[关闭]
@babydragon 2015-11-05T10:03:57.000000Z 字数 34660 阅读 2536

编写Linux内核模块——第三部分：按键和发光二极管

他山之石

【编者的话】了解了基本的内核模块开发、内核空间和用户空间交互之后，终于要开始和硬件设备直接交互了。Linux内核提供了对通用输入输出接口、中断请求等的封装，让驱动开发者可以利用中断来控制硬件线路上的设备。本文来自Derek Molloy的博客，通过三个示例，讲解了通用输入输出接口和中断编程，内核对象和内核线程的使用。

前言

在本系列文章中，我们已经知道了如何为嵌入式Linux设备编写可加载内核模块（loadable kernel module，LKM）。这是本系列的第三篇文章，在阅读本文之前，请先阅读：

这两篇文章介绍了如何构建、加载和卸载可加载内核模块和字符设备驱动。这些细节不会在本文中重复。

本文描述了如何编写内核代码，使之能够和连接到嵌入式Linux系统通用输入输出接口（GPIO）的定制电子电路交互。同时也将介绍如何为这种嵌入式Linux系统中默认不支持的设备添加高级功能。本文使用BeagleBone作为部署平台，为了完成本文实验，使用BeagleBone是理想的方案，但不是必须的。

本文的重点是教学和实践，而不是解决一个深入实际的需求。但我相信如果读者能够阅读按键和发光二极管闪烁实验，那么也可以实现和大部分电子设备交互。因此，本文描述了三个不同的可加载内核模块，每个都有它自己独立的目的和需求：

和按钮、闪烁的发光二极管交互有其他简单的方式，但是这些示例介绍了一些对于处理复杂内核任务编程来说至关重要的概念。

视频演示

这里提供了一段YouTube上的短片，它呈现了本文开发的可加载内核模块的功能概述。

https://youtu.be/ltCZydX_zmk
视频1：本文描述的可加载内核模块的功能

电路

本文使用的唯一电路如图1所示。这是和《Exploring BeagleBone》书第六章相同的图，为了方便直接在这里使用。作为书中详细介绍的，使用了一个场效应管（Field Effect Transistor，FET）（小信号晶体管）作为发光二极管门电路，它确保了点亮发光二极管的电流不会损坏BeagleBone。可以通过串联一个大限流电阻，直接将发光二极管连接到通用输入输出接口上，但这是不建议的。图中按钮没有使用上拉或者下拉电阻，这是因为BeagleBone的P9_27端口默认配置了一个内置的下拉电阻。在连接类似电路的时候总是需要非常的小心，任何一个失误都可能导致BeagleBone损坏！

电路图
图1：本文描述的发光二极管和按键电路

本次讨论的源码

本次讨论的所有代码都在为《Exploring BeagleBone》准备的GitHub仓库上。代码可以在ExploringBB GitHub仓库内核工程目录中公开查看，或者也可以将代码复制到BeagleBone（或者其他Linux设备）：

  1. molloyd@beaglebone:~$ sudo apt-get install git
  2. molloyd@beaglebone:~$ git clone https://github.com/derekmolloy/exploringBB.git

代码中/extras/kernel/目录中的gpio_test、button和led是本文最重要的几个目录。为这些示例代码自动生成的Doxygen文档有HTML格式和PDF格式。

示例1：按钮按下，发光二极管亮起可加载内核模块

当在嵌入式Linux设备中和电子电路进行交互的时候，开发者立即需要面对sysfs文件系统，同时需要使用低级别文件操作。这种方式可能会导致效率低下（特别是对传统嵌入式系统有开发经验时），然而，这些文件项会使用内存映射，对于大部分应用程序性能来说是足够的。在我的书中，我已经证明了，通过使用pthread库、回调函数和sys/poll.h，在忽略CPU开销后，可以实现响应时间大约在三分之一毫秒。

和Linux用户空间不同，Linux内核空间支持中断。本文第一个示例演示了如何编写一个使用通用输入输出接口和中断的可加载内核模块，实现比在用户空间更快的响应时间。我不建议开发者将所有通用输入输出接口代码都在内核空间实现，但是这些示例可能可以提供一些启发，开发者可以在内核空间执行独立的任务，高级别代码仍然可以在Linux用户空间编写。

通用输入输出接口和内核

通用输入输出接口（General Purpose Input/Outputs，GPIOs）在书中第6章和前文/视频中有详细描述。这些软件控制的输入输出接口，能够在Linux用户空间使用通用输入输出接口的sysfs接口控制（直接使用Linux shell或者在可执行程序中操作），这些接口能够让开发者激活通用输入输出接口或者设置它的状态。比如，要通过sysfs激活图1中的发光二极管并开启/关闭发光二极管，可以用如下步骤实现（使用超级用户权限）：

  1. root@beaglebone:/sys/class/gpio# ls
  2. export  gpiochip0  gpiochip32  gpiochip64  gpiochip96  unexport
  3. root@beaglebone:/sys/class/gpio# echo 49 > export
  4. root@beaglebone:/sys/class/gpio# ls
  5. export  gpio49  gpiochip0  gpiochip32  gpiochip64  gpiochip96  unexport
  6. root@beaglebone:/sys/class/gpio# cd gpio49
  7. root@beaglebone:/sys/class/gpio/gpio49# ls
  8. active_low  direction  edge  power  subsystem  uevent  value
  9. root@beaglebone:/sys/class/gpio/gpio49# echo out > direction
  10. root@beaglebone:/sys/class/gpio/gpio49# echo 1 > value
  11. root@beaglebone:/sys/class/gpio/gpio49# echo 0 > value
  12. root@beaglebone:/sys/class/gpio/gpio49# cd ..
  13. root@beaglebone:/sys/class/gpio# echo 49 > unexport
  14. root@beaglebone:/sys/class/gpio# ls
  15. export  gpiochip0  gpiochip32  gpiochip64  gpiochip96  unexport

有趣的是，在Linux内核空间控制通用输入输出接口的步骤和上述步骤非常类似。Linux通用输入输出接口，可以通过linux/gpio.h（3.8.x版本）头文件中定义的函数在内核空间方便的访问和控制。这里列举了包含在该头文件中的一些重要的函数：

  1. static inline bool gpio_is_valid(int number)            // 检查通用输入输出接口号是否有效（在BeagleBone开发版上最大值是127）
  2. static inline int  gpio_request(unsigned gpio, const char *label)        // 分配通用输入输出接口号和提供给sysfs的标签
  3. static inline int  gpio_export(unsigned gpio, bool direction_may_change) // 通过sysfs激活接口，并且决定端口方向，可以从输入变成输出，反之亦然
  4. static inline int  gpio_direction_input(unsigned gpio)  // 设置为输入方向（和通常一样，成功返回0）
  5. static inline int  gpio_get_value(unsigned gpio)        // 获取输入输出接口设置的值（方向）
  6. static inline int  gpio_direction_output(unsigned gpio, int value)       // 值是当前状态
  7. static inline int  gpio_set_debounce(unsigned gpio, unsigned debounce)   // 以毫秒为单位设置去抖动时间（平台相关）
  8. static inline int  gpio_sysfs_set_active_low(unsigned gpio, int value)   // 设置低电平有效（反转运行状态）
  9. static inline void gpio_unexport(unsigned gpio)         // 从sysfs移除
  10. static inline void gpio_free(unsigned gpio)             // 释放通用输入输出端口
  11. static inline int  gpio_to_irq(unsigned gpio)           // 与中断请求关联

重要的是，通过上述列表中的最后一个函数，可以将一个中断请求（interrupt request，IRQ）关联到通用输入输出接口上。中断请求允许开发者构建有效率、高性能的代码来检测输入状态改变。我们将在下面讨论中断和在Linux操作系统上的使用。有关Linux系统上使用输入输出接口使用的更多信息，参阅：

中断

中断是从连接的硬件设备、软件应用程序或者电路发送给微处理器的信号，该信号标示了有需要关注的事件发生。中断是高优先级条件，它大致的含义是“中断当前正在做的事情，做一些其他事情”。处理器挂起当前活动，保存当前状态并且执行中断处理函数，这也被成为中断服务例程（interrupt service routine，ISR）。一旦处理函数执行完毕，处理器重新加载之前的状态，继续进行之前的活动。

