【正点原子FPGA连载】第二十五章 gpio子系统下的LED驱动实验--摘自【正点原子】领航者ZYNQ之Linux开发指南_V1.3

正点原子运营

1）实验平台：正点原子领航者ZYNQ开发板
2）平台购买地址：https://item.taobao.com/item.htm?&id=606160108761
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-301505-1-1.html
5）对正点原子FPGA感兴趣的同学可以加群讨论：712557122
6）关注正点原子公众号，获取最新资料更新

第二十五章 gpio子系统下的LED驱动实验

在上一章当中已经给大家介绍了linux的gpio子系统，那本章我们就来编写一个基于gpio子系统API的LED驱动程序，本章将在第二十五章实验的基础上进行修改完成。

1.1 实验简介

在《第二十五章 设备树下的LED驱动实验》中，虽然我们在dtsled.c驱动代码中获取到了GPIO有关寄存器物理地址，然后使用of_iomap函数进行内存映射，得到对应的虚拟地址，最后操作寄存器对应的虚拟地址完成对GPIO的初始化，但本质上还是跟裸机没啥区别，还非常的麻烦。所以本章就带大家完成一个gpio子系统下的led驱动程序，本章我们在第二十五章实验基础上完成，本章实验重点内容如下：

①     修改第二十五章创建的led节点，在节点中指定led使用的GPIO。

②     去掉led节点中的reg属性，因为不需要用到了。

③     在第二十三章驱动实验的基础上修改驱动代码，获取设备树中传入的gpio，调用gpio子系统提供的接口函数对gpio进行操控。

1.2 硬件原理图分析

本章实验硬件原理图参考33.3小节即可。

1.3 实验程序编写

本实验对应的例程路径为：ZYNQ开发板光盘资料(A盘)\4_SourceCode\ZYNQ_7010\3_Embedded_Linux\Linux驱动例程\5_gpioled。

本章实验在第二十三章实验的基础上完成，重点是将驱动改为基于gpio子系统的框架下的led驱动代码。

1.3.1 修改设备树文件

1、添加led-gpio节点指定led使用的GPIO

打开linux内核源码目录下的arch/arm/boot/dts/system-top.dts文件，找到第二十五章创建在根节点“/”下的led节点，我们需要对led节点内容进行修改，去掉之前reg属性，添加led-gpio节点指定LED所使用的GPIO管脚，修改完成之后如下所示：

示例代码27.3.1.1 system-top.dts文件led节点

1. #defineGPIO_ACTIVE_HIGH   0
   
2. #defineGPIO_ACTIVE_LOW    1
   
3. 
   
4. /dts-v1/;
   
5. #include "zynq-7000.dtsi"
   
6. #include "pl.dtsi"
   
7. #include "pcw.dtsi"
   
8. / {
   
9.      model = "AlientekZYNQ Development Board";
   
10. 
    
11.      chosen {
    
12.          bootargs = "console=ttyPS0,115200earlyprintk root=/dev/mmcblk0p2 rw rootwait";
    
13.          stdout-path = "serial0:115200n8";
    
14.      };
    
15.      aliases {
    
16.          ethernet0 = &gem0;
    
17.          i2c0 = &i2c_2;
    
18.          i2c1 = &i2c0;
    
19.          i2c2 = &i2c1;
    
20.          serial0 = &uart0;
    
21.          serial1 = &uart1;
    
22.          spi0 = &qspi;
    
23.      };
    
24.      memory {
    
25.          device_type = "memory";
    
26.          reg = <0x0 0x20000000>;
    
27.      };
    
28. 
    
29.      led {
    
30.          compatible = "alientek,led";
    
31.          status = "okay";
    
32.          default-state= "on";
    
33.          led-gpio = <&gpio07 GPIO_ACTIVE_HIGH>;
    
34.      };
    
35. };

复制代码

第7和第8行，在设备树文件中定义了两个宏，这两个宏用来表示GPIO是高电平有效还是低电平有效，GPIO_ACTIVE_HIGH表示高电平有效。

第35~40行，将之前定义的reg属性给去掉了，加上了一个“led-gpio”属性，它的值等于“<&gpio0 7 GPIO_ACTIVE_HIGH>”，led-gpio属性指定了LED灯所使用的GPIO，在这里就是GPIO0的IO07，低电平有效，这些东西在第二十七章给大家讲过了，这里不再重复啰嗦！稍后编写驱动程序的时候会获取led-gpio属性的内容来得到GPIO编号，因为gpio子系统的API操作函数需要GPIO编号。

