Linux驱动实践：如何编写【 GPIO 】设备的驱动程序？，


别人的经验，我们的阶梯!

大家好，我是道哥。

在前几篇文章中，我们一块讨论了：在 Linux 系统中，编写字符设备驱动程序的基本框架，主要是从代码流程和 API 函数这两方面触发。

这篇文章，我们就以此为基础，写一个有实际应用功能的驱动程序：

示例程序目标

编写一个驱动程序模块：mygpio.ko。

当这个驱动模块被加载的时候，在系统中创建一个 mygpio 类设备，并且在 /dev 目录下，创建 4 个设备节点：

  • /dev/mygpio0
  • /dev/mygpio1
  • /dev/mygpio2
  • /dev/mygpio3

因为我们现在是在 x86 平台上来模拟 GPIO 的控制操作，并没有实际的 GPIO 硬件设备。

因此，在驱动代码中，与硬件相关部分的代码，使用宏 MYGPIO_HW_ENABLE 控制起来，并且在其中使用printk输出打印信息来体现硬件的操作。

在应用程序中，可以分别打开以上这 4 个 GPIO 设备，并且通过发送控制指令，来设置 GPIO 的状态。

编写驱动程序

以下所有操作的工作目录，都是与上一篇文章相同的，即：~/tmp/linux-4.15/drivers/。

创建驱动目录和驱动程序

  1. $ cd linux-4.15/drivers/ 
  2. $ mkdir mygpio_driver 
  3. $ cd mygpio_driver 
  4. $ touch mygpio.c 

mygpio.c 文件的内容如下(不需要手敲，文末有代码下载链接)：

  1. #include <linux/module.h> 
  2. #include <linux/kernel.h> 
  3. #include <linux/ctype.h> 
  4. #include <linux/device.h> 
  5. #include <linux/cdev.h> 
  6.  
  7. // GPIO 硬件相关宏定义 
  8. #define MYGPIO_HW_ENABLE 
  9.  
  10. // 设备名称 
  11. #define MYGPIO_NAME     "mygpio" 
  12.  
  13. // 一共有４个 GPIO 口 
  14. #define MYGPIO_NUMBER       4 
  15.  
  16. // 设备类 
  17. static struct class *gpio_class; 
  18.  
  19. // 用来保存设备 
  20. struct cdev gpio_cdev[MYGPIO_NUMBER]; 
  21.  
  22. // 用来保存设备号 
  23. int gpio_major = 0; 
  24. int gpio_minor = 0; 
  25.  
  26. #ifdef MYGPIO_HW_ENABLE 
  27. // 硬件初始化函数，在驱动程序被加载的时候(gpio_driver_init)被调用 
  28. static void gpio_hw_init(int gpio) 
  29. { 
  30.     printk("gpio_hw_init is called: %d. \n", gpio); 
  31. } 
  32.  
  33. // 硬件释放 
  34. static void gpio_hw_release(int gpio) 
  35. { 
  36.     printk("gpio_hw_release is called: %d. \n", gpio); 
  37. } 
  38.  
  39. // 设置硬件GPIO的状态，在控制GPIO的时候(gpio_ioctl)被调研 
  40. static void gpio_hw_set(unsigned long gpio_no, unsigned int val) 
  41. { 
  42.     printk("gpio_hw_set is called. gpio_no = %ld, val = %d. \n", gpio_no, val); 
  43. } 
  44. #endif 
  45.  
  46. // 当应用程序打开设备的时候被调用 
  47. static int gpio_open(struct inode *inode, struct file *file) 
  48. { 
  49.      
  50.     printk("gpio_open is called. \n"); 
  51.     return 0;    
  52. } 
  53.  
  54. // 当应用程序控制GPIO的时候被调用 
  55. static long gpio_ioctl(struct file* file, unsigned int val, unsigned long gpio_no) 
  56. { 
  57.     printk("gpio_ioctl is called. \n"); 
  58.      
  59.     // 检查设置的状态值是否合法 
  60.     if (0 != val && 1 != val) 
  61.     { 
  62.         printk("val is NOT valid! \n"); 
  63.         return 0; 
  64.     } 
  65.  
  66.     // 检查设备范围是否合法 
  67.     if (gpio_no >= MYGPIO_NUMBER) 
  68.     { 
  69.         printk("dev_no is invalid! \n"); 
  70.         return 0; 
  71.     } 
  72.  
  73.     printk("set GPIO: %ld to %d. \n", gpio_no, val); 
  74.  
  75. #ifdef MYGPIO_HW_ENABLE 
  76.     // 操作 GPIO 硬件 
  77.     gpio_hw_set(gpio_no, val); 
  78. #endif 
  79.  
  80.     return 0; 
  81. } 
  82.  
  83. static const struct file_operations gpio_ops={ 
  84.     .owner = THIS_MODULE, 
  85.     .open  = gpio_open, 
  86.     .unlocked_ioctl = gpio_ioctl 
  87. }; 
  88.  
  89. static int __init gpio_driver_init(void) 
  90. { 
  91.     int i, devno; 
  92.     dev_t num_dev; 
  93.  
  94.     printk("gpio_driver_init is called. \n"); 
  95.  
  96.     // 动态申请设备号(严谨点的话，应该检查函数返回值) 
  97.     alloc_chrdev_region(&num_dev, gpio_minor, MYGPIO_NUMBER, MYGPIO_NAME); 
  98.  
  99.     // 获取主设备号 
  100.     gpio_major = MAJOR(num_dev); 
  101.     printk("gpio_major = %d. \n", gpio_major); 
  102.  
  103.     // 创建设备类 
  104.     gpio_class = class_create(THIS_MODULE, MYGPIO_NAME); 
  105.  
  106.     // 创建设备节点 
  107.     for (i = 0; i < MYGPIO_NUMBER; ++i) 
  108.     { 
  109.         // 设备号 
  110.         devno = MKDEV(gpio_major, gpio_minor + i); 
  111.          
  112.         // 初始化 cdev 结构 
  113.         cdev_init(&gpio_cdev[i], &gpio_ops); 
  114.  
  115.         // 注册字符设备 
  116.         cdev_add(&gpio_cdev[i], devno, 1); 
  117.  
  118.         // 创建设备节点 
  119.         device_create(gpio_class, NULL, devno, NULL, MYGPIO_NAME"%d", i); 
  120.     } 
  121.  
  122. #ifdef MYGPIO_HW_ENABLE 
  123.     // 初始化 GPIO 硬件 
  124.     for (i = 0; i < MYGPIO_NUMBER; ++i) 
  125.     { 
  126.         gpio_hw_init(i); 
  127.     } 
  128. #endif 
  129.  
  130.     return 0; 
  131. } 
  132.  
  133. static void __exit gpio_driver_exit(void) 
  134. { 
  135.     int i; 
  136.     printk("gpio_driver_exit is called. \n"); 
  137.  
  138.     // 删除设备和设备节点 
  139.     for (i = 0; i < MYGPIO_NUMBER; ++i) 
  140.     { 
  141.         cdev_del(&gpio_cdev[i]); 
  142.         device_destroy(gpio_class, MKDEV(gpio_major, gpio_minor + i)); 
  143.     } 
  144.  
  145.     // 释放设备类 
  146.     class_destroy(gpio_class); 
  147.  
  148. #ifdef MYGPIO_HW_ENABLE 
  149.     // 释放 GPIO 硬件 
  150.     for (i = 0; i < MYGPIO_NUMBER; ++i) 
  151.     { 
  152.         gpio_hw_release(i); 
  153.     } 
  154. #endif 
  155.  
  156.     // 注销设备号 
  157.     unregister_chrdev_region(MKDEV(gpio_major, gpio_minor), MYGPIO_NUMBER); 
  158. } 
  159.  
  160. MODULE_LICENSE("GPL"); 
  161. module_init(gpio_driver_init); 
  162. module_exit(gpio_driver_exit); 

