|
本帖最后由 正点原子 于 2020-9-16 12:43 编辑
1)实验平台:正点原子领航者ZYNQ开发板
2)平台购买地址:https://item.taobao.com/item.htm?&id=606160108761
3)全套实验源码+手册+视频下载地址:http://www.openedv.com/docs/boards/fpga/zdyz_linhanz.html
4) 正点原子官方B站:https://space.bilibili.com/394620890
5)对正点原子FPGA感兴趣的同学可以加群讨论:876744900 点击加入:
6)关注正点原子公众号,获取最新资料
第三十章Linux并发与竞争实验
在上一章中我们学习了Linux下的并发与竞争,并且学习了四种常用的处理并发和竞争的机制:原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。
30.1原子操作实验
本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\ZYNQ_7010\3_Embedded_Linux\Linux驱动例程\7_atomic。
本例程我们在第二十七章的gpioled.c文件基础上完成。在本节使用中我们使用原子操作来实现对LED这个设备的互斥访问,也就是一次只允许一个应用程序可以使用LED灯。
30.1.1实验程序编写
1、修改设备树文件
因为本章实验是在第二十七章实验的基础上完成的,因此不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第二十七章实验驱动文件gpioled.c的基础上修改而来。首先在我们的drivers目录下新建名为“7_atomic”的文件夹,将第二十七章实验目录下的gpioled.c复制到7_atomic文件夹中,并且重命名为atomic.c。
本节实验重点就是使用atomic来实现一次只能允许一个应用访问LED,所以我们只需要在atomic.c文件源码的基础上加上添加atomic相关代码即可,完成以后的atomic.c文件内容如下所示:
示例代码30.1.1.1 atomic.c文件内容
- 1 /***************************************************************
- 2 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
- 3 文件名 : atomic.c
- 4 作者 : 邓涛
- 5 版本 : V1.0
- 6 描述 : 原子操作实验,使用原子变量来实现对实现设备的互斥访问
- 7 其他 : 无
- 8 论坛 : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
- 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 #define GPIOLED_CNT 1 /* 设备号个数 */
- 29 #define GPIOLED_NAME "gpioled" /* 名字 */
- 30
- 31 /* dtsled设备结构体 */
- 32 struct gpioled_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 atomic_t lock; /* 原子变量 */
- 42 };
- 43
- 44 static struct gpioled_dev gpioled; /* led设备 */
- 45
- 46 /*
- 47 * @description : 打开设备
- 48 * @param – inode : 传递给驱动的inode
- 49 * @param – filp : 设备文件,file结构体有个叫做private_data的成员变量
- 50 * 一般在open的时候将private_data指向设备结构体。
- 51 * @return : 0 成功;其他 失败
- 52 */
- 53 static int led_open(struct inode *inode, struct file *filp)
- 54 {
- 55 /* 通过判断原子变量的值来检查LED有没有被别的应用使用 */
- 56 if (!atomic_dec_and_test(&gpioled.lock)) {
- 57 printk(KERN_ERR "gpioled: Device is busy!\n");
- 58 atomic_inc(&gpioled.lock); /* 小于0的话就加1,使其原子变量等于0 */
- 59 return -EBUSY; /* LED被其他应用使用,返回忙 */
- 60 }
- 61
- 62 return 0;
- 63 }
- 64
- 65 /*
- 66 * @description : 从设备读取数据
- 67 * @param – filp : 要打开的设备文件(文件描述符)
- 68 * @param – buf : 返回给用户空间的数据缓冲区
- 69 * @param – cnt : 要读取的数据长度
- 70 * @param – offt : 相对于文件首地址的偏移
- 71 * @return : 读取的字节数,如果为负值,表示读取失败
- 72 */
- 73 static ssize_t led_read(struct file *filp, char __user *buf,
- 74 size_t cnt, loff_t *offt)
- 75 {
- 76 return 0;
- 77 }
- 78
- 79 /*
- 80 * @description : 向设备写数据
- 81 * @param – filp : 设备文件,表示打开的文件描述符
- 82 * @param – buf : 要写给设备写入的数据
- 83 * @param – cnt : 要写入的数据长度
- 84 * @param – offt : 相对于文件首地址的偏移
- 85 * @return : 写入的字节数,如果为负值,表示写入失败
- 86 */
- 87 static ssize_t led_write(struct file *filp, const char __user *buf,
- 88 size_t cnt, loff_t *offt)
- 89 {
- 90 int ret;
- 91 char kern_buf[1];
- 92
- 93 ret = copy_from_user(kern_buf, buf, cnt); // 得到应用层传递过来的数据
- 94 if(0 > ret) {
- 95 printk(KERN_ERR "kernel write failed!\r\n");
- 96 return -EFAULT;
- 97 }
- 98
- 99 if (0 == kern_buf[0])
- 100 gpio_set_value(gpioled.led_gpio, 0); // 如果传递过来的数据是0则关闭led
- 101 else if (1 == kern_buf[0])
- 102 gpio_set_value(gpioled.led_gpio, 1); // 如果传递过来的数据是1则点亮led
- 103
- 104 return 0;
- 105 }
- 106
- 107 /*
- 108 * @description : 关闭/释放设备
- 109 * @param – filp : 要关闭的设备文件(文件描述符)
- 110 * @return : 0 成功;其他 失败
- 111 */
- 112 static int led_release(struct inode *inode, struct file *filp)
- 113 {
- 114 /* 关闭驱动文件的时候释放原子变量 */
- 115 atomic_inc(&gpioled.lock);
- 116
- 117 return 0;
- 118 }
- 119
- 120 /* 设备操作函数 */
- 121 static struct file_operations gpioled_fops = {
- 122 .owner = THIS_MODULE,
- 123 .open = led_open,
- 124 .read = led_read,
- 125 .write = led_write,
- 126 .release = led_release,
- 127 };
- 128
- 129 static int __init led_init(void)
- 130 {
- 131 const char *str;
- 132 int ret;
- 133
- 134 /* 1.获取led设备节点 */
- 135 gpioled.nd = of_find_node_by_path("/led");
- 136 if(NULL == gpioled.nd) {
- 137 printk(KERN_ERR "gpioled: Failed to get /led node\n");
- 138 return -EINVAL;
- 139 }
- 140
- 141 /* 2.读取status属性 */
- 142 ret = of_property_read_string(gpioled.nd, "status", &str);
- 143 if(!ret) {
- 144 if (strcmp(str, "okay"))
- 145 return -EINVAL;
- 146 }
- 147
- 148 /* 2、获取compatible属性值并进行匹配 */
- 149 ret = of_property_read_string(gpioled.nd, "compatible", &str);
- 150 if(0 > ret) {
- 151 printk(KERN_ERR "gpioled: Failed to get compatible property\n");
- 152 return ret;
- 153 }
- 154
- 155 if (strcmp(str, "alientek,led")) {
- 156 printk(KERN_ERR "gpioled: Compatible match failed\n");
- 157 return -EINVAL;
- 158 }
- 159
- 160 printk(KERN_INFO "gpioled: device matching successful!\r\n");
- 161
- 162 /* 4.获取设备树中的led-gpio属性,得到LED所使用的GPIO编号 */
- 163 gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
- 164 if(!gpio_is_valid(gpioled.led_gpio)) {
- 165 printk(KERN_ERR "gpioled: Failed to get led-gpio\n");
- 166 return -EINVAL;
- 167 }
- 168
- 169 printk(KERN_INFO "gpioled: led-gpio num = %d\r\n", gpioled.led_gpio);
- 170
- 171 /* 5.向gpio子系统申请使用GPIO */
- 172 ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
- 173 if (ret) {
- 174 printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
- 175 return ret;
- 176 }
- 177
- 178 /* 6.将led gpio管脚设置为输出模式 */
- 179 gpio_direction_output(gpioled.led_gpio, 0);
- 180
- 181 /* 7.初始化LED的默认状态 */
- 182 ret = of_property_read_string(gpioled.nd, "default-state", &str);
- 183 if(!ret) {
- 184 if (!strcmp(str, "on"))
- 185 gpio_set_value(gpioled.led_gpio, 1);
- 186 else
- 187 gpio_set_value(gpioled.led_gpio, 0);
- 188 } else
- 189 gpio_set_value(gpioled.led_gpio, 0);
- 190
- 191 /* 8.注册字符设备驱动 */
- 192 /* 创建设备号 */
- 193 if (gpioled.major) {
- 194 gpioled.devid = MKDEV(gpioled.major, 0);
- 195 ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
- 196 if (ret)
- 197 goto out1;
- 198 } else {
- 199 ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);
- 200 if (ret)
- 201 goto out1;
- 202
- 203 gpioled.major = MAJOR(gpioled.devid);
- 204 gpioled.minor = MINOR(gpioled.devid);
- 205 }
- 206
- 207 printk("gpioled: major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);
- 208
- 209 /* 初始化cdev */
- 210 gpioled.cdev.owner = THIS_MODULE;
- 211 cdev_init(&gpioled.cdev, &gpioled_fops);
- 212
- 213 /* 添加一个cdev */
- 214 ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
- 215 if (ret)
- 216 goto out2;
- 217
- 218 /* 创建类 */
- 219 gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
- 220 if (IS_ERR(gpioled.class)) {
- 221 ret = PTR_ERR(gpioled.class);
- 222 goto out3;
- 223 }
- 224
- 225 /* 创建设备 */
- 226 gpioled.device = device_create(gpioled.class, NULL,
- 227 gpioled.devid, NULL, GPIOLED_NAME);
- 228 if (IS_ERR(gpioled.device)) {
- 229 ret = PTR_ERR(gpioled.device);
- 230 goto out4;
- 231 }
- 232
- 233 /* 9.初始化原子变量 */
- 234 atomic_set(&gpioled.lock, 1); /* 原子变量初始值为1 */
- 235
- 236 return 0;
- 237
- 238 out4:
- 239 class_destroy(gpioled.class);
- 240
- 241 out3:
- 242 cdev_del(&gpioled.cdev);
- 243
- 244 out2:
- 245 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
- 246
- 247 out1:
- 248 gpio_free(gpioled.led_gpio);
- 249
- 250 return ret;
- 251 }
- 252
- 253 static void __exit led_exit(void)
- 254 {
- 255 /* 注销设备 */
- 256 device_destroy(gpioled.class, gpioled.devid);
- 257
- 258 /* 注销类 */
- 259 class_destroy(gpioled.class);
- 260
- 261 /* 删除cdev */
- 262 cdev_del(&gpioled.cdev);
- 263
- 264 /* 注销设备号 */
- 265 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
- 266
- 267 /* 释放GPIO */
- 268 gpio_free(gpioled.led_gpio);
- 269 }
- 270
- 271 /* 驱动模块入口和出口函数注册 */
- 272 module_init(led_init);
- 273 module_exit(led_exit);
- 274
- 275 MODULE_AUTHOR("DengTao <<a href="mailto:773904075@qq.com">773904075@qq.com</a>>");
- 276 MODULE_DESCRIPTION("Alientek ZYNQ GPIO LED Driver");
- 277 MODULE_LICENSE("GPL");
复制代码
第41行,在struct gpioled_dev结构体中定义了一个原子变量lock,用来实现一次只能允许一个应用访问LED灯,led_init驱动入口函数会将lock的值设置为1。
第53~63行,每次调用open函数打开驱动设备的时候先申请lock,如果申请成功的话就表示LED灯还没有被其他的应用使用,如果申请失败就表示LED灯正在被其他的应用程序使用,并打印“gpioled: Device is busy!”。每次打开驱动设备的时候先使用atomic_dec_and_test函数将lock减1,如果atomic_dec_and_test函数返回值为真就表示lock当前值为0,说明设备可以使用。如果atomic_dec_and_test函数返回值为假,就表示lock当前值为负数(lock值默认是1),lock值为负数的可能性只有一个,那就是其他设备正在使用LED。其他设备正在使用LED灯,那么就只能退出了,在退出之前调用函数atomic_inc将lock加1,因为此时lock的值被减成了负数,必须要对其加1,将lock的值变为0。
第115行,LED灯使用完毕,应用程序调用close函数关闭的驱动文件,led_release函数执行,调用atomic_inc释放lcok,也就是将lock加1。
第234行,初始化原子变量lock,初始值设置为1,这样每次就只允许一个应用使用LED灯。
3、编写测试APP
在7_atomic实验目录下新建名为atomicApp.c的测试APP,在里面输入如下所示内容:
示例代码30.1.1.2 atomicApp.c文件内容
- 1 /***************************************************************
- 2 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
- 3 文件名 : atomicApp.c
- 4 作者 : 邓涛
- 5 版本 : V1.0
- 6 描述 : 原子变量测试APP,测试原子变量能不能实现一次
- 7 只允许一个应用程序使用LED。
- 8 其他 : 无
- 9 使用方法 : ./atomicApp /dev/gpioled 0 关闭LED灯
- 10 ./atomicApp /dev/gpioled 1 打开LED灯
- 11 论坛 : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
- 12 日志 : 初版V1.0 2019/1/30 邓涛创建
- 13 ***************************************************************/
- 14
- 15 #include <stdio.h>
- 16 #include <unistd.h>
- 17 #include <sys/types.h>
- 18 #include <sys/stat.h>
- 19 #include <fcntl.h>
- 20 #include <stdlib.h>
- 21 #include <string.h>
- 22
- 23 /*
- 24 * @description : main主程序
- 25 * @param – argc : argv数组元素个数
- 26 * @param – argv : 具体参数
- 27 * @return : 0 成功;其他 失败
- 28 */
- 29 int main(int argc, char *argv[])
- 30 {
- 31 int fd, ret;
- 32 int cnt = 0;
- 33 unsigned char buf[1];
- 34
- 35 if(3 != argc) {
- 36 printf("Usage:\n"
- 37 "\t./atomicApp /dev/gpioled 1 @ close led\n"
- 38 "\t./atomicApp /dev/gpioled 0 @ open led\n"
- 39 );
- 40 return -1;
- 41 }
- 42
- 43 /* 打开设备 */
- 44 fd = open(argv[1], O_RDWR);
- 45 if(0 > fd) {
- 46 printf("ERROR: file %s open failed!\r\n", argv[1]);
- 47 return -1;
- 48 }
- 49
- 50 /* 将字符串转换为int型数据 */
- 51 buf[0] = atoi(argv[2]);
- 52
- 53 /* 向驱动写入数据 */
- 54 ret = write(fd, buf, sizeof(buf));
- 55 if(0 > ret){
- 56 printf("ERROR: LED Control Failed!\r\n");
- 57 close(fd);
- 58 return -1;
- 59 }
- 60
- 61 /* 模拟占用25秒LED设备 */
- 62 for ( ; ; ) {
- 63 sleep(5);
- 64 cnt++;
- 65 printf("App running times:%d\r\n", cnt);
- 66 if(cnt >= 5) break;
- 67 }
- 68
- 69 printf("App running finished!\n");
- 70
- 71 /* 关闭设备 */
- 72 close(fd);
- 73 return 0;
- 74 }
复制代码
atomicApp.c中的内容就是在第二十七章的ledAPP.c的基础上修改而来的,重点是加入了第62~67行的模拟占用25秒LED设备的代码。测试APP在获取到LED设备使用权以后会使用25秒,在使用的这段时间如果有其他的应用也去获取LED灯使用权的话肯定会失败!
30.1.2运行测试
1、编译驱动程序
编写Makefile文件,将二十七章实验目录下的Makefile文件拷贝到7_atomic目录下,修改Makefile文件的obj-m变量,修改完成之后Makefile内容如下所示:
示例代码30.1.2.1 Makefile文件内容
- 1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
- 2
- 3 obj-m := atomic.o
- 4
- 5 all:
- 6 make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
- 7
- 8 clean:
- 9 make -C $(KERN_DIR) M=`pwd` clean
复制代码
第3行,设置obj-m变量的值为atomic.,其它的都没改。
修改完成之后保存退出,输入如下命令编译出驱动模块文件:
make
编译成功以后就会生成一个名为“atomic.ko”的驱动模块文件,如下所示:
图 41.1.1 编译atomic驱动模块
2、编译测试APP
输入如下命令编译测试atomicApp.c这个测试程序:
- arm-linux-gnueabihf-gcc atomicApp.c -o atomicApp
复制代码
编译成功以后就会生成atomicApp这个应用程序。
3、运行测试
将上一小节编译出来的atomic.ko和atomicApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载atomic.ko驱动模块:
- depmod //第一次加载驱动的时候需要运行此命令
- modprobe atomic.ko //加载驱动
复制代码
驱动加载成功以后就可以使用atomicApp软件来测试驱动是否工作正常,输入如下命令以后台运行模式运行atomicApp程序,“&”表示将程序放置后台运行,不占用终端:
- ./atomicApp /dev/gpioled 0 & //熄灭LED灯
复制代码
输入上述命令以后查看开发板上的PS_LED0灯是否熄灭(驱动成功加载之后LED会被点亮),然后每隔5秒都会输出一行“App running times ”,如图 41.1.2所示:
图 41.1.2 熄灭LED灯
从图 41.1.2中可以看出,atomicApp运行正常,输出了“App running times:1”和“App running times:2”,这就是模拟25秒占用LED设备,说明atomicApp这个软件正在使用LED灯。此时再输入如下命令关闭LED灯:
- ./atomicApp /dev/gpioled 1 //点亮LED灯
复制代码
输入上述命令以后会发现如图 41.1.3所示输入信息:
图 41.1.3 点亮LED灯
从图 41.1.3可以看出,打开/dev/gpioled失败!原因是在图 41.1.2中运行的atomicApp软件正在占用/dev/gpioled,也就是它正在占用LED设备,如果再次运行atomicApp软件去操作/dev/gpioled肯定会失败。必须等待图 41.1.2中的atomicApp运行结束,也就是25S结束以后其他软件才能去操作/dev/gpioled。这个就是采用原子变量实现一次只能有一个应用程序访问LED灯。
如果要卸载驱动的话输入如下命令即可:
30.2自旋锁实验
上一节我们使用原子变量实现了一次只能有一个应用程序访问LED灯,本节我们使用自旋锁来实现此功能。在使用自旋锁之前,先回顾一下自旋锁的使用注意事项:
①、自旋锁保护的临界区要尽可能的短,因此在open函数中申请自旋锁,然后在release函数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况,如果设备被使用了那么变量就加一,设备被释放以后变量就减1,我们只需要使用自旋锁保护这个变量即可。
②、考虑驱动的兼容性,合理的选择API函数。
综上所述,在本节例程中,我们通过定义一个变量dev_stats表示设备的使用情况,dev_stats为0的时候表示设备没有被使用,dev_stats大于0的时候表示设备被使用。驱动open函数中先判断dev_stats是否为0,也就是判断设备是否可用,如果为0的话就使用设备,并且将dev_stats加1,表示设备被使用了。使用完以后在release函数中将dev_stats减1,表示设备没有被使用了。因此真正实现设备互斥访问的是变量dev_stats,但是我们要使用自旋锁对dev_stats来做保护。
本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\ZYNQ_7010\3_Embedded_Linux\Linux驱动例程\8_spinlock。
30.2.1实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的,同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第上一节实验驱动文件atomic.c的基础上修改而来。在drivers目录下新建名为“8_spinlock”的文件夹,将7_atomic实验中的atomic.c复制到8_spinlock文件夹中,并且重命名为spinlock.c。将原来使用atomic的地方换为spinlock即可,其他代码不需要修改,完成以后的spinlock.c文件内容如下所示(有省略):
示例代码30.2.1.1 spinlock.c文件内容(片段)
- ......
- 28 #define GPIOLED_CNT 1 /* 设备号个数 */
- 29 #define GPIOLED_NAME "gpioled" /* 名字 */
- 30
- 31 /* dtsled设备结构体 */
- 32 struct gpioled_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 int dev_stats; /* 设备状态: 0,设备未使用; >0,设备已经被使用 */
- 42 spinlock_t lock; /* 自旋锁 */
- 43 };
- 44
- 45 static struct gpioled_dev gpioled; /* led设备 */
- ......
- 54 static int led_open(struct inode *inode, struct file *filp)
- 55 {
- 56 unsigned long flags;
- 57 int ret = 0;
- 58
- 59 /* 自旋锁上锁 */
- 60 spin_lock_irqsave(&gpioled.lock, flags);
- 61
- 62 /* 如果设备被使用了 */
- 63 if (gpioled.dev_stats) {
- 64 printk(KERN_ERR "gpioled: Device is busy!\n");
- 65 ret = -EBUSY;
- 66 goto out;
- 67 }
- 68
- 69 /* 如果设备没有打开,那么就标记已经打开了 */
- 70 gpioled.dev_stats++;
- 71
- 72 out:
- 73 /* 解锁 */
- 74 spin_unlock_irqrestore(&gpioled.lock, flags);
- 75 return ret;
- 76 }
- ......
- 125 static int led_release(struct inode *inode, struct file *filp)
- 126 {
- 127 unsigned long flags;
- 128
- 129 /* 上锁 */
- 130 spin_lock_irqsave(&gpioled.lock, flags);
- 131
- 132 /* 关闭驱动文件的时候将dev_stats减1 */
- 133 if (gpioled.dev_stats)
- 134 gpioled.dev_stats--;
- 135
- 136 /* 解锁 */
- 137 spin_unlock_irqrestore(&gpioled.lock, flags);
- 138
- 139 return 0;
- 140 }
- ......
- 151 static int __init led_init(void)
- 152 {
- ......
- 255 /* 9.初始化自旋锁 */
- 256 spin_lock_init(&gpioled.lock);
- ......
- 273 }
复制代码
第41行,dev_stats变量表示设备状态,如果为0的话表示设备还没有被使用,如果大于0的话就表示设备已经被使用了。
第42行,定义自旋锁变量lock。
第54~76行,在open函数中使用自旋锁实现对设备的互斥访问,第60行调用spin_lock_irqsave函数获取锁,为了考虑到驱动兼容性,这里并没有使用spin_lock函数来获取锁。第63行判断dev_stats是否大于0,如果是的话表示设备已经被使用了,那么就使用goto跳转到out处执行spin_unlock_irqrestore函数释放锁,并且返回-EBUSY。如果设备没有被使用的话就在第70行将dev_stats加1,表示设备要被使用了,然后调用spin_unlock_irqrestore函数释放锁。自旋锁的工作就是保护dev_stats变量,真正实现对设备互斥访问的是dev_stats。
第125~140行,在release函数中将dev_stats减1,表示设备被释放了,可以被其他的应用程序使用。将dev_stats减1的时候需要自旋锁对其进行保护。
第256行,在驱动入口函数led_init中调用spin_lock_init函数初始化自旋锁。
3、编写测试APP
测试APP使用41.1.1小节中的atomicApp.c即可,将7_atomic目录中的atomicApp.c文件拷贝到本例程目录中,并将atomicApp.c重命名为spinlockApp.c即可。
30.2.2运行测试
1、编译驱动程序
编写Makefile文件,将7_atomic目录下的Makefile文件拷贝本实验目录中,打开Makefile文件将obj-m变量的值改为spinlock.o,Makefile内容如下所示:
示例代码30.2.2.1 Makefile文件内容
- 1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
- 2
- 3 obj-m := spinlock.o
- 4
- 5 all:
- 6 make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
- 7
- 8 clean:
- 9 make -C $(KERN_DIR) M=`pwd` clean
复制代码
第3行,设置obj-m变量的值为spinlock.o。
修改完成之后保存退出,输入如下命令编译出驱动模块文件:
make
编译成功以后就会生成一个名为“spinlock.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试spinlockApp.c这个测试程序:
- arm-linux-gnueabihf-gcc spinlockApp.c -o spinlockApp
复制代码
编译成功以后就会生成spinlockApp这个应用程序。
3、运行测试
将上一小节编译出来的spinlock.ko和spinlockApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载spinlock.ko驱动模块:
- depmod //第一次加载驱动的时候需要运行此命令
- modprobe spinlock.ko //加载驱动
复制代码
驱动加载成功以后就可以使用spinlockApp软件测试驱动是否工作正常,测试方法和41.1.2小节中一样,先输入如下命令让spinlockApp软件模拟占用25秒的LED设备:
- ./atomicApp /dev/gpioled 0 & //关闭LED灯
复制代码
紧接着再输入如下命令打开LED灯:
- ./atomicApp /dev/gpioled 0 //打开LED灯
复制代码
看一下能不能打开LED设备,驱动正常工作的话并不会打开LED设备,会提示你“file /dev/gpioled open failed!”,必须等待第一个atomicApp软件运行完成(25S计时结束)才可以再次操作LED设备。
如果要卸载驱动的话输入如下命令即可:
30.3信号量实验
本节我们来使用信号量实现了一次只能有一个应用程序访问LED灯,信号量可以导致休眠,因此信号量保护的临界区没有运行时间限制,可以在驱动的open函数申请信号量,然后在release函数中释放信号量。但是信号量不能用在中断中,本节实验我们不会在中断中使用信号量。
本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\ZYNQ_7010\3_Embedded_Linux\Linux驱动例程\9_semaphore。
30.3.1实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的,同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在上一节实验驱动文件spinlock.c的基础上修改而来。在drivers目录下新建名为“9_semaphore”的文件夹,将8_spinlock实验中的spinlock.c复制到9_semaphore文件夹中,并且重命名为semaphore.c。将原来使用到自旋锁的地方换为信号量即可,其他的内容基本不变,完成以后的semaphore.c文件内容如下所示(有省略):
示例代码30.3.1.1 semaphore.c文件代码
- ......
- 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 #include <linux/semaphore.h>
- 28
- 29 #define GPIOLED_CNT 1 /* 设备号个数 */
- 30 #define GPIOLED_NAME "gpioled" /* 名字 */
- 31
- 32 /* dtsled设备结构体 */
- 33 struct gpioled_dev {
- 34 dev_t devid; /* 设备号 */
- 35 struct cdev cdev; /* cdev */
- 36 struct class *class; /* 类 */
- 37 struct device *device; /* 设备 */
- 38 int major; /* 主设备号 */
- 39 int minor; /* 次设备号 */
- 40 struct device_node *nd; /* 设备节点 */
- 41 int led_gpio; /* LED所使用的GPIO编号 */
- 42 struct semaphore sem; /* 信号量 */
- 43 };
- ......
- 54 static int led_open(struct inode *inode, struct file *filp)
- 55 {
- 56 /* 获取信号量,如果获取不到则会进入休眠状态 */
- 57 if (down_interruptible(&gpioled.sem))
- 58 return -ERESTARTSYS;
- 59
- 60 #if 0
- 61 down(&gpioled.sem);
- 62 #endif
- 63
- 64 return 0;
- 65 }
- ......
- 114 static int led_release(struct inode *inode, struct file *filp)
- 115 {
- 116 /* 释放信号量,信号量值加1 */
- 117 up(&gpioled.sem);
- 118
- 119 return 0;
- 120 }
- ......
- 131 static int __init led_init(void)
- 132 {
- ......
- 235 /* 初始化信号量 */
- 236 sema_init(&gpioled.sem, 1);
- ......
- 253 }
- ......
复制代码
第29行,要使用信号量必须添加<linux/semaphore.h>头文件。
第42行,在设备结构体中添加一个信号量成员变量sem。
第54~65行,在open函数中申请信号量,可以使用down函数,也可以使用down_interruptible函数。如果信号量值大于或等于1就表示可用,那么应用程序就会开始使用LED设备。如果信号量值为0就表示应用程序不能使用LED设备,此时应用程序就会进入到休眠状态。等到信号量值大于或等于1的时候应用程序就会唤醒,申请到信号量,获取LED设备使用权。
第117行,在release函数中调用up函数释放信号量,这样其他因为没有得到信号量而进入休眠状态的应用程序就会唤醒,获取信号量。
第236行,在驱动入口函数中调用sema_init函数初始化信号量sem的值为1,相当于sem是个二值信号量。
总结一下,当信号量sem为1的时候表示LED设备还没有被使用,如果应用程序A要使用LED设备,先调用open函数打开/dev/gpioled,这个时候会获取信号量sem,获取成功以后sem的值减1变为0。如果此时应用程序B也要使用LED设备,调用open函数打开/dev/gpioled就会因为信号量无效(值为0)而进入休眠状态。当应用程序A运行完毕,调用close函数关闭/dev/gpioled的时候就会释放信号量sem,此时信号量sem的值就会加1,变为1。信号量sem再次有效,表示其他应用程序可以使用LED设备了,此时在休眠状态的应用程序A就会被唤醒获取到信号量sem,获取成功以后就开始控制LED设备了。
3、编写测试APP
测试APP使用41.1.1小节中的atomicApp.c即可,将7_atomic中的atomicApp.c文件到本实验目录下中,并将atomicApp.c重命名为semaphoreApp.c即可。
30.3.2运行测试
1、编译驱动程序
编写Makefile文件,将上一小节实验目录下的Makefile文件拷贝到本实验目录9_semaphore下,打开Makefile文件将obj-m变量的值改为semaphore.o,Makefile内容如下所示:
示例代码30.3.2.1 Makefile文件内容
- 1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
- 2
- 3 obj-m := semaphore.o
- 4
- 5 all:
- 6 make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
- 7
- 8 clean:
- 9 make -C $(KERN_DIR) M=`pwd` clean
复制代码
第3行,设置obj-m变量的值为semaphore.o。
修改完成保存退出,输入如下命令编译出驱动模块文件:
make
编译成功以后就会生成一个名为“semaphore.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试semaApp.c这个测试程序:
- arm-linux-gnueabihf-gcc semaphoreApp.c -o semaphoreApp
复制代码
编译成功以后就会生成semaphoreApp这个应用程序。
3、运行测试
将上一小节编译出来的semaphore.ko和semaphoreApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载semaphore.ko驱动模块:
- depmod //第一次加载驱动的时候需要运行此命令
- modprobe semaphore.ko //加载驱动
复制代码
驱动加载成功以后就可以使用semaphoreApp软件测试驱动是否工作正常,测试方法和41.1.2小节中一样,先输入如下命令让semaphoreApp软件模拟占用25S的LED灯:
- ./semaphoreApp /dev/gpioled 0 & //关闭LED灯
复制代码
紧接着再输入如下命令打开LED灯:
- ./semaphoreApp /dev/gpioled 1 & //打开LED灯
复制代码
注意两个命令都是运行在后台,第一条命令先获取到信号量,因此可以操作LED设备,将LED灯打开,并且占有25S。第二条命令因为获取信号量失败而进入休眠状态,等待第一条命令运行完毕并释放信号量以后才拥有LED设备使用权,将LED灯关闭,运行结果如图 41.3.1所示:
图 41.3.1 两条命令运行过程
如果要卸载驱动的话输入如下命令即可:
30.4互斥体实验
前面我们使用原子操作、自旋锁和信号量实现了对LED设备的互斥访问,但是最适合互斥的就是互斥体mutex了。本节我们来学习一下如何使用mutex实现对LED设备的互斥访问。
本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\ZYNQ_7010\3_Embedded_Linux\Linux驱动例程\10_mutex。
30.4.1实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的,同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在上一节实验驱动文件semaphore.c的基础上修改而来。在drivers目录下新建名为“10_mutex”的文件夹,将9_semaphore实验中的semaphore.c复制到10_mutex文件夹中,并且重命名为mutex.c。将原来使用到信号量的地方换为mutex即可,其他的内容基本不变,完成以后的mutex.c文件内容如下所示(有省略):
示例代码30.4.1.1 mutex.c文件代码
- ......
- 29 #define GPIOLED_CNT 1 /* 设备号个数 */
- 30 #define GPIOLED_NAME "gpioled" /* 名字 */
- 31
- 32 /* dtsled设备结构体 */
- 33 struct gpioled_dev {
- 34 dev_t devid; /* 设备号 */
- 35 struct cdev cdev; /* cdev */
- 36 struct class *class; /* 类 */
- 37 struct device *device; /* 设备 */
- 38 int major; /* 主设备号 */
- 39 int minor; /* 次设备号 */
- 40 struct device_node *nd; /* 设备节点 */
- 41 int led_gpio; /* LED所使用的GPIO编号 */
- 42 struct mutex lock; /* 互斥体 */
- 43 };
- 44
- 45 static struct gpioled_dev gpioled; /* led设备 */
- ......
- 54 static int led_open(struct inode *inode, struct file *filp)
- 55 {
- 56 /* 获取互斥体,可以被信号打断 */
- 57 if (mutex_lock_interruptible(&gpioled.lock))
- 58 return -ERESTARTSYS;
- 59
- 60 #if 0
- 61 mutex_lock(&gpioled.lock); /* 不能被信号打断 */
- 62 #endif
- 63
- 64 return 0;
- 65 }
- ......
- 114 static int led_release(struct inode *inode, struct file *filp)
- 115 {
- 116 /* 释放互斥锁 */
- 117 mutex_unlock(&gpioled.lock);
- 118
- 119 return 0;
- 120 }
- ......
- 131 static int __init led_init(void)
- 132 {
- 133 const char *str;
- 134 int ret;
- ......
- 235 /* 初始化互斥体 */
- 236 mutex_init(&gpioled.lock);
- ......
- 252 return ret;
- 253 }
复制代码
第42行,定义互斥体lock。
第54~65行,在open函数中调用mutex_lock_interruptible或者mutex_lock获取mutex,成功的话就表示可以使用LED设备,失败的话就会进入休眠状态,和信号量一样。
第117行,在release函数中调用mutex_unlock函数释放mutex,这样其他应用程序就可以获取mutex了。
第236行,在驱动入口函数中调用mutex_init初始化mutex。
互斥体和二值信号量类似,只不过互斥体是专门用于互斥访问的。
3、编写测试APP
测试APP使用41.1.1小节中的atomicApp.c即可,将7_atomic中的atomicApp.c文件拷贝到本实验目录10_mutex中,并将atomicApp.c重命名为mutexApp.c即可。
30.4.2运行测试
1、编译驱动程序
编写Makefile文件,将上一节实验目录下的Makefile文件拷贝到本实验目录下,打开Makefile文件将obj-m变量的值改为mutex.o,Makefile内容如下所示:
示例代码30.4.2.1 Makefile文件
- 1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
- 2
- 3 obj-m := mutex.o
- 4
- 5 all:
- 6 make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
- 7
- 8 clean:
- 9 make -C $(KERN_DIR) M=`pwd` clean
复制代码
第3行,设置obj-m变量的值为mutex.o。
Makefile修改完成之后保存退出,输入如下命令编译出驱动模块文件:
编译成功以后就会生成一个名为“mutex.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试mutexApp.c这个测试程序:
- arm-linux-gnueabihf-gcc mutexApp.c -o mutexApp
复制代码
编译成功以后就会生成mutexApp这个应用程序。
3、运行测试
将上一小节编译出来的mutex.ko和mutexApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载mutex.ko驱动模块:
- depmod //第一次加载驱动的时候需要运行此命令
- modprobe mutex.ko //加载驱动
复制代码
驱动加载成功以后就可以使用mutexApp软件测试驱动是否工作正常,测试方法和41.3.2中测试信号量的方法一样,这里不说了!
如果要卸载驱动的话输入如下命令即可:
|
阿莫论坛20周年了!感谢大家的支持与爱护!!
你熬了10碗粥,别人一桶水倒进去,淘走90碗,剩下10碗给你,你看似没亏,其实你那10碗已经没有之前的裹腹了,人家的一桶水换90碗,继续卖。说白了,通货膨胀就是,你的钱是挣来的,他的钱是印来的,掺和在一起,你的钱就贬值了。
|