正点原子j-link驱动下载_「正点原子FPGA连载」第二十八章Linux蜂鸣器驱动实验

1)摘自【正点原子】领航者 ZYNQ 之linux驱动开发指南

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

第二十八章Linux蜂鸣器驱动实验

上一章实验中我们借助gpio子系统编写了LED灯驱动，领航者开发板上还有一个蜂鸣器，从软件的角度考虑，蜂鸣器驱动和LED灯驱动其实是一摸一样的，都是控制IO输出高低电平。本章我们就来学习编写蜂鸣器的Linux驱动，也算是对上一章讲解的gpio子系统的巩固。
28.1有源蜂鸣器简介
蜂鸣器常用于计算机、打印机、报警器、电子玩具等电子产品中，常用的蜂鸣器有两种：有源蜂鸣器和无源蜂鸣器，这里的有“源”不是电源，而是震荡源，有源蜂鸣器内部带有震荡源，所以有源蜂鸣器只要通电就会叫。无源蜂鸣器内部不带震荡源，直接用直流电是驱动不起来的，需要2K-5K的方波去驱动。领航者开发板使用的是有源蜂鸣器，因此只要给其供电就会工作，开发板所使用的有源蜂鸣器如下图所示：

图 39.1.1 有源蜂鸣器

有源蜂鸣器只要通电就会叫，所以我们可以做一个供电电路，这个供电电路可以由一个IO来控制其通断，一般使用三极管来搭建这个电路。为什么我们不能像控制LED灯一样，直接将GPIO接到蜂鸣器的负极，通过IO输出高低来控制蜂鸣器的通断。因为蜂鸣器工作的电流比LED灯要大，直接将蜂鸣器接到开发板的GPIO上有可能会烧毁IO，所以我们需要通过一个三极管来间接的控制蜂鸣器的通断，相当于加了一层隔离。本章我们就驱动开发板上的有源蜂鸣器，使其周期性的“滴、滴、滴…..”鸣叫。
本节我们来看一下如果在Linux下编写蜂鸣器驱动需要做哪些工作：
①在设备树中创建蜂鸣器节点beeper；
②在蜂鸣器节点beeper中指定gpio；
③编写驱动程序和测试APP，和第二十七章的LED驱动程序和测试APP基本一样。
接下来我们就根据上面这三步来编写蜂鸣器Linux驱动程序。
28.2硬件原理图分析
打开领航者底板原理图文件，找到蜂鸣器电路原理图，如下所示：

图 39.2.1 蜂鸣器原理图

图 39.2.1中通过一个NPN型的三极管S8050来驱动蜂鸣器，通过BEEP这个IO来控制三极管Q1的导通，当BEEP输出高电平的时候Q1导通，相当于蜂鸣器的负极连接到GND，蜂鸣器形成一个通路，因此蜂鸣器会鸣叫。同理，当BEEP输出低电平的时候Q1不导通，那么蜂鸣器就没有形成一个通路，因此蜂鸣器也就不会鸣叫。
在原理图中搜索“BEEP”标号，可知BEEP连接到了ZYNQ的G18引脚，如下所示：

图 39.2.2 BEEP管脚

G18并不是MIO引脚，而是PL端的IO引脚，但是PS可以通过EMIO来连接PL端引脚，关于MIO和EMIO的详细内容请大家阅读《领航者ZYNQ之嵌入式开发指南》的第二和第三章的内容，这里就不给大家做过多的介绍。
本篇驱动开发篇使用的hdf文件对应的vivado工程，是笔者配置的，使能了EMIO，并将G18引脚绑定到了EMIO，如下所示：

图 39.2.3 EMIO连接G18引脚