可加载内核模块驱动必须注册中断的处理函数，它定义了当中断发生时需要执行的操作。在本例中处理函数命名为ebbgpio_irq_handler()，它的形式如下：

  1. static irq_handler_t ebbgpio_irq_handler(unsigned int irq, void *dev_id, struct pt_regs *regs) { 
  2.    // 中断发生时需要执行的操作
  3.    … }

处理函数然后通过request_irq()函数注册为中断请求（IRQ），步骤如下：

  1. result = request_irq(irqNumber,               // 注册的中断号 
  2.          (irq_handler_t) ebbgpio_irq_handler, // 指向中断处理函数的指针（如上所示）
  3.          IRQF_TRIGGER_RISING,                 // 中断在上升沿（图1中按键按下）
  4.          "ebb_gpio_handler",                  // 用于在/proc/interrupts中标识拥有者
  5.          NULL);                               // 共享中断的设备id，这里为NULL

中断号在列表2的示例代码中是自动确定的，它通过将中断号和各自的通用输入输出端口号关联，重要的是，通用输入输出号不是中断号，然而，他们有一对一映射。

要取消中断请求响应，有一个对应的free_irq()函数。在第一个示例中，free_irq()函数在ebbgpio_exit()函数中调用，也就是在可加载模块卸载的时候调用。

在本例中，一个简单的瞬时按钮（如图1所示），被用于在按键按下去的上升沿产生一个中断。它也可以在下降沿创建一个中断，列表1的代码，通过/include/linux/interrupt.h头文件，提供了中断定义集合。这些标记可以通过按位或运算符进行结合，提供精确中断配置控制。

  1. #define IRQF_TRIGGER_NONE       0x00000000
  2. #define IRQF_TRIGGER_RISING     0x00000001
  3. #define IRQF_TRIGGER_FALLING    0x00000002
  4. #define IRQF_TRIGGER_HIGH       0x00000004
  5. #define IRQF_TRIGGER_LOW        0x00000008
  6. #define IRQF_TRIGGER_MASK       (IRQF_TRIGGER_HIGH   | IRQF_TRIGGER_LOW | \
  7.                                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
  8. #define IRQF_TRIGGER_PROBE      0x00000010
  9. #define IRQF_DISABLED           0x00000020  // 当调用中断处理函数的时候关闭中断请求
  10. #define IRQF_SHARED             0x00000080  // 允许多个设备间共享中断请求
  11. #define IRQF_PROBE_SHARED       0x00000100  // 当希望共享错配发生时，由调用方设置
  12. #define __IRQF_TIMER            0x00000200  // 用于标记当前中断是定时器中断的标志
  13. #define IRQF_PERCPU             0x00000400  // 中断是每个CPU的
  14. #define IRQF_NOBALANCING        0x00000800  // 将当前中断从中断请求平衡中排除的标志
  15. #define IRQF_IRQPOLL            0x00001000  // 中断用于轮询
  16. #define IRQF_ONESHOT            0x00002000  // 当中断处理函数结束后，中断不会再使能
  17. #define IRQF_NO_SUSPEND         0x00004000  // 在挂起时不要禁止当前中断请求
  18. #define IRQF_FORCE_RESUME       0x00008000  // 在挂起恢复是强制使能，即使设置了IRQF_NO_SUSPEND标志
  19. #define IRQF_NO_THREAD          0x00010000  // 中断不能使用线程
  20. #define IRQF_EARLY_RESUME       0x00020000  // 尽早在syscore阶段恢复，而不是在设备恢复时间恢复
  21. #define IRQF_TIMER              (__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD)

列表1：可用的中断标志位（参见：/usr/src/linux-headers…/include/linux/interrupt.h）

第一个可加载内核模块的完整源码在列表2中提供。示例代码中的注释为每个函数的角色提供了描述。参见GitHub仓库目录：/extras/kernel/gpio_test/gpio_test.c。该示例中的代码很大程度上基于本系列前两篇文章中的描述。

  1. /**
  2.  * @file   gpio_test.c
  3.  * @author Derek Molloy
  4.  * @date   2015年4月19日
  5.  * @brief  控制通用输入输出接口上的发光二极管/按键对的内核模块。
  6.  * 该设备通过sysfs挂载到/sys/class/gpio/gpio115和gpio49。因此该测试用可加载内核模块假设发光二极管连接到了
  7.  * 通用输入输出接口49端口（BeagleBone的P9_23针脚），按键连接到了通用输入输出接口115端口（BeagleBone的P9_27针脚）。 
  8.  * 对针脚定义不需要自定义，因为这些针脚在处于其默认复用模式状态。
  9.  * @see http://www.derekmolloy.ie/
  10. */
  12. #include <linux/init.h>
  13. #include <linux/module.h>
  14. #include <linux/kernel.h>
  15. #include <linux/gpio.h>                 // 通用输入输出接口相关函数需要
  16. #include <linux/interrupt.h>            // 中断请求代码需要
  18. MODULE_LICENSE("GPL");
  19. MODULE_AUTHOR("Derek Molloy");
  20. MODULE_DESCRIPTION("A Button/LED test driver for the BBB");
  21. MODULE_VERSION("0.1");
  23. static unsigned int gpioLED = 49;       ///< 硬编码发光二极管端口，本例中为P9_23针脚（通用输入输出49端口）
  24. static unsigned int gpioButton = 115;   ///< 硬编码按键端口，本例中尉P9_27针脚（通用输入输出115端口）
  25. static unsigned int irqNumber;          ///< 用于本文件中共享中断请求号
  26. static unsigned int numberPresses = 0;  ///< 信息记录，保存按键按下次数
  27. static bool     ledOn = 0;          ///< 发光二极管是关闭还是开启？用于反转它的状态（默认是关闭的）
  29. /// 自定义中断请求处理函数的函数原型，参见下方实现
  30. static irq_handler_t  ebbgpio_irq_handler(unsigned int irq, void *dev_id, struct pt_regs *regs);
  32. /** @brief 可加载内核模块初始化还书
  33.  *  static关键字将本函数的可见范围限制在本C文件中。
  34.  *  __init宏表示当该函数用于内置驱动（非可加载内核模块）时，只在初始化时候使用，
  35.  *  在该阶段以后可以废弃并回收内存。在本例中，
  36.  *  该函数设置通用输入输出接口和中断请求。
  37.  *  @return 如果成功返回0
  38.  */
  39. static int __init ebbgpio_init(void){
  40.    int result = 0;
  41.    printk(KERN_INFO "GPIO_TEST: Initializing the GPIO_TEST LKM\n");
  42.    // 通用输入输出接口号是否有效？（例如BBB有4x32个，但不都是有效的）
  43.    if (!gpio_is_valid(gpioLED)){
  44.       printk(KERN_INFO "GPIO_TEST: invalid LED GPIO\n");
  45.       return -ENODEV;
  46.    }
  47.    // 开始设置发光二极管。它使用通用输入输出接口输出模式，默认会开启。
  48.    ledOn = true;
  49.    gpio_request(gpioLED, "sysfs");          // gpioLED变量被硬编码为49，请求它
  50.    gpio_direction_output(gpioLED, ledOn);   // 设置通用输入输出接口为输出默认，并且开启
  51. // gpio_set_value(gpioLED, ledOn);          // 因为上面已经设置过，这里不需要设置（仅作为参照）
  52.    gpio_export(gpioLED, false);             // 使得gpio49在/sys/class/gpio目录中显示
  53.                                 // 布尔参数防止方向被改变
  54.    gpio_request(gpioButton, "sysfs");       // 设置gpioButton变量
  55.    gpio_direction_input(gpioButton);        // 设置按键的接口为输入
  56.    gpio_set_debounce(gpioButton, 200);      // 设置按键去抖动时间延迟为200毫秒
  57.    gpio_export(gpioButton, false);          // 使得gpio115在/sys/class/gpio目录中显示
  58.                                 // 布尔参数防止方向被改变
  59.    // 在可加载内核模块加载时做一个简单的测试，查看按键是否工作
  60.    printk(KERN_INFO "GPIO_TEST: The button state is currently: %d\n", gpio_get_value(gpioButton));
  62.    // 通用输入输出号和中断请求号不同！该函数完成二者的映射
  63.    irqNumber = gpio_to_irq(gpioButton);
  64.    printk(KERN_INFO "GPIO_TEST: The button is mapped to IRQ: %d\n", irqNumber);
  66.    // 下一个调用请求中断线路
  67.    result = request_irq(irqNumber,             // 请求的中断号
  68.                         (irq_handler_t) ebbgpio_irq_handler, // 指向下面介绍的中断处理函数的指针
  69.                         IRQF_TRIGGER_RISING,   // 在上升沿中断（按键按下时，非释放时）
  70.                         "ebb_gpio_handler",    // 在/proc/interrupts识别中断拥有者
  71.                         NULL);                 // 共享中断线路的设备ID指针，这里为NULL即可
  73.    printk(KERN_INFO "GPIO_TEST: The interrupt request result is: %d\n", result);
  74.    return result;
  75. }
  77. /** @brief 可加载内核模块清理函数
  78.  *  和初始化函数类似，它是静态的。__exit宏表示了如果这个代码用于内置驱动（非可加载内核模块），该函数是不需要的。
  79.  *  这里主要用于释放通用输入输出接口和展示清理消息。
  80.  */
  81. static void __exit ebbgpio_exit(void){
  82.    printk(KERN_INFO "GPIO_TEST: The button state is currently: %d\n", gpio_get_value(gpioButton));
  83.    printk(KERN_INFO "GPIO_TEST: The button was pressed %d times\n", numberPresses);
  84.    gpio_set_value(gpioLED, 0);              // 关闭发光二极管，明确该设备将卸载
  85.    gpio_unexport(gpioLED);                  // 取消导出发光二极管通用输入输出接口
  86.    free_irq(irqNumber, NULL);               // 释放中断请求号，在本例中不需要*dev_id
  87.    gpio_unexport(gpioButton);               // 取消导出按键通用输入输出接口
  88.    gpio_free(gpioLED);                      // 释放发光二极管通用输入输出接口
  89.    gpio_free(gpioButton);                   // 释放按键通用输入输出接口
  90.    printk(KERN_INFO "GPIO_TEST: Goodbye from the LKM!\n");
  91. }
  93. /** @brief 通用输入输出接口中断请求处理器
  94.  *  该函数是一个自定义的中断处理函数，关联到前面创建的通用输入输出接口上。 
  95.  *  由于中断线路被屏蔽，相同的中断处理器无法并行执行，直到该函数执行完成。
  96.  *  该函数是静态的，确保它无法被文件外的函数调用到。
  97.  *  @param irq    关联到通用输入输出接口的中断请求号，对于日志记录非常有用。
  98.  *  @param dev_id 提供的*dev_id，可以用于标记哪个设备引起这这个中断，
  99.  *  本例中没有使用，传入NULL。
  100.  *  @param regs   h/w特殊寄存器的值，仅用于调试。
  101.  *  return returns 如果成功返回IRQ_HANDLED，其他结果返回IRQ_NONE
  102.  */
  103. static irq_handler_t ebbgpio_irq_handler(unsigned int irq, void *dev_id, struct pt_regs *regs){
  104.    ledOn = !ledOn;                          // 在每次按键按下的时候反转发光二极管状态
  105.    gpio_set_value(gpioLED, ledOn);          // 设置相应的实体发光二极管
  106.    printk(KERN_INFO "GPIO_TEST: Interrupt! (button state is %d)\n", gpio_get_value(gpioButton));
  107.    numberPresses++;                         // 全局计数器，当模块卸载的时候会输出
  108.    return (irq_handler_t) IRQ_HANDLED;      // 宣布中断请求被成功处理
  109. }
  111. /// 下面两个函数是强制性的，他们标识了初始化函数和清理函数（前面介绍过）
  112. module_init(ebbgpio_init);
  113. module_exit(ebbgpio_exit);

