• Linux驱动之INPUT设备驱动

    目录

    一、开发环境

    二、编写按键input设备的注册与事件上报

            2.1 修改设备树文件

                    1 添加 pinctrl 节点

                    2、添加 KEY 设备节点

                    3、检查 PIN 是否被其他外设使用

            2.2 驱动程序编写

            2.3 测试APP编写

            2.4 运行测试

    三、Linux内核自带按键input设备驱动

            3.1 自带按键驱动程序源码简析

            3.2 自带按键驱动程序的使用

            3.3 运行测试

            上一章已经了解了input子系统的大体框架和input设备的注册以及对应事件的上报流程，现在就写一个简单的input设备驱动实验来更加深入的理解input子系统。

            本章将分别采用以下两种方法来进行按键input设备驱动的实验：

    • 1、编写按键input设备的注册与事件上报

    • 2、Linux内核自带按键input设备驱动

    一、开发环境

    • CPU：IMX6ULL

    • 内核版本：Linux-5.19

    二、编写按键input设备的注册与事件上报

    2.1 修改设备树文件

    1 添加 pinctrl 节点

            I.MX6U-ALPHA开发板上的 KEY 使用了 UART1_CTS_B这个 PIN，打开 imx6ul-14x14-evk.dtsi ，在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为“pinctrl_key”的子节点，节点内容如下所示：

    1. pinctrl_key: keygrp {
    2.     fsl,pins = <
    3.         MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080 /* key0 */
    4.     >;
    5. };

            第 3 行，将 GPIO_IO18 这个 PIN 复用为 GPIO1_IO18。

    2、添加 KEY 设备节点

            在根节点“/”下创建 KEY 节点，节点名为“key”，节点内容如下：

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

            第 6 行， pinctrl-0 属性设置 KEY 所使用的 PIN 对应的 pinctrl 节点。

            第 7 行， key-gpio 属性指定了 KEY 所使用的 GPIO。

    3、检查 PIN 是否被其他外设使用

            本次实验中按键使用的 PIN 为 UART1_CTS_B，因此先检查 PIN 为 UART1_CTS_B 这个 PIN 有没有被其他的 pinctrl 节点使用，如果有使用的话就要屏蔽掉，然后再检查 GPIO1_IO18这个 GPIO 有没有被其他外设使用，如果有的话也要屏蔽掉。

            设备树编写完成以后使用“make dtbs”命令重新编译设备树，然后使用新编译出来的imx6ull-toto.dtb 文件启动 Linux 系统。启动成功以后进入“/proc/device-tree”目录中查看“key”节点是否存在，如果存在的话就说明设备树基本修改成功(具体还要驱动验证)，结果如下所示：

    1. / # ls /proc/device-tree/
    2. #address-cells      clock-osc           pmu
    3. #size-cells         compatible          regulator-can-3v3
    4. aliases             cpus                regulator-peri-3v3
    5. backlight-display   dts_led             regulator-sd1-vmmc
    6. beep                key                 soc
    7. chosen              memory@80000000     sound-wm8960
    8. clock-cli           model               spi4
    9. clock-di0           name                timer
    10. clock-di1           panel

    2.2 驱动程序编写

            设备树准备好以后就可以编写驱动程序了，在 input_key.c 里面输入如下内容：

    1. /*
    2.  * Copyright © toto Co., Ltd. 1998-2029. All rights reserved.
    3.  * @Description: 
    4.  * @Version: 1.0
    5.  * @Autor: Seven
    6.  * @Date: 2023-09-17 13:19:32
    7.  * @LastEditors: Seven
    8.  * @LastEditTime: 2023-09-17 16:57:23
    9.  */
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28.  
    29. #define KEYINPUT_CNT    1           /* 设备数量 */
    30. #define KEYINPUT_NAME   "inputkey"  /* 设备名字 */
    31. #define KEY_VALUE       0x1         /* 按键值 */
    32. #define KEY_INVALID     0xFF        /* 无效的按键值 */
    33. #define KEY_NUM         1           /* 按键数量 */
    34.  
    35. /* 定义按键中断操作结构体 */
    36. struct irq_keydesc {
    37.     int gpio;           /* 中断使用的gpio */
    38.     int irqnum;         /* 中断号 */
    39.     unsigned char value;/* 按键对应的键值 */
    40.     char name[10];      /* 中断名 */
    41.     irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
    42. };
    43.  
    44. /* inputkey设备信息 */
    45. struct inputkey_dev {
    46.     dev_t devid;
    47.     struct cdev cdev;
    48.     struct class *class;
    49.     struct device *device;
    50.     struct device_node *dev_nd;
    51.     struct timer_list timer;
    52.     struct irq_keydesc irq_desc[KEY_NUM];
    53.     unsigned char cur_keynum;
    54.     struct input_dev *inputdev;
    55. };
    56.  
    57. /* 定义 key 输入设备 */
    58. struct inputkey_dev inputdev;
    59.  
    60. /*
    61.  * @Brief   中断服务函数，开启定时器，
    62.  *          延时10ms用于按键消抖
    63.  * @Param   irq:中断号
    64.  * @Param   dev_id:设备结构
    65.  * @Note    NOne
    66.  * @RetVal  中断执行结果
    67.  */
    68. static irqreturn_t key_handler(int irq, void *dev_id)
    69. {
    70.     struct inputkey_dev *dev = (struct inputkey_dev *)dev_id;
    71.  
    72.     dev->cur_keynum = 0;
    73.     // dev->timer.data = (volatile long)dev_id;
    74.     mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));
    75.  
    76.     return IRQ_RETVAL(IRQ_HANDLED);
    77. }
    78.  
    79. /*
    80.  * @Brief   定时器服务函数，用于按键消抖，
    81.  *          定时器到再次读取按键值，按键还处于按下则按键有效
    82.  * @Param   t:设备结构体
    83.  * @Note    NOne
    84.  * @RetVal  NOne
    85.  */
    86. void timer_function(struct timer_list *t)
    87. {
    88.     unsigned char value, num;
    89.     struct irq_keydesc *keydesc;
    90.     struct inputkey_dev *dev = from_timer(dev, t, timer);
    91.  
    92.     num = dev->cur_keynum;
    93.     keydesc = &dev->irq_desc[num];
    94.     
    95.     /* 读取IO值 */
    96.     value = gpio_get_value(keydesc->gpio);
    97.     /* 按键按下 */
    98.     if(value == 0) {
    99.         /* 上报按键值 */
    100.         input_report_key(dev->inputdev, keydesc->value, 1);
    101.         input_sync(dev->inputdev);
    102.     } else { /* 按键松开 */
    103.         input_report_key(dev->inputdev, keydesc->value, 0);
    104.         input_sync(dev->inputdev);
    105.     }
    106. }
    107.  
    108. /*
    109.  * @Brief   按键IO初始化
    110.  * @Param   None
    111.  * @Note    NOne
    112.  * @RetVal  NOne
    113.  */
    114. static int keyio_init(void)
    115. {
    116.     unsigned char i = 0;
    117.     char name[10];
    118.     int ret = 0;
    119.  
    120.     inputdev.dev_nd = of_find_node_by_path("/key");
    121.     if (!inputdev.dev_nd) {
    122.         printk(KERN_ERR "key node not found\r");
    123.         return -EINVAL;
    124.     }
    125.  
    126.     /* 提取GPIO */
    127.     for (i = 0; i < KEY_NUM; i++) {
    128.         inputdev.irq_desc[i].gpio = 
    129.                 of_get_named_gpio(inputdev.dev_nd, "key-gpio", i);
    130.         if (inputdev.irq_desc[i].gpio < 0) {
    131.             printk(KERN_ERR "can't get key:%d\n", i);
    132.         }
    133.     }
    134.  
    135.     /* 初始化key所使用的IO, 并设置中断模式 */
    136.     for (i = 0; i < KEY_NUM; i++) {
    137.         memset(inputdev.irq_desc[i].name, 0, sizeof(name));
    138.         sprintf(inputdev.irq_desc[i].name, "KEY%d", i);
    139.         gpio_request(inputdev.irq_desc[i].gpio, 
    140.                         inputdev.irq_desc[i].name);
    141.         gpio_direction_input(inputdev.irq_desc[i].gpio);
    142.         inputdev.irq_desc[i].irqnum = 
    143.                         irq_of_parse_and_map(inputdev.dev_nd, i);
    144.     }
    145.  
    146.     /* 申请中断 */
    147.     inputdev.irq_desc[0].handler = key_handler;
    148.     inputdev.irq_desc[0].value = KEY_0;
    149.  
    150.     for (i = 0; i < KEY_NUM; i++) {
    151.         ret = request_irq(inputdev.irq_desc[i].irqnum,
    152.                         inputdev.irq_desc[i].handler,
    153.                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
    154.                         inputdev.irq_desc[i].name, &inputdev);
    155.         if (ret < 0) {
    156.             printk(KERN_ERR "irq %d request failed\n", 
    157.                             inputdev.irq_desc[i].irqnum);
    158.             return -EFAULT;
    159.         }
    160.     }
    161.  
    162.     /* 6.初始化timer */
    163.     inputdev.timer.expires = jiffies + msecs_to_jiffies(10);
    164.     timer_setup(&inputdev.timer, timer_function, 0);
    165.  
    166.     /* 申请input_dev */
    167.     inputdev.inputdev = input_allocate_device();
    168.     inputdev.inputdev->name = KEYINPUT_NAME;
    169.  
    170.     inputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) 
    171.                                 | BIT_MASK(EV_REP);
    172.     input_set_capability(inputdev.inputdev, EV_KEY, KEY_0);
    173.  
    174.     /* 注册input设备*/
    175.     ret = input_register_device(inputdev.inputdev);
    176.     if (ret) {
    177.         printk(KERN_ERR "register input device failed\n");
    178.         return ret;
    179.     }
    180.  
    181.     return 0;
    182. }
    183.  
    184. /*
    185.  * @Brief   驱动入口函数
    186.  * @Param   None
    187.  * @Note    NOne
    188.  * @RetVal  NOne
    189.  */
    190. static int __init inputkey_init(void)
    191. {
    192.     keyio_init();
    193.  
    194.     return 0;
    195. }
    196.  
    197. /*
    198.  * @Brief   驱动出口函数
    199.  * @Param   None
    200.  * @Note    NOne
    201.  * @RetVal  NOne
    202.  */
    203. static void __exit inputkey_exit(void)
    204. {
    205.     unsigned int i = 0;
    206.  
    207.     /* 删除定时器 */
    208.     del_timer_sync(&inputdev.timer);
    209.  
    210.     /* 释放中断 */
    211.     for (i = 0; i < KEY_NUM; i++) {
    212.         free_irq(inputdev.irq_desc[i].irqnum, &inputdev);
    213.     }
    214.  
    215.     /* 释放IO */
    216.     for (i = 0; i < KEY_NUM; i++) {
    217.         gpio_free(inputdev.irq_desc[i].gpio);
    218.     }
    219.  
    220.     /* 释放input设备 */
    221.     input_unregister_device(inputdev.inputdev);
    222.     input_free_device(inputdev.inputdev);
    223. }
    224.  
    225.  
    226. module_init(inputkey_init);
    227. module_exit(inputkey_exit);
    228.  
    229. MODULE_LICENSE("GPL");
    230. MODULE_AUTHOR("toto");

    2.3 测试APP编写

            input_key_app.c 测试程序具体代码如下：

    1. /*
    2.  * Copyright © toto Co., Ltd. 1998-2029. All rights reserved.
    3.  * @Description: 
    4.  * @Version: 1.0
    5.  * @Autor: Seven
    6.  * @Date: 2023-09-17 16:10:12
    7.  * @LastEditors: Seven
    8.  * @LastEditTime: 2023-09-17 21:12:01
    9.  */
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18.  
    19. /* 定义一个input_event变量，存放输入事件信息 */
    20. static struct input_event inputevt;
    21.  
    22. /*
    23.  * @Brief   main 主程序
    24.  * @Param   argc:
    25.  * @Param   argv:
    26.  * @Note    NOne
    27.  * @RetVal  0-成功;其他-失败
    28.  */
    29. int main(int argc, char *argv[])
    30. {
    31.     int fd, err;
    32.     char *filename;
    33.  
    34.     if (argc != 2) {
    35.         printf("argc != 3\n");
    36.         return -1;
    37.     }
    38.  
    39.     filename = argv[1];
    40.  
    41.     /*打开驱动文件*/
    42.     fd = open(filename, O_RDWR);
    43.     if (fd < 0) {
    44.         printf("open filename:%d failed\n", filename);
    45.         return -1;
    46.     }
    47.  
    48.     while (1) {
    49.         err = read(fd, &inputevt, sizeof(inputevt));
    50.         if (err <= 0) {
    51.             printf("read inputevt failed\n");
    52.             continue;
    53.         }
    54.  
    55.         switch (inputevt.type)
    56.         {
    57.         case EV_KEY:
    58.             printf("key %d %s\n", inputevt.code, 
    59.                         inputevt.value ? "down" : "up");
    60.             break;
    61.         case EV_REL:
    62.             break;
    63.         case EV_ABS:
    64.             break;
    65.         case EV_MSC:
    66.             break;
    67.         case EV_SW:
    68.             break;
    69.         default:
    70.             break;
    71.         }
    72.     }
    73.  
    74.     /*关闭文件*/
    75.     close(fd);
    76.  
    77.     return 0;
    78. }

    2.4 运行测试

            开发板上电，将input_key.ko 和 input_key_app 这两个文件拷贝到 /lib/modules/5.19.0-g794a2f7be62d-dirty/ 目录中，在加载input_key.ko之前，先来看一下/dev/input 目录下都有哪些文件，结果如下所示：

    1. / # ls -al /dev/input/
    2. total 0
    3. drwxr-xr-x    2 0        0               80 Jan 19 19:30 .
    4. drwxr-xr-x    6 0        0             2880 Jan 19 19:25 ..
    5. crw-rw----    1 0        0          13,  64 Jan  1 00:00 event0

            从上面可以看出，当前/dev/input 目录只有 event0 这一个文件。接下来输入如下命令加载 input_key.ko 这个驱动模块。

    1. / # insmod /lib/modules/5.19.0-g794a2f7be62d-dirty/input_key.ko 
    2. [  310.665956] input_key: loading out-of-tree module taints kernel.
    3. [  310.678432] input: inputkey as /devices/virtual/input/input2

            当驱动模块加载成功以后再来看一下/dev/input 目录下有哪些文件，结果如下所示：

    1. / # ls -al /dev/input/
    2. total 0
    3. drwxr-xr-x    2 0        0               80 Jan 19 19:30 .
    4. drwxr-xr-x    6 0        0             2880 Jan 19 19:25 ..
    5. crw-rw----    1 0        0          13,  64 Jan  1 00:00 event0
    6. crw-------    1 0        0          13,  65 Jan 19 19:30 event1

            从上面可以看出，多了一个 event1 文件，因此/dev/input/event1 就是注册的驱动所对应的设备文件。 input_key_app 就是通过读取/dev/input/event1 这个文件来获取输入事件信息的，输入如下测试命令：

    ./input_key_app /dev/input/event1

            然后按下开发板上的 KEY 按键，结果如下所示：

    1. /home/app # ./input_key_app /dev/input/event1
    2. key 11 down
    3. key 11 up
    4. key 11 down
    5. key 11 up
    6. key 11 down
    7. key 11 up
    8. key 11 down
    9. key 11 up

            从上面可以看出，当我们按下或者释放开发板上的按键以后都会在终端上输出相应的内容，提示我们哪个按键按下或释放了，在 Linux 内核中 KEY_0 为 11。

            另外，我们也可以不用 input_key_app 来测试驱动，可以直接使用 hexdump 命令来查看/dev/input/event1 文件内容，输入如下命令：

    hexdump /dev/input/event1

            然后按下按键，终端输出如下所示信息：

    1. / # hexdump /dev/input/event1
    2. 0000000 079e 0019 8806 0004 0001 000b 0001 0000
    3. 0000010 079e 0019 8806 0004 0000 0000 0000 0000
    4. 0000020 079e 0019 6be6 0007 0001 000b 0000 0000
    5. 0000030 079e 0019 6be6 0007 0000 0000 0000 0000
    6. 0000040 079f 0019 2861 0003 0001 000b 0001 0000
    7. 0000050 079f 0019 2861 0003 0000 0000 0000 0000
    8. 0000060 079f 0019 d5a2 0004 0001 000b 0000 0000
    9. 0000070 079f 0019 d5a2 0004 0000 0000 0000 0000
    10. 0000080 07a0 0019 69a9 0000 0001 000b 0001 0000
    11. 0000090 07a0 0019 69a9 0000 0000 0000 0000 0000
    12. 00000a0 07a0 0019 14f8 0002 0001 000b 0000 0000
    13. 00000b0 07a0 0019 14f8 0002 0000 0000 0000 0000

            上面就是 input_event 类型的原始事件数据值，采用十六进制表示，这些原始数据的含义如下：

    1. /*****************input_event 类型********************/
    2. /* 编号 */    /* tv_sec */    /* tv_usec */    /* type */    /* code */    /* value */
    3.  
    4. 0000000       079e 0019       8806 0004        0001         000b           0001 0000
    5. 0000010       079e 0019       8806 0004        0000         0000           0000 0000
    6. 0000020       079e 0019       6be6 0007        0001         000b           0000 0000
    7. 0000030       079e 0019       6be6 0007        0000         0000           0000 0000

            type 为事件类型，查看示例代码 58.1.2.3 可知， EV_KEY 事件值为 1， EV_SYN 事件值为0。因此第 1 行表示 EV_KEY 事件，第 2 行表示 EV_SYN 事件。

            code 为事件编码，也就是按键号，查看示例代码 58.1.2.4 可以， KEY_0 这个按键编号为 11，对应的十六进制为 0xb，因此第1 行表示 KEY_0 这个按键事件，最后的 value 就是按键值，为 1 表示按下，为 0 的话表示松开。

    综上所述，"hexdump /dev/input/event1" 中的原始事件值含义如下：

    • 第 1 行，按键(KEY_0)按下事件。

    • 第 2 行， EV_SYN 同步事件，因为每次上报按键事件以后都要同步的上报一个 EV_SYN 事件。

    • 第 3 行，按键(KEY_0)松开事件。

    • 第 4 行， EV_SYN 同步事件，和第 2 行一样。

    三、Linux内核自带按键input设备驱动

    3.1 自带按键驱动程序源码简析

            Linux 内核也自带了 KEY 驱动，如果要使用内核自带的 KEY 驱动的话需要配置 Linux 内核，不过 Linux 内核一般默认已经使能了 KEY 驱动，但是我们还是要检查一下。按照如下路径找到相应的配置选项：

    1. -> Device Drivers
    2.     -> Input device support
    3.         -> Generic input layer (needed for keyboard, mouse, ...) (INPUT [=y])
    4.         -> Keyboards (INPUT_KEYBOARD [=y])
    5.                 ->GPIO Buttons

    选中“GPIO Buttons”选项，将其编译进 Linux 内核中【默认是选中的】，如下图所示：

     

    bbab636c0f0b06145393dc015436f532.png

            选中以后就会在.config 文件中出现“CONFIG_KEYBOARD_GPIO=y”这一行， Linux 内核就会根据这一行来将 KEY 驱动文件编译进 Linux 内核。

            Linux 内核自带的 KEY 驱动文件为drivers/input/keyboard/gpio_keys.c， gpio_keys.c 采用了 platform 驱动框架，在 KEY 驱动上使用了 input 子系统实现。在 gpio_keys.c 文件中找到如下所示内容：

    1. static const struct of_device_id gpio_keys_of_match[] = {
    2.     { .compatible = "gpio-keys", },
    3.     { },
    4. };
    5. MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
    6.  
    7. static int gpio_keys_probe(struct platform_device *pdev)
    8. ......
    9. static struct platform_driver gpio_keys_device_driver = {
    10.     .probe      = gpio_keys_probe,
    11.     .shutdown   = gpio_keys_shutdown,
    12.     .driver     = {
    13.         .name   = "gpio-keys",
    14.         .pm = &gpio_keys_pm_ops,
    15.         .of_match_table = gpio_keys_of_match,
    16.         .dev_groups = gpio_keys_groups,
    17.     }
    18. };
    19.  
    20. static int __init gpio_keys_init(void)
    21. {
    22.     return platform_driver_register(&gpio_keys_device_driver);
    23. }
    24.  
    25. static void __exit gpio_keys_exit(void)
    26. {
    27.     platform_driver_unregister(&gpio_keys_device_driver);
    28. }
    29.  
    30. late_initcall(gpio_keys_init);
    31. module_exit(gpio_keys_exit);
    32.  
    33. MODULE_LICENSE("GPL");
    34. MODULE_AUTHOR("Phil Blundell ");
    35. MODULE_DESCRIPTION("Keyboard driver for GPIOs");
    36. MODULE_ALIAS("platform:gpio-keys");

            从上面的代码可以看出，这就是一个标准的 platform 驱动框架，如果要使用设备树来描述 KEY 设备信息的话，设备节点的 compatible 属性值要设置为“gpio-keys”。当设备和驱动匹配以后 gpio_keys_probe 函数就会执行， gpio_keys_probe 函数内容如下：

    1. static int gpio_keys_probe(struct platform_device *pdev)
    2. {
    3.     struct device *dev = &pdev->dev;
    4.     const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
    5.     struct fwnode_handle *child = NULL;
    6.     struct gpio_keys_drvdata *ddata;
    7.     struct input_dev *input;
    8.     int i, error;
    9.     int wakeup = 0;
    10.  
    11.     if (!pdata) {
    12.         pdata = gpio_keys_get_devtree_pdata(dev);
    13.         if (IS_ERR(pdata))
    14.             return PTR_ERR(pdata);
    15.     }
    16.     ......
    17.     input = devm_input_allocate_device(dev);
    18.     if (!input) {
    19.         dev_err(dev, "failed to allocate input device\n");
    20.         return -ENOMEM;
    21.     }
    22.  
    23.     ddata->pdata = pdata;
    24.     ddata->input = input;
    25.     mutex_init(&ddata->disable_lock);
    26.  
    27.     platform_set_drvdata(pdev, ddata);
    28.     input_set_drvdata(input, ddata);
    29.  
    30.     input->name = pdata->name ? : pdev->name;
    31.     input->phys = "gpio-keys/input0";
    32.     input->dev.parent = dev;
    33.     input->open = gpio_keys_open;
    34.     input->close = gpio_keys_close;
    35.  
    36.     input->id.bustype = BUS_HOST;
    37.     input->id.vendor = 0x0001;
    38.     input->id.product = 0x0001;
    39.     input->id.version = 0x0100;
    40.  
    41.     input->keycode = ddata->keymap;
    42.     input->keycodesize = sizeof(ddata->keymap[0]);
    43.     input->keycodemax = pdata->nbuttons;
    44.  
    45.     /* Enable auto repeat feature of Linux input subsystem */
    46.     if (pdata->rep)
    47.         __set_bit(EV_REP, input->evbit);
    48.  
    49.     for (i = 0; i < pdata->nbuttons; i++) {
    50.         const struct gpio_keys_button *button = &pdata->buttons[i];
    51.  
    52.         if (!dev_get_platdata(dev)) {
    53.             child = device_get_next_child_node(dev, child);
    54.             if (!child) {
    55.                 dev_err(dev,
    56.                     "missing child device node for entry %d\n",
    57.                     i);
    58.                 return -EINVAL;
    59.             }
    60.         }
    61.  
    62.         error = gpio_keys_setup_key(pdev, input, ddata,
    63.                         button, i, child);
    64.         if (error) {
    65.             fwnode_handle_put(child);
    66.             return error;
    67.         }
    68.  
    69.         if (button->wakeup)
    70.             wakeup = 1;
    71.     }
    72.  
    73.     fwnode_handle_put(child);
    74.  
    75.     error = input_register_device(input);
    76.     if (error) {
    77.         dev_err(dev, "Unable to register input device, error: %d\n",
    78.             error);
    79.         return error;
    80.     }
    81.  
    82.     device_init_wakeup(dev, wakeup);
    83.  
    84.     return 0;
    85. }

    大致可以总结如下：

    • 调用 gpio_keys_get_devtree_pdata 函数从设备树中获取到 KEY 相关的设备节点信息。

    • 调用 devm_input_allocate_device 函数申请 input_dev。

    • 初始化 input_dev。

    • 设置 input_dev 事件，这里设置了 EV_REP 事件。

    • 调用 gpio_keys_setup_key 函数继续设置 KEY，此函数会设置 input_dev 的EV_KEY 事件已经事件码(也就是 KEY 模拟为哪个按键)。

    • 调用 input_register_device 函数向 Linux 系统注册 input_dev。

    接下来再来看一下 gpio_keys_setup_key 函数，此函数内容如下：

    1. static int gpio_keys_setup_key(struct platform_device *pdev,
    2.                 struct input_dev *input,
    3.                 struct gpio_keys_drvdata *ddata,
    4.                 const struct gpio_keys_button *button,
    5.                 int idx,
    6.                 struct fwnode_handle *child)
    7. {
    8.     const char *desc = button->desc ? button->desc : "gpio_keys";
    9.     struct device *dev = &pdev->dev;
    10.     struct gpio_button_data *bdata = &ddata->data[idx];
    11.     irq_handler_t isr;
    12.     unsigned long irqflags;
    13.     int irq;
    14.     int error;
    15.  
    16.     bdata->input = input;
    17.     bdata->button = button;
    18.     spin_lock_init(&bdata->lock);
    19.  
    20.     if (child) {
    21.         bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
    22.                              NULL, GPIOD_IN, desc);
    23.         if (IS_ERR(bdata->gpiod)) {
    24.             error = PTR_ERR(bdata->gpiod);
    25.             if (error == -ENOENT) {
    26.                 /*
    27.                  * GPIO is optional, we may be dealing with
    28.                  * purely interrupt-driven setup.
    29.                  */
    30.                 bdata->gpiod = NULL;
    31.             } else {
    32.                 if (error != -EPROBE_DEFER)
    33.                     dev_err(dev, "failed to get gpio: %d\n",
    34.                         error);
    35.                 return error;
    36.             }
    37.         }
    38.     } else if (gpio_is_valid(button->gpio)) {
    39.         /*
    40.          * Legacy GPIO number, so request the GPIO here and
    41.          * convert it to descriptor.
    42.          */
    43.         unsigned flags = GPIOF_IN;
    44.  
    45.         if (button->active_low)
    46.             flags |= GPIOF_ACTIVE_LOW;
    47.  
    48.         error = devm_gpio_request_one(dev, button->gpio, flags, desc);
    49.         if (error < 0) {
    50.             dev_err(dev, "Failed to request GPIO %d, error %d\n",
    51.                 button->gpio, error);
    52.             return error;
    53.         }
    54.  
    55.         bdata->gpiod = gpio_to_desc(button->gpio);
    56.         if (!bdata->gpiod)
    57.             return -EINVAL;
    58.         .......
    59.         INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
    60.  
    61.         hrtimer_init(&bdata->debounce_timer,
    62.                  CLOCK_REALTIME, HRTIMER_MODE_REL);
    63.         bdata->debounce_timer.function = gpio_keys_debounce_timer;
    64.  
    65.         isr = gpio_keys_gpio_isr;
    66.         irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
    67.         ......
    68.         bdata->irq = button->irq;
    69.  
    70.         if (button->type && button->type != EV_KEY) {
    71.             dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
    72.             return -EINVAL;
    73.         }
    74.  
    75.         bdata->release_delay = button->debounce_interval;
    76.         hrtimer_init(&bdata->release_timer,
    77.                  CLOCK_REALTIME, HRTIMER_MODE_REL_HARD);
    78.         bdata->release_timer.function = gpio_keys_irq_timer;
    79.  
    80.         isr = gpio_keys_irq_isr;
    81.         irqflags = 0;
    82.  
    83.         /*
    84.          * For IRQ buttons, there is no interrupt for release.
    85.          * So we don't need to reconfigure the trigger type for wakeup.
    86.          */
    87.     }
    88.  
    89.     bdata->code = &ddata->keymap[idx];
    90.     *bdata->code = button->code;
    91.     input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
    92.     ......
    93.     return 0;
    94. }

            调用 input_set_capability 函数设置 EV_KEY 事件以及 KEY 的按键类型，也就是 KEY 作为哪个按键？我们会在设备树里面设置指定的 KEY 作为哪个按键。

            一切都准备就绪以后剩下的就是等待按键按下，然后向 Linux 内核上报事件，事件上报是在 gpio_keys_irq_isr 函数中完成的，此函数内容如下：

    1. static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
    2. {
    3.     struct gpio_button_data *bdata = dev_id;
    4.     struct input_dev *input = bdata->input;
    5.     unsigned long flags;
    6.  
    7.     BUG_ON(irq != bdata->irq);
    8.  
    9.     spin_lock_irqsave(&bdata->lock, flags);
    10.  
    11.     if (!bdata->key_pressed) {
    12.         if (bdata->button->wakeup)
    13.             pm_wakeup_event(bdata->input->dev.parent, 0);
    14.  
    15.         input_event(input, EV_KEY, *bdata->code, 1);
    16.         input_sync(input);
    17.  
    18.         if (!bdata->release_delay) {
    19.             input_event(input, EV_KEY, *bdata->code, 0);
    20.             input_sync(input);
    21.             goto out;
    22.         }
    23.  
    24.         bdata->key_pressed = true;
    25.     }
    26.  
    27.     if (bdata->release_delay)
    28.         hrtimer_start(&bdata->release_timer,
    29.                   ms_to_ktime(bdata->release_delay),
    30.                   HRTIMER_MODE_REL_HARD);
    31. out:
    32.     spin_unlock_irqrestore(&bdata->lock, flags);
    33.     return IRQ_HANDLED;
    34. }

            gpio_keys_irq_isr 是按键中断处理函数，调用 "input_event" 向 Linux 系统上报 EV_KEY 事件，表示按键按下。调用 "input_sync" 使用 input_sync 函数向系统上报 EV_REP 同步事件。

            综上所述， Linux 内核自带的 gpio_keys.c 驱动文件思路和前面编写的 input_key.c 驱动文件基本一致。都是申请和初始化 input_dev，设置事件，向 Linux 内核注册 input_dev。最终在按键中断服务函数或者消抖定时器中断服务函数中上报事件和按键值。

    3.2 自带按键驱动程序的使用

            要使用 Linux 内核自带的按键驱动程序很简单，只需要根据 Documentation/devicetree/bindings/input/gpio-keys.yaml 这个文件在设备树中添加指定的设备节点即可，节点要求如下：

    • ①、节点名字为“gpio-keys”。

    • ②、 gpio-keys 节点的 compatible 属性值一定要设置为“gpio-keys”。

    • ③、所有的 KEY 都是 gpio-keys 的子节点，每个子节点可以用如下属性描述：

      • gpios： KEY 所连接的 GPIO 信息

      • interrupts： KEY 所使用 GPIO 中断信息，不是必须的，可以不写

      • label： KEY 名字

      • linux,code： KEY 要模拟的按键。

    • ④、如果按键要支持连按的话要加入 autorepeat。

            打开 imx6ul-14x14-evk.dtsi ，根据上面的要求创建对应的设备节点，设备节点内容如下所示：

    1. gpio-keys {
    2.     compatible = "gpio-keys";
    3.     #address-cells = <1>;
    4.     #size-cells = <0>;
    5.     autorepeat;
    6.     
    7.     key0 {
    8.         labal = "GPIO Key Enter";
    9.         linux,code = ;
    10.         gpios = <&gpio1 18 GPIO_ACTIVE_LOW>;
    11.     };
    12. };

    • autorepeat 表示按键支持连按。

    • ALPHA 开发板 KEY 按键信息，名字设置为“GPIO Key Enter”，这里我们将开发板上的 KEY 按键设置为“EKY_ENTER”这个按键键值为28，也就是回车键，效果和键盘上的回车键一样。

    • 设置 KEY 所使用的 IO 为 GPIO1_IO18，一定要检查一下设备树看看此 GPIO 有没有被用到其他外设上，如果有的话要删除掉相关代码！

    3.3 运行测试

            重新编译设备树，然后用新编译出来的 设备树dtb 启动 Linux 系统，系统启动以后查看/dev/input 目录，看看都有哪些文件，结果如下所示：

    1. / # ls -al /dev/input/
    2. total 0
    3. drwxr-xr-x    2 0        0               80 Jan 20 00:34 .
    4. drwxr-xr-x    6 0        0             2880 Jan 20 00:34 ..
    5. crw-rw----    1 0        0          13,  64 Jan  1 00:00 event0
    6. crw-rw----    1 0        0          13,  65 Jan 20 00:34 event1

    从上面可以看出存在 event1 这个文件，这个文件就是 KEY 对应的设备文件，使用hexdump 命令来查看/dev/input/event1 文件，输入如下命令：

    hexdump /dev/input/event1

    然后按下 ALPHA 开发板上的按键，终端输出如下所示内容：

    1. / # hexdump /dev/input/event1
    2. 0000000 157f 0019 80d4 000d 0001 001c 0001 0000
    3. 0000010 157f 0019 80d4 000d 0000 0000 0000 0000
    4. 0000020 1580 0019 001c 0001 0001 001c 0000 0000
    5. 0000030 1580 0019 001c 0001 0000 0000 0000 0000
    6. 0000040 1580 0019 f8a0 000b 0001 001c 0001 0000
    7. 0000050 1580 0019 f8a0 000b 0000 0000 0000 0000
    8. 0000060 1580 0019 0aef 000f 0001 001c 0000 0000
    9. 0000070 1580 0019 0aef 000f 0000 0000 0000 0000
    10. 0000080 1581 0019 7e19 0009 0001 001c 0001 0000
    11. 0000090 1581 0019 7e19 0009 0000 0000 0000 0000
    12. 00000a0 1581 0019 30e4 000c 0001 001c 0000 0000
    13. 00000b0 1581 0019 30e4 000c 0000 0000 0000 0000

            按下 KEY 按键以后会在终端上输出如上所示的信息，表示 Linux 内核的按键驱动工作正常。至于上述中内容的含义就参照前面2.4节中的介绍，进行分析。

             关于更多嵌入式C语言、FreeRTOS、RT-Thread、Linux应用编程、linux驱动等相关知识，关注公众号【嵌入式Linux知识共享】，后续精彩内容及时收看了解。

     

  • 相关阅读:
    MySQL
    Matlab|【EI复现】电动汽车集群并网的分布式鲁棒优化调度模型
    数据结构--串的基本概念
    【mediasoup】处理rtp包：h264探测是否关键帧
    过五关，斩六将！「网易/美团/菜鸟」已拿offer【Java岗】
    斯坦福密码学 —— 02流密码
    c++（六）
    02_面向对象高级_继承
    maven 安装本地jar失败 错误指南
    mysql笔记：11. 性能优化
  • 原文地址：https://blog.csdn.net/Wang_XB_3434/article/details/132957576