相对于前几篇文章来说，上面的代码稍微有一点点复杂，主要是多了宏定义 MYGPIO_HW_ENABLE 控制部分的代码。

比如：在这个宏定义控制下的三个与硬件相关的函数：

  • gpio_hw_init()
  • gpio_hw_release()
  • gpio_hw_set()

就是与GPIO硬件的初始化、释放、状态设置相关的操作。

代码中的注释已经比较完善了，结合前几篇文章中的函数说明，还是比较容易理解的。

从代码中可以看出：驱动程序使用 alloc_chrdev_region 函数，来动态注册设备号，并且利用了 Linux 应用层中的 udev 服务，自动在 /dev 目录下创建了设备节点。

另外还有一点：在上面示例代码中，对设备的操作函数只实现了 open 和 ioctl 这两个函数，这是根据实际的使用场景来决定的。

这个示例中，只演示了如何控制 GPIO 的状态。

你也可以稍微补充一下，增加一个read函数，来读取某个GPIO口的状态。

控制 GPIO 设备，使用 write 或者 ioctl 函数都可以达到目的，只是 ioctl 更灵活一些。

创建 Makefile 文件

  1. $ touch Makefile 

内容如下：

  1. ifneq ($(KERNELRELEASE),) 
  2.     obj-m := mygpio.o 
  3. else 
  4.     KERNELDIR ?= /lib/modules/$(shell uname -r)/build 
  5.     PWD := $(shell pwd) 
  6. default: 
  7.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules 
  8. clean: 
  9.     $(MAKE) -C $(KERNEL_PATH) M=$(PWD) clean 
  10. endif 

编译驱动模块

  1. $ make 

得到驱动程序： mygpio.ko 。

加载驱动模块

在加载驱动模块之前，先来检查一下系统中，几个与驱动设备相关的地方。