2、添加pinctrl节点

对于ZYNQ来说，我们不需要pinctrl，原因前面已经给大家讲过了！

3、重新编译system-top.dts

上面修改完成之后，执行下面的命令重新编译system-top.dts，如下所示：

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-system-top.dtb

图24.3.1 重新编译设备树

编译完成之后将system-top.dtb文件重命名为system.dtb，然后将其拷贝到开发板的SD启动卡Fat分区，替换掉之前的system.dtb文件，然后重启开发板，进入到/proc/device-tree目录下，可以看到我们的led节点，进入到led节点目录下，如下所示：

图24.3.2 led节点下的属性

可以看到有一个“led-gpio”文件，这就是我们前面新添加的属性。因为led-gpio属性的值是引用别的节点，所以直接用cat命令看不到这个文件的东西，我们可以使用od命令查看，如下所示：

图24.3.3 od命令查看属性

所以可以知道它里面是有东西的。

1.3.2 LED灯驱动程序编写

设备树准备好以后就可以编写驱动程序了，本章实验在第二十五章实验驱动文件dtsled.c的基础上修改而来。首先在drivers目录下新建名为“5_gpioled”文件夹，然后在5_gpioled文件夹里面新建gpioled.c文件，在gpioled.c里面输入如下内容：

示例代码27.3.2.1 gpioled.c文件内容

1. /***************************************************************
   
2.   Copyright ? ALIENTEK Co., Ltd. 1998-2029. Allrights reserved.
   
3.   文件名    : gpioled.c
   
4.   作者      : 邓涛
   
5.   版本      : V1.0
   
6.   描述      : ZYNQ LED驱动文件。
   
7.   其他      : 无
   
8.   论坛      : www.openedv.com
   
9.   日志      : 初版V1.0 2019/1/30 邓涛创建
   
10. ***************************************************************/
    
11. 
    
12. #include <linux/types.h>
    
13. #include <linux/kernel.h>
    
14. #include <linux/delay.h>
    
15. #include <linux/ide.h>
    
16. #include <linux/init.h>
    
17. #include <linux/module.h>
    
18. #include <linux/errno.h>
    
19. #include <linux/gpio.h>
    
20. #include <asm/mach/map.h>
    
21. #include <asm/uaccess.h>
    
22. #include <asm/io.h>
    
23. #include <linux/cdev.h>
    
24. #include <linux/of.h>
    
25. #include <linux/of_address.h>
    
26. #include <linux/of_gpio.h>
    
27. 
    
28. #defineGPIOLED_CNT     1          /* 设备号个数 */
    
29. #defineGPIOLED_NAME    "gpioled"  /* 名字 */
    
30. 
    
31. /*dtsled设备结构体 */
    
32. structgpioled_dev {
    
33.     dev_t devid;            /* 设备号 */
    
34.     struct cdev cdev;       /* cdev */
    
35.     struct class *class;    /* 类 */
    
36.     struct device *device;  /* 设备 */
    
37.     int major;              /* 主设备号 */
    
38.     int minor;              /* 次设备号 */
    
39.     struct device_node *nd; /* 设备节点 */
    
40.     int led_gpio;           /* LED所使用的GPIO编号 */
    
41. };
    
42. 
    
43. static structgpioled_dev gpioled;  /* led设备 */
    
44. 
    
45. /*
    
46. * @description         : 打开设备
    
47. * @param – inode       : 传递给驱动的inode
    
48. * @param - filp        : 设备文件，file结构体有个叫做private_data的成员变量
    
49. *                        一般在open的时候将private_data指向设备结构体。
    
50. * @return              : 0 成功;其他 失败
    
51. */
    
52. static intled_open(struct inode *inode, struct file*filp)
    
53. {
    
54.     filp->private_data= &gpioled;  /* 设置私有数据 */
    
55.     return 0;
    
56. }
    
57. 
    
58. /*
    
59. * @description         : 从设备读取数据
    
60. * @param - filp        : 要打开的设备文件(文件描述符)
    
61. * @param - buf         : 返回给用户空间的数据缓冲区
    
62. * @param - cnt         : 要读取的数据长度
    
63. * @param - offt        : 相对于文件首地址的偏移
    
64. * @return              : 读取的字节数，如果为负值，表示读取失败
    
65. */
    