列表2：通用输入输出接口发光二极管和按键测试内核模块源码

列表2中描述的可加载内核模块，和前文一样，可以通过如下步骤构建和加载：

  1. molloyd@beaglebone:~/exploringBB/extras/kernel/gpio_test$ make
  2. make -C /lib/modules/3.8.13-bone70/build/ M=/home/molloyd/exploringBB/extras/kernel/gpio_test modules
  3. …
  4. molloyd@beaglebone:~/exploringBB/extras/kernel/gpio_test$ ls -l *.ko 
  5. -rw-r--r-- 1 molloyd molloyd 5898 Apr 19 18:04 gpio_test.ko
  6. molloyd@beaglebone:~/exploringBB/extras/kernel/gpio_test$ sudo insmod gpio_test.ko
  7. molloyd@beaglebone:~/exploringBB/extras/kernel/gpio_test$ lsmod
  8. Module                  Size  Used by
  9. gpio_test               1379  0

此时，kern.log文件给出了如下内核日志输出：

  1. root@beaglebone:/var/log# tail -f kern.log
  2. Apr 19 18:25:23 beaglebone kernel: [174918.090753] GPIO_TEST: Initializing the GPIO_TEST LKM
  3. Apr 19 18:25:23 beaglebone kernel: [174918.094457] GPIO_TEST: The button state is currently: 0
  4. Apr 19 18:25:23 beaglebone kernel: [174918.094472] GPIO_TEST: The button is mapped to IRQ: 243
  5. Apr 19 18:25:23 beaglebone kernel: [174918.094625] GPIO_TEST: The interrupt request result is: 0

然后当按照图1方式连接的物理瞬时开关按下时，内核日志立即有一下反应：

  1.  Apr 19 18:29:21 beaglebone kernel: [175156.710964] GPIO_TEST: Interrupt! (button state is 1)
  2.  Apr 19 18:29:21 beaglebone kernel: [175156.838235] GPIO_TEST: Interrupt! (button state is 1)
  3.  Apr 19 18:29:23 beaglebone kernel: [175157.907436] GPIO_TEST: Interrupt! (button state is 1)
  4.  Apr 19 18:29:23 beaglebone kernel: [175158.020004] GPIO_TEST: Interrupt! (button state is 1)

出于兴趣，此时可以查看/proc/interrupts文件项，可以看见有一个名为“ebb_gpio_handler”的中断处理器，它和列表2代码中配置的相同。同时也能看见关联通用输入输出接口的中断号为243，和前面看见的内核日志输出可以对的上。

  1. molloyd@beaglebone:~/exploringBB/extras/kernel/gpio_test$ cd /proc/
  2. molloyd@beaglebone:/proc$ cat interrupts
  3.            CPU0
  4. …
  5.  42:      27721      INTC  4a100000.ethernet
  6.  43:          0      INTC  4a100000.ethernet
  7.  64:          0      INTC  mmc0
  8.  67:    2052095      INTC  gp_timer
  9.  70:       1116      INTC  44e0b000.i2c
  10.  72:          8      INTC
  11.  75:          0      INTC  rtc0
  12.  76:          0      INTC  rtc0
  13. 109:          0      INTC  53100000.sham
  14. 134:          0      GPIO  mmc0
  15. 243:         45      GPIO  ebb_gpio_handler
  16. …

再次强调，需要特别注意中断号不是通用输入输出接口号，图1电路图中的按键端口号为115，发光二极管端口号为49。在列表2代码中还可以发现，通用输入输出号使用通用输入输出函数导出（当内核模块卸载时，通用输入输出接口会自动取消导出）：

  1. molloyd@beaglebone:~/exploringBB/extras/kernel$ ls -l /sys/class/gpio/
  2. total 0
  3. --w------- 1 root root 4096 Jan  1  2000 export
  4. lrwxrwxrwx 1 root root    0 Apr 22 21:44 gpio115 -> ../../devices/virtual/gpio/gpio115
  5. lrwxrwxrwx 1 root root    0 Apr 22 21:44 gpio49 -> ../../devices/virtual/gpio/gpio49
  6. lrwxrwxrwx 1 root root    0 Jan  1  2000 gpiochip0 -> ../../devices/virtual/gpio/gpiochip0
  7. lrwxrwxrwx 1 root root    0 Jan  1  2000 gpiochip32 -> ../../devices/virtual/gpio/gpiochip32
  8. lrwxrwxrwx 1 root root    0 Jan  1  2000 gpiochip64 -> ../../devices/virtual/gpio/gpiochip64
  9. lrwxrwxrwx 1 root root    0 Jan  1  2000 gpiochip96 -> ../../devices/virtual/gpio/gpiochip96
  10. --w------- 1 root root 4096 Jan  1  2000 unexport

当模块使用sudo rmmod gpio_test命令卸载时，有以下日志输出：

  1.  Apr 19 18:29:35 beaglebone kernel: [175170.252260] GPIO_TEST: The button state is currently: 0
  2.  Apr 19 18:29:35 beaglebone kernel: [175170.252278] GPIO_TEST: The button was pressed 4 times
  3.  Apr 19 18:29:35 beaglebone kernel: [175170.256753] GPIO_TEST: Goodbye from the LKM!