所以由上面可以知道，G18连接到了EMIO的第7个引脚emio[6]，由于EMIO对应的GPIO起始编号是从54开始的，所以由此可知emio[6]对应的就是GPIO 60(54 + 6)，关于MIO和EMIO编号的问题在《领航者ZYNQ之嵌入式开发指南》的第二和第三章有详细的说明。
所以目标很明确了，蜂鸣器就是通过GPIO 60控制的，那么在我们的驱动代码当中就是对GPIO 60进行控制从而控制蜂鸣器鸣叫和关闭！
28.3实验程序编写
本实验对应的例程路径为：ZYNQ开发板光盘资料(A盘)4_SourceCodeZYNQ_70103_Embedded_LinuxLinux驱动例程6_beeper。
本章也是直接在前面的实验当中进行修改。
28.3.1修改设备树文件
打开system-top.dts文件，在根节点“/”下创建一个名为beeper的节点，节点内容如下：
示例代码28.3.1.1 system-top.dts蜂鸣器节点beeper

1. 42 beeper {
2. 43 compatible = "alientek,beeper";
3. 44 status = "okay";
4. 45 default-state = "off";
5. 46 beeper-gpio = ;
6. 47 };

第43行，设置beeper节点的compatible属性为“alientek,beeper”，我们在驱动代码中会区匹配这个属性的值。
第45行，将default-state属性的值设置为“off”，我们在代码中会根据default-state属性的值来设置蜂鸣器的初始化状态。
第46行，beeper-gpio属性指定所需的GPIO。
设备树编写完成以后使用下面这条命令重新编译设备树，如下所示：

图 39.3.1 重新编译设备树

将编译出来的system-top.dtb文件重命名为system.dtb，然后将system.dtb文件拷贝到开发板SD启动卡的FAT分区，替换旧的dtb文件。替换成功之后重新启动成功开发板，以后进入“/proc/device-tree”目录中查看“beeper”节点是否存在，如果存在的话就说明设备树基本修改成功(具体还要驱动验证)，结果如下图所示：

图 39.3.2 beeper节点

28.3.2蜂鸣器驱动程序编写
设备树准备好以后就可以编写驱动程序了，在我们的drivers目录下新建名为“6_beeper”的文件夹，然后在6_beeper文件中新建beeper.c文件，在beeper.c里面输入如下内容：
示例代码28.3.2.1 beeper.c文件内容

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

beep.c中的内容和上一章的gpioled.c中的内容基本一样，基本上就是改了下命名。
28.3.3编写测试APP
测试APP程序直接将上一章工程目录下的ledApp.c文件拷贝到当前实验目录，将其重命名为beeperApp.c即可。
28.4运行测试
28.4.1编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件，直接将上一章实验目录下的Makefile文件拷贝到本实验目录，修改Makefile文件，将obj-m变量的值改为beeper.o，修改完成之后Makefile内容如下所示：
示例代码28.4.1.1 Makefile文件内容

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

第3行，设置obj-m变量的值为beeper.o。
修改完成之后保存退出，输入如下命令编译出驱动模块文件：

1. make

编译成功以后就会生成一个名为“beeper.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试beeperApp.c这个测试程序：

1. arm-linux-gnueabihf-gcc beeperApp.c -o beeperApp

编译成功以后就会生成beeperApp这个应用程序，最终在本章实验实验目录下有如下文件：

图 39.4.1 本章实验目录下的文件

28.4.2运行测试
将上一小节编译出来的beeper.ko和beeperApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中，然后重启开发板，进入到目录/lib/modules/4.14.0-xilinx目录，输入如下命令加载beeper.ko驱动模块：

1. depmod //第一次加载驱动的时候需要运行此命令
2. modprobe beep.ko //加载驱动

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

图 39.4.2 加载beeper.ko驱动模块

从图 39.4.2中可以看出，在内核驱动中获取到的GPIO0_60的编号为963，使用beeperApp软件来测试驱动是否工作正常，输入如下命令打开蜂鸣器：

1. ./beeperApp /dev/beeper 1 //打开蜂鸣器

执行上述命令之后，开发板的蜂鸣器是会鸣叫的，如果鸣叫的话说明驱动工作正常。在输入如下命令关闭蜂鸣器：

1. ./beeperApp /dev/beeper 0 //关闭蜂鸣器

执行上述命令后，开发板的蜂鸣器会停止鸣叫。如果要卸载驱动的话输入如下命令即可：

1. rmmod beep.ko