66. staticssize_t led_read(struct file *filp, char__user *buf,
    
67.             size_t cnt,loff_t *offt)
    
68. {
    
69.         return 0;
    
70. }
    
71. 
    
72. /*
    
73. * @description         : 向设备写数据
    
74. * @param - filp        : 设备文件，表示打开的文件描述符
    
75. * @param - buf         : 要写给设备写入的数据
    
76. * @param - cnt         : 要写入的数据长度
    
77. * @param - offt        : 相对于文件首地址的偏移
    
78. * @return              : 写入的字节数，如果为负值，表示写入失败
    
79. */
    
80. staticssize_t led_write(struct file *filp, const char__user *buf,
    
81.             size_t cnt,loff_t *offt)
    
82. {
    
83.     int ret;
    
84.     char kern_buf[1];
    
85. 
    
86.     ret = copy_from_user(kern_buf, buf, cnt);   // 得到应用层传递过来的数据
    
87.     if(0 > ret) {
    
88.         printk(KERN_ERR"kernel write failed!\r\n");
    
89.         return -EFAULT;
    
90.     }
    
91. 
    
92.     if (0 ==kern_buf[0])
    
93.         gpio_set_value(gpioled.led_gpio, 0); // 如果传递过来的数据是0则关闭led
    
94.     else if (1 ==kern_buf[0])
    
95.         gpio_set_value(gpioled.led_gpio, 1); // 如果传递过来的数据是1则点亮led
    
96. 
    
97.     return 0;
    
98. }
    
99. 
    
100. /*
     
101.   * @description         : 关闭/释放设备
     
102.   * @param – filp        : 要关闭的设备文件(文件描述符)
     
103.   * @return              : 0 成功;其他 失败
     
104.   */
     
105. static intled_release(struct inode *inode, struct file*filp)
     
106. {
     
107.      return 0;
     
108. }
     
109. 
     
110. /* 设备操作函数 */
     
111. static structfile_operations gpioled_fops = {
     
112.      .owner   = THIS_MODULE,
     
113.      .open    =led_open,
     
114.      .read    =led_read,
     
115.      .write   = led_write,
     
116.      .release= led_release,
     
117. };
     
118. 
     
119. static int__init led_init(void)
     