性能

这个可加载内核模块最有用的特性之一是可以整体评估响应时间（中断延迟时间）。瞬时开关按下结果是发光二极管状态反转，即当按键按下时如果发光二极管是关闭的，那么它将会打开。为了测量这个延时，示波器被使用，它被配置成在按键信号的上升沿触发。示波器提供了独立的时间测量，它的输出展示在图2中。

按键延时
图2：该可加载内核模块的性能，按键按下发光二极管状态改变

绿色的信号表示按键信号而蓝色信号表示发光二极管响应信号。在图中延时大约在17微秒。重复该测试，延时变化在最小15微秒，最大25微秒之间。BeagleBone上使用的镜像是普通的Debian发行版，如果使用实时Linux内核（如Xenomai），这一结果将会更好和偏差将会更小。

按键开关去抖动

按键的机械性质意味着，当按键按下时，按键接触将会触动开关触点，接通电路，然后会有微小的反弹，瞬间断开电路。这种机械反弹可能引起错误脉冲，引发按键误按。去抖动就是用于描述去除这种错误脉冲过程的术语。值得注意的是，本例中的按键去抖动采用软件实现。代码使用gpio_set_bounce()函数，一旦检测到边沿转换，在给定的时间段内（通常是100毫秒到200毫秒）忽略重复的边沿转换。如果希望在“干净”的数字信号上使用代码检测多重边沿变化，应该移除gpio_set_debounce()函数，因为软件去抖动将会严重影响性能。YouTube视频（参见视频2）描述了一种对机械开关去抖动的硬件实现。

https://youtu.be/tmjuLtiAsc0
视频2：来自YouTube频道的瞬时开关去抖动

示例2：增强的按键通用输入输出接口驱动

示例2基于示例1构建，创建了一个增强的通用输入输出接口驱动，它能够使用sysfs让用户配置并和通用输入输出接口上的按键进行交互。该模块允许通用输入输出按键映射到Linux用户空间，因此用户可以和它直接交互。以下示例是解释该功能的最好方式，在示例中，按键被连接到通用输入输出115接口，可以通过以下方式访问和操作：

  1. molloyd@beaglebone:/sys/ebb/gpio115$ ls -l
  2. total 0
  3. -r--r--r-- 1 root root 4096 Apr 24 11:52 diffTime
  4. -rw-rw-rw- 1 root root 4096 Apr 24 11:54 isDebounce
  5. -r--r--r-- 1 root root 4096 Apr 24 11:52 lastTime
  6. -r--r--r-- 1 root root 4096 Apr 24 11:52 ledOn
  7. -rw-rw-rw- 1 root root 4096 Apr 24 11:52 numberPresses
  8. molloyd@beaglebone:/sys/ebb/gpio115$ cat numberPresses
  9. 55
  10. molloyd@beaglebone:/sys/ebb/gpio115$ cat ledOn
  11. 0
  12. molloyd@beaglebone:/sys/ebb/gpio115$ cat lastTime
  13. 10:54:48:487088428
  14. molloyd@beaglebone:/sys/ebb/gpio115$ cat diffTime
  15. 0.628361750
  16. molloyd@beaglebone:/sys/ebb/gpio115$ echo 0 > isDebounce 
  17. molloyd@beaglebone:/sys/ebb/gpio115$ cat isDebounce 
  18. 0

尽管创建该可加载内核模块有一些复杂性，但是用户接口非常简单，并且能够通过任何编程语言编写的可执行程序在嵌入式系统中使用。

sysfs是一个基于内存的文件系统，它提供了将内核数据结构、属性导出并链接到Linux用户空间的机制。本文前面的章节“通用输入输出接口和内核”提供了一个如何操作/sys/class/gpio文件项的示例，它用于操作内核数据结构来开启和关闭发光二极管。使sysfs发挥作用的基础设施，主要基于kboject接口。

kobject接口

Linux中的驱动模型，使用了kobject抽象，为了理解这个模型，必须先领悟下面这些重要的概念【摘自Greg Kroah-Hartman的指南】：

  1.  #define KOBJ_NAME_LEN   20
  3. struct kobject {
  4.     char               *k_name;              // kobject name pointer (must not be NULL)
  5.     char               name[KOBJ_NAME_LEN];  // short kobject internal name data (can kmalloc() longer names)
  6.     struct kref        kref;                 // the reference count
  7.     struct list_head   entry;                // circularly linked list to members of the kset
  8.     struct kobject     *parent;              // the parent kobject
  9.     struct kset        *kset;                // kobject can be a member of a set (otherwise NULL)
  10.     struct kobj_type   *ktype;               // kobj_type is a struct that describes the type of the object
  11.     struct dentry      *dentry;              // the sysfs directory entry
  12. };

列表3：kobject结构体

在此示例中，只需要一个kobject对象，它在文件系统中被映射到/sys/ebb。单个kobject包含了上述示例中的所有交互需要的属性（例如查看numberPresses项）。这在列表4中，通过使用kobject_create_and_add()函数实现，过程如下：

  1. static struct kobject *ebb_kobj; 
  2. ebb_kobj = kobject_create_and_add("ebb", kernel_kobj->parent);

kernel_kobj指针提供了/sys/kernel/的引用。如果去掉了调用中的->parent内容，那么ebb文件项将会创建在/sys/kernel/ebb，但是为了清晰，这里放置在了/sys/ebb，这不是最佳实践！（另外，sysfs_create_dir()函数提供了相同的功能。）

当sysfs属性被读取或者写入的时候，_show和_store函数将会被分别调用。sysfs.h头文件定义了以下帮助宏，使得定义属性会更加方便。

示例的源码