先看一下 /dev 目录下，目前还没有设备节点( /dev/mygpio[0-3] )。

  1. $ ls -l /dev/mygpio* 
  2. ls: cannot access '/dev/mygpio*': No such file or directory 

再来查看一下 /proc/devices 目录下，也没有 mygpio 设备的设备号。

  1. $ cat /proc/devices 

为了方便查看打印信息，把dmesg输出信息清理一下：

  1. $ sudo dmesg -c 

现在来加载驱动模块，执行如下指令:

  1. $ sudo insmod mygpio.ko 

当驱动程序被加载的时候，通过 module_init( ) 注册的函数 gpio_driver_init() 将会被执行，那么其中的打印信息就会输出。

还是通过 dmesg 指令来查看驱动模块的打印信息：

  1. $ dmesg 

可以看到：操作系统为这个设备分配的主设备号是 244，并且也打印了GPIO硬件的初始化函数的调用信息。

此时，驱动模块已经被加载了!

来查看一下 /proc/devices 目录下显示的设备号：

  1. $ cat /proc/devices 

设备已经注册了，主设备号是: 244 。

设备节点

由于在驱动程序的初始化函数中，使用 cdev_add 和 device_create 这两个函数，自动创建设备节点。

所以，此时我们在 /dev 目录下，就可以看到下面这4个设备节点：

现在，设备的驱动程序已经加载了，设备节点也被创建好了，应用程序就可以来控制 GPIO 硬件设备了。

应用程序

应用程序仍然放在 ~/tmp/App/ 目录下。

  1. $ mkdir ~/tmp/App/app_mygpio 
  2. $ cd ~/tmp/App/app_mygpio 
  3. $ touch app_mygpio.c 

文件内容如下：

  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include <unistd.h> 
  4. #include <assert.h> 
  5. #include <fcntl.h> 
  6. #include <sys/ioctl.h> 
  7.  
  8. #define MY_GPIO_NUMBER      4 
  9.  
  10. // 4个设备节点 
  11. char gpio_name[MY_GPIO_NUMBER][16] = { 
  12.     "/dev/mygpio0", 
  13.     "/dev/mygpio1", 
  14.     "/dev/mygpio2", 
  15.     "/dev/mygpio3" 
  16. }; 
  17.  
  18.  
  19. int main(int argc, char *argv[]) 
  20. { 
  21.     int fd, gpio_no, val; 
  22.  
  23.         // 参数个数检查 
  24.     if (3 != argc) 
  25.     { 
  26.         printf("Usage: ./app_gpio gpio_no value \n"); 
  27.         return -1; 
  28.     } 
  29.  
  30.     gpio_no = atoi(argv[1]); 
  31.     val = atoi(argv[2]); 
  32.  
  33.         // 参数合法性检查 
  34.     assert(gpio_no < MY_GPIO_NUMBER); 
  35.     assert(0 == val || 1 == val); 
  36.  
  37.     // 打开 GPIO 设备 
  38.     if((fd = open(gpio_name[gpio_no], O_RDWR | O_NDELAY)) < 0){ 
  39.         printf("%s: open failed! \n", gpio_name[gpio_no]); 
  40.         return -1; 
  41.     } 
  42.  
  43.     printf("%s: open success! \n", gpio_name[gpio_no]); 
  44.  
  45.     // 控制 GPIO 设备状态 
  46.     ioctl(fd, val, gpio_no); 
  47.      
  48.     // 关闭设备 
  49.     close(fd); 
  50. } 

以上代码也不需要过多解释，只要注意参数的顺序即可。

接下来就是编译和测试了：

  1. $ gcc app_mygpio.c -o app_mygpio 

执行应用程序的时候，需要携带2个参数：GPIO 设备编号(0 ~ 3)，设置的状态值(0 或者 1)。

这里设置一下/dev/mygpio0这个设备，状态设置为1：

  1. $ sudo ./app_mygpio 0 1 
  2. [sudo] password for xxx: <输入用户密码> 
  3. /dev/mygpio0: open success! 

如何确认/dev/mygpio0这个GPIO的状态确实被设置为1了呢?当然是看 dmesg 指令的打印信息：

  1. $ dmesg 

通过以上打印信息可以看到：确实执行了的动作。

再继续测试一下：设置 mygpio0 的状态为 0：

  1. $ sudo ./app_mygpio 0 0 

当然了，设置其他几个GPIO口的状态，都是可以正确执行的!

卸载驱动模块

卸载指令：

  1. $ sudo rmmod mygpio 

此时，/proc/devices 下主设备号 244 的 mygpio 已经不存在了.

再来看一下 dmesg的打印信息：

可以看到：驱动程序中的 gpio_driver_exit( ) 被调用执行了。

并且，/dev 目录下的 4 个设备节点，也被函数 device_destroy() 自动删除了!

本文转载自微信公众号「IOT物联网小镇」

相关内容