120. {
     
121.      const char *str;
     
122.      int ret;
     
123. 
     
124.      /* 1.获取led设备节点 */
     
125.      gpioled.nd =of_find_node_by_path("/led");
     
126.      if(NULL ==gpioled.nd) {
     
127.          printk(KERN_ERR"gpioled: Failed to get /led node\n");
     
128.          return -EINVAL;
     
129.      }
     
130. 
     
131.      /* 2.读取status属性 */
     
132.      ret =of_property_read_string(gpioled.nd, "status", &str);
     
133.      if(!ret) {
     
134.          if (strcmp(str, "okay"))
     
135.              return -EINVAL;
     
136.      }
     
137. 
     
138.      /* 2、获取compatible属性值并进行匹配 */
     
139.      ret =of_property_read_string(gpioled.nd, "compatible", &str);
     
140.      if(0 > ret) {
     
141.          printk(KERN_ERR"gpioled: Failed to get compatible property\n");
     
142.          return ret;
     
143.      }
     
144. 
     
145.      if (strcmp(str, "alientek,led")) {
     
146.          printk(KERN_ERR"gpioled: Compatible match failed\n");
     
147.          return -EINVAL;
     
148.      }
     
149. 
     
150.      printk(KERN_INFO"gpioled: device matching successful!\r\n");
     
151. 
     
152.      /* 4.获取设备树中的led-gpio属性，得到LED所使用的GPIO编号 */
     
153.      gpioled.led_gpio= of_get_named_gpio(gpioled.nd, "led-gpio", 0);
     
154.      if(!gpio_is_valid(gpioled.led_gpio)) {
     
155.          printk(KERN_ERR"gpioled: Failed to get led-gpio\n");
     
156.          return -EINVAL;
     
157.      }
     
158. 
     
159.      printk(KERN_INFO"gpioled: led-gpio num = %d\r\n",gpioled.led_gpio);
     
160. 
     
161.      /* 5.向gpio子系统申请使用GPIO*/
     
162.      ret =gpio_request(gpioled.led_gpio, "LED-GPIO");
     
163.      if (ret) {
     
164.          printk(KERN_ERR"gpioled: Failed to request led-gpio\n");
     
165.          return ret;
     
166.      }
     
167. 
     
168.      /* 6.将ledgpio管脚设置为输出模式 */
     
169.      gpio_direction_output(gpioled.led_gpio, 0);
     
170. 
     
171.      /* 7.初始化LED的默认状态 */
     
172.      ret =of_property_read_string(gpioled.nd, "default-state", &str);
     
173.      if(!ret) {
     
174.          if (!strcmp(str, "on"))
     
175.              gpio_set_value(gpioled.led_gpio, 1);
     
176.          else
     
177.              gpio_set_value(gpioled.led_gpio, 0);
     
178.      } else
     
179.          gpio_set_value(gpioled.led_gpio, 0);
     
180. 
     
181.      /* 8.注册字符设备驱动 */
     
182.       /* 创建设备号 */
     
183.      if (gpioled.major) {
     
184.          gpioled.devid= MKDEV(gpioled.major, 0);
     
185.          ret =register_chrdev_region(gpioled.devid,GPIOLED_CNT, GPIOLED_NAME);
     
186.          if (ret)
     
187.              goto out1;
     
188.      } else {
     
189.          ret =alloc_chrdev_region(&gpioled.devid, 0,GPIOLED_CNT, GPIOLED_NAME);
     
190.          if (ret)
     
191.              goto out1;
     
192. 
     
193.          gpioled.major= MAJOR(gpioled.devid);
     
194.          gpioled.minor= MINOR(gpioled.devid);
     
195.      }
     
196. 
     
197.      printk("gpioled:major=%d,minor=%d\r\n",gpioled.major,gpioled.minor);
     
198. 
     
199.       /* 初始化cdev */
     
200.      gpioled.cdev.owner= THIS_MODULE;
     
201.      cdev_init(&gpioled.cdev, &gpioled_fops);
     
202. 
     
203.       /* 添加一个cdev */
     
204.      ret =cdev_add(&gpioled.cdev,gpioled.devid, GPIOLED_CNT);
     
205.      if (ret)
     
206.          goto out2;
     
207. 
     
208.       /* 创建类 */
     
209.      gpioled.class= class_create(THIS_MODULE,GPIOLED_NAME);
     
210.      if (IS_ERR(gpioled.class)) {
     
211.          ret =PTR_ERR(gpioled.class);
     
212.          goto out3;
     
213.      }
     
214. 
     
215.       /* 创建设备 */
     
216.      gpioled.device= device_create(gpioled.class, NULL,
     
217.                  gpioled.devid, NULL,GPIOLED_NAME);
     
218.      if (IS_ERR(gpioled.device)) {
     
219.          ret =PTR_ERR(gpioled.device);
     
220.          goto out4;
     
221.      }
     
222. 
     
223.      return 0;
     
224. 
     
225. out4:
     
226.      class_destroy(gpioled.class);
     
227. 
     
228. out3:
     
229.      cdev_del(&gpioled.cdev);
     
230. 
     
231. out2:
     
232.      unregister_chrdev_region(gpioled.devid,GPIOLED_CNT);
     
233. 
     
234. out1:
     
235.      gpio_free(gpioled.led_gpio);
     
236. 
     
237.      return ret;
     
238. }
     
239. 
     
240. static void__exit led_exit(void)
     
241. {
     
242.      /* 注销设备 */
     
243.      device_destroy(gpioled.class,gpioled.devid);
     
244. 
     
245.      /* 注销类 */
     
246.      class_destroy(gpioled.class);
     
247. 
     
248.      /* 删除cdev */
     
249.      cdev_del(&gpioled.cdev);
     
250. 
     
251.      /* 注销设备号 */
     
252.      unregister_chrdev_region(gpioled.devid,GPIOLED_CNT);
     
253. 
     
254.      /* 释放GPIO */
     
255.      gpio_free(gpioled.led_gpio);
     
256. }
     
257. 
     
258. /* 驱动模块入口和出口函数注册 */
     
259. module_init(led_init);
     
260. module_exit(led_exit);
     