列表4提供了增强的按键通用输入输出接口内核模块完整的源码。它看上去很长，因为添加了很多注释和额外的printk()函数调用，以方便在代码运行时查看正在发生的事情。该示例基于列表2中的代码构建，它也包含了发光二极管，让开发者能够观察到电路自身的互动。

  1. /**
  2.  * @file   button.c
  3.  * @author Derek Molloy
  4.  * @date   2015年4月19日
  5.  * @brief  控制连接到通用输入输出接口的按键（或任何信号）的内核模块
  6.  * 它包含对中断和sysfs项的全部支持，因此可以从Linux用户空间
  7.  * 创建和按键的接口，或者配置按键。
  8.  * sysfs文件项在/sys/ebb/gpio115目录中
  9.  * @see http://www.derekmolloy.ie/
  10. */
  12. #include <linux/init.h>
  13. #include <linux/module.h>
  14. #include <linux/kernel.h>
  15. #include <linux/gpio.h>       // 通用输入输出接口函数需要
  16. #include <linux/interrupt.h>  // 中断请求代码需要
  17. #include <linux/kobject.h>    // 使用kobject和sysfs进行绑定
  18. #include <linux/time.h>       // 使用时钟来度量两次按键按下的间隔时间
  19. #define  DEBOUNCE_TIME 200    ///< 默认抖动时间：200毫秒
  21. MODULE_LICENSE("GPL");
  22. MODULE_AUTHOR("Derek Molloy");
  23. MODULE_DESCRIPTION("A simple Linux GPIO Button LKM for the BBB");
  24. MODULE_VERSION("0.1");
  26. static bool isRising = 1;                   ///< 上升沿作为默认中断请求属性
  27. module_param(isRising, bool, S_IRUGO);      ///< 参数描述。S_IRUGO表示可以读取，但不能修改。
  28. MODULE_PARM_DESC(isRising, " Rising edge = 1 (default), Falling edge = 0");  ///< 参数描述
  30. static unsigned int gpioButton = 115;       ///< 默认通用输入输出接口号为115
  31. module_param(gpioButton, uint, S_IRUGO);    ///< 参数描述，S_IRUGO表示可以读取，但是不能修改。
  32. MODULE_PARM_DESC(gpioButton, " GPIO Button number (default=115)");  ///< 参数描述
  34. static unsigned int gpioLED = 49;           ///< 默认通用输入输出端口号为49
  35. module_param(gpioLED, uint, S_IRUGO);       ///< 参数描述，S_IRUGO表示可以读取，但是不能修改
  36. MODULE_PARM_DESC(gpioLED, " GPIO LED number (default=49)");         ///< 参数描述
  38. static char   gpioName[8] = "gpioXXX";      ///< 以NULL结尾的默认字符串，以防万一
  39. static int    irqNumber;                    ///< 用于在文件中共享中断请求号
  40. static int    numberPresses = 0;            ///< 按下次数信息，保存按键按下的次数
  41. static bool   ledOn = 0;                    ///< 发光二极管开启还是关闭？用于反转它的状态（默认关闭）
  42. static bool   isDebounce = 1;               ///< 用于保存去抖动状态（默认开启）
  43. static struct timespec ts_last, ts_current, ts_diff;  ///< linux/time.h头文件提供的timespecs结构体（有纳秒精度）
  45. /// 自定义中断请求处理函数的函数原型，参见下面的实现
  46. static irq_handler_t  ebbgpio_irq_handler(unsigned int irq, void *dev_id, struct pt_regs *regs);
  48. /** @brief 输出numberPresses变量的回调函数
  49.  *  @param kobj 代表显示在sysfs文件系统中的内核对象设备
  50.  *  @param attr 指向kobj_attribute结构体的指针
  51.  *  @param buf 用于写入按下次数的缓冲区
  52.  *  @return 返回写入到缓冲区的总字符数（不包括null）
  53.  */
  54. static ssize_t numberPresses_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  55.    return sprintf(buf, "%d\n", numberPresses);
  56. }
  58. /** @brief 读入numberPresses变量的回调函数
  59.  *  @param kobj 表示显示在sysfs文件系统中的内核对象设备
  60.  *  @param attr 指向kobj_attribute结构体的指针
  61.  *  @param buf 读取按下次数的缓冲区（重置为0）
  62.  *  @param count 缓冲区中的字符数量
  63.  *  @return return 应该返回缓冲区中使用的字符数
  64.  */
  65. static ssize_t numberPresses_store(struct kobject *kobj, struct kobj_attribute *attr,
  66.                                    const char *buf, size_t count){
  67.    sscanf(buf, "%du", &numberPresses);
  68.    return count;
  69. }
  71. /** @brief 展示发光二极管是开启还是关闭 */
  72. static ssize_t ledOn_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  73.    return sprintf(buf, "%d\n", ledOn);
  74. }
  76. /** @brief 展示按键最后一次按下的时间，手动输出日期（没有本地化） */
  77. static ssize_t lastTime_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  78.    return sprintf(buf, "%.2lu:%.2lu:%.2lu:%.9lu \n", (ts_last.tv_sec/3600)%24,
  79.           (ts_last.tv_sec/60) % 60, ts_last.tv_sec % 60, ts_last.tv_nsec );
  80. }
  82. /** @brief 以秒.纳秒的格式展示时间差，最多展示9位 */
  83. static ssize_t diffTime_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  84.    return sprintf(buf, "%lu.%.9lu\n", ts_diff.tv_sec, ts_diff.tv_nsec);
  85. }
  87. /** @brief 展示按键去抖动功能是否开启 */
  88. static ssize_t isDebounce_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  89.    return sprintf(buf, "%d\n", isDebounce);
  90. }
  92. /** @brief 保存和设置去抖动状态 */
  93. static ssize_t isDebounce_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count){
  94.    unsigned int temp;
  95.    sscanf(buf, "%du", &temp);                // 使用临时变量，确保整型到布尔类型转换正确
  96.    gpio_set_debounce(gpioButton,0);
  97.    isDebounce = temp;
  98.    if(isDebounce) { gpio_set_debounce(gpioButton, DEBOUNCE_TIME);
  99.       printk(KERN_INFO "EBB Button: Debounce on\n");
  100.    }
  101.    else { gpio_set_debounce(gpioButton, 0);  // 设置去抖动时间为0
  102.       printk(KERN_INFO "EBB Button: Debounce off\n");
  103.    }
  104.    return count;
  105. }
  107. /**  使用帮助宏来定义kobj_attribute的名称和访问权限
  108.  *  kobj_attribute结构包含属性字段（名称和模式），展示和保存函数指针。
  109.  *  count变量关联到numberPresses变量，并通过numberPresses_show和numberPresses_store两个函数，
  110.  *  以0666（读写）权限暴露。
  111.  */
  112. static struct kobj_attribute count_attr = __ATTR(numberPresses, 0666, numberPresses_show, numberPresses_store);
  113. static struct kobj_attribute debounce_attr = __ATTR(isDebounce, 0666, isDebounce_show, isDebounce_store);
  115. /**  __ATTR_RO宏定义了只读属性。使用该宏不需要定义展示回调函数，但是它必须存在。
  116.  *  __ATTR_WO宏可用于只写属性，但是只能用于Linux 3.11.x版本以上。
  117.  */
  118. static struct kobj_attribute ledon_attr = __ATTR_RO(ledOn);     ///< ledon kobject 属性
  119. static struct kobj_attribute time_attr  = __ATTR_RO(lastTime);  ///< 最后一次按下时间kobject属性
  120. static struct kobj_attribute diff_attr  = __ATTR_RO(diffTime);  ///< 时间差属性
  122. /**  ebb_attrs[]是属性数组，用于创建一下属性组。
  123.  *  The attr property of the kobj_attribute is used to extract the attribute struct
  124.  */
  125. static struct attribute *ebb_attrs[] = {
  126.       &count_attr.attr,                  ///< 按键按下次数
  127.       &ledon_attr.attr,                  ///< 发光二极管开启或关闭
  128.       &time_attr.attr,                   ///< 最后一次按键按下时间，HH:MM:SS:NNNNNNNNN格式
  129.       &diff_attr.attr,                   ///< 最后两次按下的时间差
  130.       &debounce_attr.attr,               ///< 去抖动状态是否设置
  131.       NULL,
  132. };
  134. /**  属性组结构使用这个属性数组和一个名称，它将暴露到sysfs中，在本例中
  135.  *  它会显示在gpio115目录中，这是由下面介绍的ebbButton_init()函数在模块加载时，
  136.  *  使用传递给模块的自定义内核参数自动定义的。
  137.  */
  138. static struct attribute_group attr_group = {
  139.       .name  = gpioName,                 ///< 名字在ebbButton_init()函数中生成
  140.       .attrs = ebb_attrs,                ///< 上面定义的属性数组
  141. };
  143. static struct kobject *ebb_kobj;
  145. /** @brief 可加载内核模块初始化函数
  146.  *  static关键字限制了该函数的可见范围为此C文件内。__init宏表示对于内置驱动（非可加载内核模块），
  147.  *  本函数只在初始化时使用，之后将会废弃，内存将会回收。
  148.  *  在本例中，此函数设置通用输入输出接口和中断请求。
  149.  *  @return 如果成功返回0
  150.  */
  151. static int __init ebbButton_init(void){
  152.    int result = 0;
  153.    unsigned long IRQflags = IRQF_TRIGGER_RISING;      // 默认使用上升沿中断
  155.    printk(KERN_INFO "EBB Button: Initializing the EBB Button LKM\n");
  156.    sprintf(gpioName, "gpio%d", gpioButton);           // 为/sys/ebb/gpio115创建gpio115这个名称
  158.    // 在/sys/ebb中创建kobject的sysfs文件项，这可能不是一个立项的路径！
  159.    ebb_kobj = kobject_create_and_add("ebb", kernel_kobj->parent); // kernel_kobj指向/sys/kernel
  160.    if(!ebb_kobj){
  161.       printk(KERN_ALERT "EBB Button: failed to create kobject mapping\n");
  162.       return -ENOMEM;
  163.    }
  164.    // 给/sys/ebb/文件项添加属性，比如/sys/ebb/gpio115/numberPresses
  165.    result = sysfs_create_group(ebb_kobj, &attr_group);
  166.    if(result) {
  167.       printk(KERN_ALERT "EBB Button: failed to create sysfs group\n");
  168.       kobject_put(ebb_kobj);                          // 清理，移除kobject在sysfs中的文件项
  169.       return result;
  170.    }
  171.    getnstimeofday(&ts_last);                          // 将最后按下时间设置为当前时间
  172.    ts_diff = timespec_sub(ts_last, ts_last);          // 设置初始时间差为0
  174.    // 开始设置发光二极管。它使用通用输入输出接口输出模式，默认开启。
  175.    ledOn = true;
  176.    gpio_request(gpioLED, "sysfs");          // gpioLED变量硬编码为49，请求它
  177.    gpio_direction_output(gpioLED, ledOn);   // 设置通用输入输出接口为输出模式，开启发光二极管
  178. // gpio_set_value(gpioLED, ledOn);          // 不需要设置，上一行代码已经设置（这里作为参考）
  179.    gpio_export(gpioLED, false);             // 使得gpio49显示在/sys/class/gpio目录中
  180.                                 // 布尔类型参数阻止方向被反转
  181.    gpio_request(gpioButton, "sysfs");       // 设置gpioButton变量
  182.    gpio_direction_input(gpioButton);        // 设置按键的通用输入输出接口为输入模式
  183.    gpio_set_debounce(gpioButton, DEBOUNCE_TIME); // 设置按键去抖动演示为200毫秒
  184.    gpio_export(gpioButton, false);          // 使得gpio115显示在/sys/class/gpio目录中
  185.                                 // 布尔类型参数阻止方向被反转
  187.    // 在可加载内核模块加载的时候做一个简单测试，查看按键工作和期望是否一致。
  188.    printk(KERN_INFO "EBB Button: The button state is currently: %d\n", gpio_get_value(gpioButton));
  190.    /// 通用输入输出接口号和中断请求号不相同！此函数完成二者映射。
  191.    irqNumber = gpio_to_irq(gpioButton);
  192.    printk(KERN_INFO "EBB Button: The button is mapped to IRQ: %d\n", irqNumber);
  194.    if(!isRising){                           // 如果内核参数isRising=0提供了
  195.       IRQflags = IRQF_TRIGGER_FALLING;      // 设置在下降沿中断
  196.    }
  197.    // 下一个函数调用请求中断线路
  198.    result = request_irq(irqNumber,             // 请求的中断号
  199.                         (irq_handler_t) ebbgpio_irq_handler, // 指向下面中断处理函数的指针
  200.                         IRQflags,              // 使用自定义内核参数来设置中断类型
  201.                         "ebb_button_handler",  // 用于在/proc/interrupts中标识所有者
  202.                         NULL);                 // 为了共享中断线路使用的*dev_id，这里使用NULL是可以的
  203.    return result;
  204. }
  206. /** @brief 可加载内核模块清理函数
  207.  *  和初始化函数雷系，它是静态的。__exit宏表示如果该代码用于内置驱动（非可加载内核模块），
  208.  *  该函数是不需要的。
  209.  */
  210. static void __exit ebbButton_exit(void){
  211.    printk(KERN_INFO "EBB Button: The button was pressed %d times\n", numberPresses);
  212.    kobject_put(ebb_kobj);                   // 清理，移除kobject对象在sysfs中的文件项
  213.    gpio_set_value(gpioLED, 0);              // 关闭发光二极管，明确该设备将被卸载
  214.    gpio_unexport(gpioLED);                  // 取消导出发光二极管的通用输入输出接口
  215.    free_irq(irqNumber, NULL);               // 释放中断请求号，这里不需要提供*dev_id
  216.    gpio_unexport(gpioButton);               // 取消导出按键的通用输入输出接口
  217.    gpio_free(gpioLED);                      // 释放发光二极管通用输入输出接口
  218.    gpio_free(gpioButton);                   // 释放按键通用输入输出接口
  219.    printk(KERN_INFO "EBB Button: Goodbye from the EBB Button LKM!\n");
  220. }
  222. /** @brief 通用输入输出接口中断请求处理函数
  223.  *  此函数是一个关联到上述通用输入输出接口的自定义中断处理器。 
  224.  *  由于进行了屏蔽，相同的中断处理器无法同时调用，直到函数执行结束。
  225.  *  此函数是静态的，因为它不应该在此文件外被直接调用。
  226.  *  @param irq    关联到通用输入输出接口的中断请求号，对于日志记录非常有用
  227.  *  @param dev_id 提供的*dev_id，可以用于识别引起中断的设备。在本例中没有使用，传入NULL。
  228.  *  @param regs   h/w特殊寄存器的值，仅用于调试。
  229.  *  return returns 如果成功返回IRQ_HANDLED，否则返回IRQ_NONE。
  230.  */
  231. static irq_handler_t ebbgpio_irq_handler(unsigned int irq, void *dev_id, struct pt_regs *regs){
  232.    ledOn = !ledOn;                      // 在每次按键按下时反转发光二极管状态
  233.    gpio_set_value(gpioLED, ledOn);      // 设置响应物理发光二极管
  234.    getnstimeofday(&ts_current);         // 获取当前时间ts_current
  235.    ts_diff = timespec_sub(ts_current, ts_last);   // 确定两次按下的时间差
  236.    ts_last = ts_current;                // 将当前时间保存为最后一次按下时间ts_last
  237.    printk(KERN_INFO "EBB Button: The button state is currently: %d\n", gpio_get_value(gpioButton));
  238.    numberPresses++;                     // 全局计数器，将在模块卸载时输出
  239.    return (irq_handler_t) IRQ_HANDLED;  // 宣告中断请求正确处理
  240. }
  242. /// 下面两个函数是强制性的，他们标识了初始化函数和清理函数（前面介绍过）
  243. module_init(ebbButton_init);
  244. module_exit(ebbButton_exit);

