搜索
bottom↓
回复: 0

《领航者ZYNQ之嵌入式Linux开发指南_V2.0》第二十七章 gpio子系统LED

[复制链接]

出0入234汤圆

发表于 2022-1-20 18:31:43 | 显示全部楼层 |阅读模式
1)实验平台:正点原子领航者V2 ZYNQ开发板
2)  章节摘自【正点原子】《领航者ZYNQ之嵌入式Linux开发指南_V2.0》
3)购买链接:https://detail.tmall.com/item.htm?id=609032204975
4)全套实验源码+手册+视频下载地址:http://www.openedv.com/thread-329957-1-1.html
5)正点原子官方B站:https://space.bilibili.com/394620890
6)正点原子FPGA技术交流QQ群:90562473
[/url]

[url=https://www.yuanzige.com/]






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

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

       1.1实验简介

       在第二十五章中,虽然我们在dtsled.c驱动代码中获取到了GPIO有关寄存器物理地址,然后使用of_iomap函数进行内存映射,得到对应的虚拟地址,最后操作寄存器对应的虚拟地址完成对GPIO的初始化,但本质上还是跟裸机没啥区别,还非常的麻烦。所以本章就带大家完成一个gpio子系统下的led驱动程序,本章我们在第二十五章实验基础上完成,本章实验重点内容如下:
       ①修改第二十五章创建的led节点,在节点中指定led使用的GPIO。
       ②去掉led节点中的reg属性,因为不需要用到了。
       ③在第二十三章驱动实验的基础上修改驱动代码,获取设备树中传入的gpio,调用gpio子系统提供的接口函数对gpio进行操控。
       1.2硬件原理图分析
       本章实验硬件原理图参考22.3小节即可。
       1.3实验程序编写
       本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\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管脚,修改完成之后如下所示:
  1. 示例代码 27.3.1 system-top.dts文件led节点
  2.   7 #define GPIO_ACTIVE_HIGH   0
  3.   8 #define GPIO_ACTIVE_LOW    1
  4.   9
  5. 10 /dts-v1/;
  6. 11 #include "zynq-7000.dtsi"
  7. 12 #include "pl.dtsi"
  8. 13 #include "pcw.dtsi"
  9. 14 / {
  10. 15     model = "Alientek ZYNQ Development Board";
  11. 16
  12. 17     chosen {
  13. 18         bootargs = "console=ttyPS0,115200 earlyprintk root=/dev/mmcblk0p2 rw rootwait";
  14. 19         stdout-path = "serial0:115200n8";
  15. 20     };
  16. 21     aliases {
  17. 22         ethernet0 = &gem0;
  18. 23         i2c0 = &i2c_2;
  19. 24         i2c1 = &i2c0;
  20. 25         i2c2 = &i2c1;
  21. 26         serial0 = &uart0;
  22. 27         serial1 = &uart1;
  23. 28         spi0 = &qspi;
  24. 29     };
  25. 30     memory {
  26. 31         device_type = "memory";
  27. 32         reg = <0x0 0x20000000>;
  28. 33     };
  29. 34
  30. 35     led {
  31. 36         compatible = "alientek,led";
  32. 37         status = "okay";
  33. 38         default-state = "on";
  34. 39         led-gpio = <&gpio0 7 GPIO_ACTIVE_HIGH>;
  35. 40     };
  36. 41 };
复制代码
       第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,如下所示:
  1. make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- system-top.dtb
复制代码

图 27.3.1 重新编译设备树

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

图 27.3.2 led节点下的属性

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

图 27.3.3 od命令查看属性

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

图 27.4.1 5_gpioled目录下的文件

       输入如下命令编译出驱动模块文件:
  1. make
复制代码
       编译成功以后就会生成一个名为“gpioled.ko”的驱动模块文件,如下所示:

图 27.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驱动模块:
  1. depmod                                //第一次加载驱动的时候需要运行此命令
  2. modprobe gpioled.ko        //加载驱动
复制代码
       驱动加载成功以后会在终端中输出一些信息,如下图所示:

图 27.4.3 加载gpioled驱动模块

       从图 27.4.3中可以看出,通过of_get_named_gpio函数得到gpio0_7(MIO7)这个GPIO的编号为910。看起来这个数字有点大哈,不过没关系,能用就行!驱动加载成功以后就可以使用ledApp软件来测试驱动是否工作正常,输入如下命令打开LED灯:
  1. ./ledApp /dev/gpioled 0                //关闭LED灯
复制代码
       输入上述命令以后查看开发板上的PS_LED0灯是否熄灭,如果熄灭的话说明驱动工作正常。在输入如下命令打开LED灯:
  1. ./ledApp /dev/gpioled 0                //打开LED灯
复制代码

       输入上述命令以后查看开发板上的PS_LED0灯是否点亮。如果要卸载驱动的话输入如下命令即可:
  1. rmmod gpioled.ko
复制代码

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子论坛 ( 公安交互式论坛备案:44190002001997 粤ICP备09047143号 )

GMT+8, 2022-7-2 15:38

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表