261. 
     
262. MODULE_AUTHOR("DengTao<773904075@qq.com>");
     
263. MODULE_DESCRIPTION("AlientekZYNQ GPIO LED Driver");
     
264. MODULE_LICENSE("GPL");

复制代码

第26行，使用include包含of_gpio.h头文件，因为我们的代码中使用到了与gpio相关的OF函数。

第28~29行，定义led设备的设备号数量以及led设备的名字。

第32~41行，定义了struct gpioled_dev结构体，在第二十五章的基础上加入led_gpio用来表示GPIO的编号。

第80~98行，使用gpio_set_value函数替代第二十五章直接操作GPIO寄存器的做法，那么这个函数我们在前面一张给大家介绍过了。

第125~129行，跟之前是一样的，从设备树中获取led节点，包括后面读取“status”属性以及“compatible”属性。

第153~157行，重点在这里，使用of_get_named_gpio函数获取设备树中led节点指定的gpio管脚，得到一个GPIO编号，那么这个编号是linux内核GPIO子系统对gpio的编号，一个编号就对应一个gpio，那么我们这里得到的这个编号就对应设备树中led-gpio指定的那个管脚（gpio0_7---MIO7）。得到GPIO编号之后使用gpio_is_valid函数判断编号是否是有效编号。

第162~166行，通过gpio_request函数去申请对该gpio管脚的使用权。

第169行，通过gpio_direction_output函数将gpio设置为输出模式。

第172~179行，根据led节点的“default-state”属性初始化LED的状态，使用gpio_set_value函数设置gpio输出高或低电平。

后面跟第二十五章就是一样的，需要注意的是，第240~256行，驱动模块的出口函数中一定要把申请的gpio管脚给释放，通过gpio_free函数释放gpio。

1.3.3 编写测试APP

本章直接使用第二十五章的测试APP，将第二十五章实验目录下的测试APP源程序ledApp.c以及编译好的可执行文件ledApp全部拷贝到本章实验目录下，这样就不用再次编译ledApp.c文件了。

1.4 运行测试1.4.1 编译驱动程序和测试APP

1、编译驱动程序

编写Makefile文件，同样也是将第二十五章实验目录下的Makefile文件直接拷贝到本章实验目录下，只是将obj-m变量的值改为gpioled.o，Makefile内容如下所示：

示例代码27.4.1.1 Makefile文件

1. KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
   
2. 
   
3. obj-m :=gpioled.o
   
4. 
   
5. all:
   
6.          make ARCH=armCROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd`modules
   
7. 
   
8. clean:
   
9.          make -C $(KERN_DIR) M=`pwd`clean

复制代码

第3行，设置obj-m变量的值为gpioled.o。

修改完成之后保存退出，此时在我们的工程目录（5_gpioled）下有如下文件：

图 24.4.1 5_gpioled目录下的文件

输入如下命令编译出驱动模块文件：

make

编译成功以后就会生成一个名为“gpioled.ko”的驱动模块文件，如下所示：

图24.4.2 编译驱动模块

2、编译测试APP

不用编译直接上一章的ledApp可执行文件即可！

1.4.2 运行测试

将前面编译出来的gpioled.ko和ledApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中，重启开发板，进入到目录/lib/modules/4.14.0-xilinx中，输入如下命令加载gpioled.ko驱动模块：

depmod                       //第一次加载驱动的时候需要运行此命令

modprobe gpioled.ko    //加载驱动

驱动加载成功以后会在终端中输出一些信息，如下图所示：

图 24.4.3 加载gpioled驱动模块

从图 38.4.3中可以看出，通过of_get_named_gpio函数得到gpio0_7（MIO7）这个GPIO的编号为910。看起来这个数字有点大哈，不过没关系，能用就行！驱动加载成功以后就可以使用ledApp软件来测试驱动是否工作正常，输入如下命令打开LED灯：

./ledApp /dev/gpioled 0        //关闭LED灯

输入上述命令以后查看开发板上的PS_LED0灯是否熄灭，如果熄灭的话说明驱动工作正常。在输入如下命令打开LED灯：

./ledApp /dev/gpioled 0        //打开LED灯

输入上述命令以后查看开发板上的PS_LED0灯是否点亮。如果要卸载驱动的话输入如下命令即可：

rmmod gpioled.ko