列表4：增强的通用输入输出接口按键内核模块

列表4中的代码通过注释描述。然而，还有一些点值得提一下：

该模块可以通过以下方式以下降沿模式加载并测试：

  1. molloyd@beaglebone:~/exploringBB/extras/kernel/button$ make
  2. …
  3. molloyd@beaglebone:~/exploringBB/extras/kernel/button$ ls -l *.ko
  4. -rw-r--r-- 1 molloyd molloyd 10639 Apr 24 11:50 button.ko
  5. molloyd@beaglebone:~/exploringBB/extras/kernel/button$ sudo insmod button.ko isRising=0
  6. molloyd@beaglebone:~/exploringBB/extras/kernel/button$ cd /sys/ebb/gpio115/
  7. molloyd@beaglebone:/sys/ebb/gpio115$ ls
  8. diffTime  isDebounce  lastTime  ledOn  numberPresses
  9. molloyd@beaglebone:/sys/ebb/gpio115$ cat numberPresses 
  10. 4
  11. molloyd@beaglebone:/sys/ebb/gpio115$ cat ledOn 
  12. 1
  13. molloyd@beaglebone:/sys/ebb/gpio115$ cat lastTime
  14. 16:18:04:249265532
  15. molloyd@beaglebone:/sys/ebb/gpio115$ cat diffTime
  16. 1.126586000
  17. molloyd@beaglebone:/sys/ebb/gpio115$ echo 0 > numberPresses 
  18. molloyd@beaglebone:/sys/ebb/gpio115$ cat numberPresses 
  19. 0
  20. molloyd@beaglebone:/sys/ebb/gpio115$ cd ~/exploringBB/extras/kernel/button/
  21. molloyd@beaglebone:~/exploringBB/extras/kernel/button$ sudo rmmod button

同时内核日志（/var/log/kern.log）的输出为：

  1.  Apr 24 17:17:25 beaglebone kernel: [19844.622090] EBB Button: Initializing the EBB Button LKM
  2.  Apr 24 17:17:25 beaglebone kernel: [19844.625986] EBB Button: The button state is currently: 0
  3.  Apr 24 17:17:25 beaglebone kernel: [19844.626002] EBB Button: The button is mapped to IRQ: 243
  4.  Apr 24 17:18:01 beaglebone kernel: [19879.901265] EBB Button: The button state is currently: 0
  5.  Apr 24 17:18:02 beaglebone kernel: [19880.878163] EBB Button: The button state is currently: 0
  6.  Apr 24 17:18:03 beaglebone kernel: [19881.778028] EBB Button: The button state is currently: 0
  7.  Apr 24 17:18:04 beaglebone kernel: [19882.904615] EBB Button: The button state is currently: 0
  8.  Apr 24 17:18:49 beaglebone kernel: [19928.127631] EBB Button: The button was pressed 0 times
  9.  Apr 24 17:18:49 beaglebone kernel: [19928.132038] EBB Button: Goodbye from the EBB Button LKM!

请注意日志显示按钮被按下了0次。这是因为在上面的Linux终端中执行了echo 0 > numberPresses命令。

下面是关于这一主题重要的扩展阅读：

注意：确保在卸载内核模块的时候已经离开了/sys/ebb目录，否则卸载后再执行类似ls命令的时候，将会引发内核崩溃（kernel panic）。

示例3：增强的发光二极管通用输入输出接口驱动内核模块

本文最后一个示例是一个通过可编程内核模块控制发光二极管的驱动。这个示例目的是介绍内核线程（kthread）的使用，我们可以针对发生在可加载内核模块中的事件开始。

内核线程

列表5提供了本例中的代码大致结构。这是在Linux内核中相当不寻常的线程，因为我们需要明确的睡眠时间，以获取一个稳定的闪烁间隔。给内核线程调度器返回的资源，通常通过schedule()函数完成。

对于kthread_run()函数的调用和用户空间pthread库的pthread_create()（参见书的第236页）函数类似。kthread_run()函数需要一个指向线程函数（本例中的flash()函数）指针，它将显示在top或者ps命令中。kthread_run()函数返回一个task_struct结构体，它在这个C文件中作为*task指针，被很多函数共享。

  1. #include <linux/kthread.h>
  2. static struct task_struct *task;             // 线程任务结构体指针
  4. static int flash(void *arg){
  5.    …
  6.    while(!kthread_should_stop()){            // 当kthread_stop()或等效的函数被调用时返回true
  7.       set_current_state(TASK_RUNNING);       // 防止意外的临时休眠（只是一个示例）
  8.       …                                      // 执行状态改变指令（例如闪烁）
  9.       set_current_state(TASK_INTERRUPTIBLE); // 开始休眠，但是在需要时能够被唤醒
  10.       msleep(…);                             // 毫秒级休眠
  11.    }
  12.    …
  13. }
  15. static int __init ebbLED_init(void){
  16.    task = kthread_run(flash, NULL, "LED_flash_thread");   // 开始发光二极管闪烁内核线程
  17.    …
  18. }
  20. static void __exit ebbLED_exit(void){
  21.    kthread_stop(task);                       // 停止发光二极管闪烁内核线程
  22.    …
  23. }

列表5：内核线程的概要实现

此可加载内核模块的最终代码在列表6中。

  1. /**
  2.  * @file   led.c
  3.  * @author Derek Molloy
  4.  * @date   2015年4月19日
  5.  * @brief  控制连接到通用输入输出接口的简单发光二极管（或者其他任何信号）的内核模块。
  6.  * 为了使发光二极管能够闪烁，本模块使用了线程。
  7.  * sysfs文件项显示在/sys/ebb/led49
  8.  * @see http://www.derekmolloy.ie/
  9. */
  11. #include <linux/init.h>
  12. #include <linux/module.h>
  13. #include <linux/kernel.h>
  14. #include <linux/gpio.h>       // 通用输入输出接口函数需要
  15. #include <linux/kobject.h>    // 使用kobject绑定到sysfs
  16. #include <linux/kthread.h>    // 使用内核线程来实现闪烁功能
  17. #include <linux/delay.h>      // 使用该头文件以使用msleep()函数
  19. MODULE_LICENSE("GPL");
  20. MODULE_AUTHOR("Derek Molloy");
  21. MODULE_DESCRIPTION("A simple Linux LED driver LKM for the BBB");
  22. MODULE_VERSION("0.1");
  24. static unsigned int gpioLED = 49;           ///< 发光二极管默认的通用输入输出接口为49
  25. module_param(gpioLED, uint, S_IRUGO);       ///< 参数描述，S_IRUGO表示参数可以被读取，不能被修改
  26. MODULE_PARM_DESC(gpioLED, " GPIO LED number (default=49)");     ///< 参数描述
  28. static unsigned int blinkPeriod = 1000;     ///< 以毫秒为单位的闪烁间隔
  29. module_param(blinkPeriod, uint, S_IRUGO);   ///< 参数描述，S_IRUGO表示参数可以被读取，不能被修改
  30. MODULE_PARM_DESC(blinkPeriod, " LED blink period in ms (min=1, default=1000, max=10000)");
  32. static char ledName[7] = "ledXXX";          ///< 以防万一，使用以NULL结尾的默认字符串
  33. static bool ledOn = 0;                      ///< 发光二极管是关闭的还是开启的？用于闪烁
  34. enum modes { OFF, ON, FLASH };              ///< 发光二极管可选模式，static关键字在这里没有用
  35. static enum modes mode = FLASH;             ///< 默认模式是闪烁
  37. /** @brief 显示发光二极管状态的回调函数
  38.  *  @param kobj 代表一个显示在sysfs文件系统中的内核对象设备
  39.  *  @param attr 指向kobj_attribute结构体的指针
  40.  *  @param buf 写入发光二极管状态的缓冲区
  41.  *  @return 返回成功展示的状态字符串的字符个数
  42.  */
  43. static ssize_t mode_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  44.    switch(mode){
  45.       case OFF:   return sprintf(buf, "off\n");       // 展示状态，简单的方法
  46.       case ON:    return sprintf(buf, "on\n");
  47.       case FLASH: return sprintf(buf, "flash\n");
  48.       default:    return sprintf(buf, "LKM Error\n"); // 不可能到这里
  49.    }
  50. }
  52. /** @brief 保存发光二极管模式（使用上述枚举类型表示）的回调函数 */
  53. static ssize_t mode_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count){
  54.    // count-1表达式是非常重要的，否则换行符\n也会在比较中被使用
  55.    if (strncmp(buf,"on",count-1)==0) { mode = ON; }   // strncmp()函数比较固定数量的字符
  56.    else if (strncmp(buf,"off",count-1)==0) { mode = OFF; }
  57.    else if (strncmp(buf,"flash",count-1)==0) { mode = FLASH; }
  58.    return count;
  59. }
  61. /** @brief 展示发光二极管闪烁周期的回调函数 */
  62. static ssize_t period_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){
  63.    return sprintf(buf, "%d\n", blinkPeriod);
  64. }
  66. /** @brief 保存发光二极管闪烁周期的回调函数 */
  67. static ssize_t period_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count){
  68.    unsigned int period;                     // 使用变量来校验发送的数据
  69.    sscanf(buf, "%du", &period);             // 使用unsigned int类型读入时间段
  70.    if ((period>1)&&(period<=10000)){        // 必须大于等于2毫秒，小于等于10秒
  71.       blinkPeriod = period;                 // 在范围内，赋值给blinkPeriod变量
  72.    }
  73.    return period;
  74. }
  76. /** 使用帮助宏来定义kobj_attribute的名称和访问级别。
  77.  *  kobj_attribute有属性字段（名称和模式），展示和保存函数指针构成。
  78.  *  周期变量被关联到blinkPeriod变量，并且以0666（读写）模式，使用上述period_show、period_store函数暴露出去。
  79.  */
  80. static struct kobj_attribute period_attr = __ATTR(blinkPeriod, 0666, period_show, period_store);
  81. static struct kobj_attribute mode_attr = __ATTR(mode, 0666, mode_show, mode_store);
  83. /** ebb_attrs[]是属性的数组，用于创建下面的属性组。
  84.  *  kobj_attribute结构的attr字段用于抽取结构的属性。
  85.  */
  86. static struct attribute *ebb_attrs[] = {
  87.    &period_attr.attr,                       // 发光二极管闪烁的周期
  88.    &mode_attr.attr,                         // 发光二极管模式（关闭、开启、闪烁）
  89.    NULL,
  90. };
  92. /** 属性组使用属性数组和名称两个字段，将它们暴露到sysfs文件系统中。
  93.  *  在本例中是gpio49目录。它在下面介绍的ebbLED_init()函数中，通过模块加载时传递的自定义模块参数自动定义。
  94.  */
  95. static struct attribute_group attr_group = {
  96.    .name  = ledName,                        // 名称在ebbLED_init()函数中生成
  97.    .attrs = ebb_attrs,                      // 属性数组在上面定义
  98. };
  100. static struct kobject *ebb_kobj;            /// 指向kobject对象的指针
  101. static struct task_struct *task;            /// 指向线程任务对象的指针
  103. /** @brief 发光二极管闪烁的主要内核线程循环
  104.  *
  105.  *  @param arg 用于将数据传递如线程的无类型（void）
  106.  *  @return 如果成功返回0
  107.  */
  108. static int flash(void *arg){
  109.    printk(KERN_INFO "EBB LED: Thread has started running \n");
  110.    while(!kthread_should_stop()){           // 当kthread_stop()函数调用的时候返回true
  111.       set_current_state(TASK_RUNNING);
  112.       if (mode==FLASH) ledOn = !ledOn;      // 反转发光二极管状态
  113.       else if (mode==ON) ledOn = true;
  114.       else ledOn = false;
  115.       gpio_set_value(gpioLED, ledOn);       // 使用发光二极管状态来点亮、关闭发光二极管
  116.       set_current_state(TASK_INTERRUPTIBLE);
  117.       msleep(blinkPeriod/2);                // 毫秒级休眠，休眠时间为闪烁周期的一半
  118.    }
  119.    printk(KERN_INFO "EBB LED: Thread has run to completion \n");
  120.    return 0;
  121. }
  123. /** @brief 可加载内核模块初始化函数
  124.  *  static关键字限制了本函数的可见范围为当前C文件。__init宏表示对于内置驱动（非可加载内核模块），
  125.  *  本函数只在初始化时候使用，在该时间点以后，可以被废弃，内存会被回收。
  126.  * 在本例中，本函数设置通用输入输出接口和中断请求。
  127.  *  @return 如果成功返回0
  128.  */
  129. static int __init ebbLED_init(void){
  130.    int result = 0;
  132.    printk(KERN_INFO "EBB LED: Initializing the EBB LED LKM\n");
  133.    sprintf(ledName, "led%d", gpioLED);      // 为/sys/ebb/led49创建gpio115名字
  135.    ebb_kobj = kobject_create_and_add("ebb", kernel_kobj->parent); // kernel_kobj对象指向/sys/kernel
  136.    if(!ebb_kobj){
  137.       printk(KERN_ALERT "EBB LED: failed to create kobject\n");
  138.       return -ENOMEM;
  139.    }
  140.    // 将属性添加到/sys/ebb/目录中，例如/sys/ebb/led49/ledOn
  141.    result = sysfs_create_group(ebb_kobj, &attr_group);
  142.    if(result) {
  143.       printk(KERN_ALERT "EBB LED: failed to create sysfs group\n");
  144.       kobject_put(ebb_kobj);                // 清理，移除kobject对象在sysfs文件系统中的文件项
  145.       return result;
  146.    }
  147.    ledOn = true;
  148.    gpio_request(gpioLED, "sysfs");          // gpioLED变量值默认是49，请求它
  149.    gpio_direction_output(gpioLED, ledOn);   // 设置通用输入输出接口为输出模式，并且开启
  150.    gpio_export(gpioLED, false);  // 使得gpio49显示在/sys/class/gpio目录中
  151.                                  // 第二个参数阻止方向反转
  153.    task = kthread_run(flash, NULL, "LED_flash_thread");  // 开始发光二极管闪烁
  154.    if(IS_ERR(task)){                                     // 内核线程的名称为LED_flash_thread
  155.       printk(KERN_ALERT "EBB LED: failed to create the task\n");
  156.       return PTR_ERR(task);
  157.    }
  158.    return result;
  159. }
  161. /** @brief 可加载内核模块清理函数
  162.  *  和初始化函数类似，它是静态的。__exit宏表示如果该代码用于内置驱动（非可加载内核模块），本函数是不需要的。
  163.  */
  164. static void __exit ebbLED_exit(void){
  165.    kthread_stop(task);                      // 停止发光二极管闪烁线程
  166.    kobject_put(ebb_kobj);                   // 清理，移除kobject在sysfs文件系统中的文件项
  167.    gpio_set_value(gpioLED, 0);              // 关闭发光二极管，明确设备已经被卸载
  168.    gpio_unexport(gpioLED);                  // 取消导出发光二极管的通用输入输出端口
  169.    gpio_free(gpioLED);                      // 释放发光二极管的通用输入输出接口
  170.    printk(KERN_INFO "EBB LED: Goodbye from the EBB LED LKM!\n");
  171. }
  173. /// 下面两个函数是强制性的，他们标识了初始化函数和清理函数（前面介绍过）
  174. module_init(ebbLED_init);
  175. module_exit(ebbLED_exit);

列表6：增强通用输入输出发光二极管控制器内核模块

列表6中的注释，提供了所有任务一体化的完整说明，然而，还有一些需要补充的点：

该示例可以通过以下步骤构建和执行：

  1. molloyd@beaglebone:~/exploringBB/extras/kernel/led$ make
  2. …
  3. molloyd@beaglebone:~/exploringBB/extras/kernel/led$ sudo insmod led.ko
  4. molloyd@beaglebone:~/exploringBB/extras/kernel/led$ cd /sys/ebb/led49/
  5. molloyd@beaglebone:/sys/ebb/led49$ ls
  6. blinkPeriod  mode
  7. molloyd@beaglebone:/sys/ebb/led49$ cat blinkPeriod 
  8. 1000
  9. molloyd@beaglebone:/sys/ebb/led49$ cat mode
  10. flash
  11. molloyd@beaglebone:/sys/ebb/led49$ echo 100 > blinkPeriod
  12. molloyd@beaglebone:/sys/ebb/led49$ ps aux|grep LED
  13. root      7042 0.0 0.0      0     0 ?        D    18:36   0:00 [LED_flash_threa]
  14. molloyd   7062  0.0  0.1   3100   616 pts/0    S+   18:37   0:00 grep LED

可以通过将休眠时间减少到1毫秒来提高闪烁频率，这样可以观察CPU的负载，操作如下：

  1.  molloyd@beaglebone:/sys/ebb/led49$ echo 2 > blinkPeriod 
  2.  molloyd@beaglebone:/sys/ebb/led49$ ps aux|grep LED
  3.  root      7042 0.1 0.0      0     0 ?        D    18:36   0:00 [LED_flash_threa]
  4.  molloyd   7070  0.0  0.1   3100   616 pts/0    S+   18:38   0:00 grep LED
  5.  molloyd@beaglebone:/sys/ebb/led49$ echo off > mode
  6.  molloyd@beaglebone:/sys/ebb/led49$ echo on > mode
  7.  molloyd@beaglebone:/sys/ebb/led49$ cd ~/exploringBB/extras/kernel/led/
  8.  molloyd@beaglebone:~/exploringBB/extras/kernel/led$ sudo rmmod led

从输出可以看见，当闪烁的休眠周期为1毫秒的时候，线程负载非常小，CPU占用率只有0.1%。对于不同周期值的输出信号，详见在图3到图6。

The kernel log output for this example is as follows:
本例的内核日志输出如下：

  1. Apr 24 18:36:30 beaglebone kernel: [24588.981157] EBB LED: Initializing the EBB LED LKM
  2. Apr 24 18:36:30 beaglebone kernel: [24588.987821] EBB LED: Thread has started running
  3. Apr 24 18:40:57 beaglebone kernel: [24856.188934] EBB LED: Thread has run to completion
  4. Apr 24 18:40:57 beaglebone kernel: [24856.190471] EBB LED: Goodbye from the EBB LED LKM!

相比于Linux用户空间的类似测试，这种实现的结果相当可观的。结果有一致的约50%的占空比，并且频率的值的范围也相当的一致。例如，图6表示当休眠延时设置为1毫秒的时候，这种实现的性能，它的结果大约是每个周期7.8毫秒。频率范围在127.935赫兹到128.07赫兹之间，它的波动在+/-0.05%。这种情况下，内核线程CPU使用率小于0.1%。更高频率也是可能的，但是脉冲宽度将会有更大的波动，可能BeagleBone上的可编程实时单元子系统和工业通信子系统（Programmable Real-Time Unit Subsystem and Industrial Communication SubSystem，PRU-ICSS）更适合这样的任务。

50毫秒
图3：50毫秒休眠延迟的发光二极管闪烁模块的性能

25毫秒
图4：25毫秒休眠延迟的发光二极管闪烁模块的性能

5毫秒
图5：5毫秒休眠延迟的发光二极管闪烁模块的性能

2毫秒
图6：1毫秒休眠延迟的发光二极管闪烁模块的性能

总结

记住内核事实上是一个程序，一个大而复杂的程序，不过它仍然是一个程序。我们可以修改内核代码、重新编译、重新部署，然后重启，但这是一个漫长的过程。Linux可加载内核模块允许开发者创建一个二进制代码，使得它能够在运行时向内核中加载或者卸载。希望这三篇文章已经说清楚如何通过可加载内核模块，将自定义功能构建到Linux内核中。

随着时间的推移，在需要或者找到合适的嵌入式系统应用的时候，我将进一步向这个系列增加文章。

查看英文原文：Writing a Linux Kernel Module — Part 3: Buttons and LEDs

编后语

《他山之石》是InfoQ中文站新推出的一个专栏，精选来自国内外技术社区和个人博客上的技术文章，让更多的读者朋友受益，本栏目转载的内容都经过原作者授权。文章推荐可以发送邮件到editors@cn.infoq.com。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注