- 1软考中级网络工程师笔记（二）_设信道带宽为4000hz,采用pcm编码,采样周期为125μs,每个样本量化为128个等级,
- 2迄今为止程序员写过的最大Bug：亏损30亿、致6人死亡，甚至差点毁灭世界
- 3人工智能&统计&大数据带动数据时代_大数据与人工智能时代的统计研究
- 4清华大学团队：人脸识别爆出巨大丑闻，15分钟解锁19款手机_清华大学 人脸识别 外国手机是哪款
- 5HIFUSE：用于医学图像分类的分层多尺度特征融合网络
- 6免费ChatGDT插件《 WeTab 新标签页》_wetab-免费chatgpt新标签页
- 7在矩池云使用ChatGLM-6B & ChatGLM2-6B_glm2-6b web_demo 没反应
- 8Kafka入门到实战-第五弹
- 9FATE —— 二.4.3 使用冻结参数Bert进行情绪分类_fate_llm.model_zoo.bert_
- 10KY145 EXCEL排序（用Java实现）
【正点原子Linux连载】 第十二章 Linux并发与竞争实验 摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南
赞
踩
1）实验平台：正点原子ATK-DLRK3568开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=731866264428
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/docs/boards/xiaoxitongban
第十二章 Linux并发与竞争实验
在上一章中我们学习了Linux下的并发与竞争，并且学习了四种常用的处理并发和竞争的机制：原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。
12.1 原子操作实验
本实验对应的例程路径为：开发板光盘 01、程序源码 06、Linux驱动例程源码 06_atomic。
本例程我们在第十章的gpioled.c文件基础上完成。在本节我们使用原子操作来实现对LED这个设备的互斥访问，也就是一次只允许一个应用程序可以使用LED灯。
12.1.1 实验程序编写
1、修改设备树文件
因为本章实验是在第十章实验的基础上完成的，因此不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第十章实验驱动文件gpioled.c的基础上修改而来。新建名为“06_atomic”的文件夹，然后在06_atomic文件夹里面创建vscode工程，工作区命名为“atomic”。将5_gpioled实验中的gpioled.c复制到06_atomic文件夹中，并且重命名为atomic.c。本节实验重点就是使用atomic来实现一次只能允许一个应用访问LED，所以我们只需要在atomic.c文件源码的基础上加上添加atomic相关代码即可，完成以后的atomic.c文件内容如下所示：
示例代码12.1.1.1 atomic.c文件代码段
1 #include <linux/types.h> 2 #include <linux/kernel.h> 3 #include <linux/delay.h> 4 #include <linux/ide.h> 5 #include <linux/init.h> 6 #include <linux/module.h> 7 #include <linux/errno.h> 8 #include <linux/gpio.h> 9 #include <linux/cdev.h> 10 #include <linux/device.h> 11 #include <linux/of.h> 12 #include <linux/of_address.h> 13 #include <linux/of_gpio.h> 14 #include <asm/mach/map.h> 15 #include <asm/uaccess.h> 16 #include <asm/io.h> 17 /*************************************************************** 18 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 19 文件名 : atomic.c 20 作者 : 正点原子Linux团队 21 版本 : V1.0 22 描述 : 原子操作实验，使用原子变量来实现对实现设备的互斥访问。 23 其他 : 无 24 论坛 : www.openedv.com 25 日志 : 初版V1.0 2022/12/08 正点原子Linux团队创建 26 ***************************************************************/ 27 #define GPIOLED_CNT 1 /* 设备号个数 */ 28 #define GPIOLED_NAME "gpioled" /* 名字 */ 29 #define LEDOFF 0 /* 关灯 */ 30 #define LEDON 1 /* 开灯 */ 31 32 /* gpioled设备结构体 */ 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 atomic_t lock; /* 原子变量 */ 43 }; 44 45 static struct gpioled_dev gpioled; /* led设备 */ 46 47 48 /* 49 * @description : 打开设备 50 * @param – inode : 传递给驱动的inode 51 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量 52 * 一般在open的时候将private_data指向设备结构体。 53 * @return : 0 成功;其他 失败 54 */ 55 static int led_open(struct inode *inode, struct file *filp) 56 { 57 /* 通过判断原子变量的值来检查LED有没有被别的应用使用 */ 58 if (!atomic_dec_and_test(&gpioled.lock)) { 59 atomic_inc(&gpioled.lock);/* 小于0的话就加1,使其原子变量等于0 */ 60 return -EBUSY; /* LED被使用，返回忙 */ 61 } 62 63 filp->private_data = &gpioled; /* 设置私有数据 */ 64 return 0; 65 } 66 67 /* 68 * @description : 从设备读取数据 69 * @param - filp : 要打开的设备文件(文件描述符) 70 * @param - buf : 返回给用户空间的数据缓冲区 71 * @param - cnt : 要读取的数据长度 72 * @param - offt : 相对于文件首地址的偏移 73 * @return : 读取的字节数，如果为负值，表示读取失败 74 */ 75 static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 76 { 77 return 0; 78 } 79 80 /* 81 * @description : 向设备写数据 82 * @param - filp : 设备文件，表示打开的文件描述符 83 * @param - buf : 要写给设备写入的数据 84 * @param - cnt : 要写入的数据长度 85 * @param - offt : 相对于文件首地址的偏移 86 * @return : 写入的字节数，如果为负值，表示写入失败 87 */ 88 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 89 { 90 int retvalue; 91 unsigned char databuf[1]; 92 unsigned char ledstat; 93 struct gpioled_dev *dev = filp->private_data; 94 95 retvalue = copy_from_user(databuf, buf, cnt); 96 if(retvalue < 0) { 97 printk("kernel write failed!\r\n"); 98 return -EFAULT; 99 } 100 101 ledstat = databuf[0]; /* 获取状态值 */ 102 103 if(ledstat == LEDON) { 104 gpio_set_value(dev->led_gpio, 1); /* 打开LED灯 */ 105 } else if(ledstat == LEDOFF) { 106 gpio_set_value(dev->led_gpio, 0); /* 关闭LED灯 */ 107 } 108 return 0; 109 } 110 111 /* 112 * @description : 关闭/释放设备 113 * @param - filp : 要关闭的设备文件(文件描述符) 114 * @return : 0 成功;其他 失败 115 */ 116 static int led_release(struct inode *inode, struct file *filp) 117 { 118 struct gpioled_dev *dev = filp->private_data; 119 120 /* 关闭驱动文件的时候释放原子变量 */ 121 atomic_inc(&dev->lock); 122 123 return 0; 124 } 125 126 /* 设备操作函数 */ 127 static struct file_operations gpioled_fops = { 128 .owner = THIS_MODULE, 129 .open = led_open, 130 .read = led_read, 131 .write = led_write, 132 .release = led_release, 133 }; 134 135 /* 136 * @description : 驱动出口函数 137 * @param : 无 138 * @return : 无 139 */ 140 static int __init led_init(void) 141 { 142 int ret = 0; 143 const char *str; 144 145 /* 1、初始化原子变量 */ 146 gpioled.lock = (atomic_t)ATOMIC_INIT(0); 147 148 /* 2、原子变量初始值为1 */ 149 atomic_set(&gpioled.lock, 1); 150 151 /* 设置LED所使用的GPIO */ 152 /* 1、获取设备节点：gpioled */ 153 gpioled.nd = of_find_node_by_path("/gpioled"); 154 if(gpioled.nd == NULL) { 155 printk("gpioled node not find!\r\n"); 156 return -EINVAL; 157 } 158 159 /* 2.读取status属性 */ 160 ret = of_property_read_string(gpioled.nd, "status", &str); 161 if(ret < 0) 162 return -EINVAL; 163 164 if (strcmp(str, "okay")) 165 return -EINVAL; 166 167 /* 3、获取compatible属性值并进行匹配 */ 168 ret = of_property_read_string(gpioled.nd, "compatible", &str); 169 if(ret < 0) { 170 printk("gpioled: Failed to get compatible property\n"); 171 return -EINVAL; 172 } 173 174 if (strcmp(str, "alientek,led")) { 175 printk("gpioled: Compatible match failed\n"); 176 return -EINVAL; 177 } 178 179 /* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */ 180 gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0); 181 if(gpioled.led_gpio < 0) { 182 printk("can't get led-gpio"); 183 return -EINVAL; 184 } 185 printk("led-gpio num = %d\r\n", gpioled.led_gpio); 186 187 /* 5.向gpio子系统申请使用GPIO */ 188 ret = gpio_request(gpioled.led_gpio, "LED-GPIO"); 189 if (ret) { 190 printk(KERN_ERR "gpioled: Failed to request led-gpio\n"); 191 return ret; 192 } 193 194 /* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */ 195 ret = gpio_direction_output(gpioled.led_gpio, 1); 196 if(ret < 0) { 197 printk("can't set gpio!\r\n"); 198 } 199 200 /* 注册字符设备驱动 */ 201 /* 1、创建设备号 */ 202 if (gpioled.major) { /* 定义了设备号 */ 203 gpioled.devid = MKDEV(gpioled.major, 0); 204 ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME); 205 if(ret < 0) { 206 pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT); 207 goto free_gpio; 208 } 209 } else { /* 没有定义设备号 */ 210 ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */ 211 if(ret < 0) { 212 pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret); 213 goto free_gpio; 214 } 215 gpioled.major = MAJOR(gpioled.devid); /* 获取分配号的主设备号 */ 216 gpioled.minor = MINOR(gpioled.devid); /* 获取分配号的次设备号 */ 217 } 218 printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor); 219 220 /* 2、初始化cdev */ 221 gpioled.cdev.owner = THIS_MODULE; 222 cdev_init(&gpioled.cdev, &gpioled_fops); 223 224 /* 3、添加一个cdev */ 225 cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT); 226 if(ret < 0) 227 goto del_unregister; 228 229 /* 4、创建类 */ 230 gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME); 231 if (IS_ERR(gpioled.class)) { 232 goto del_cdev; 233 } 234 235 /* 5、创建设备 */ 236 gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME); 237 if (IS_ERR(gpioled.device)) { 238 goto destroy_class; 239 } 240 return 0; 241 242 destroy_class: 243 device_destroy(gpioled.class, gpioled.devid); 244 del_cdev: 245 cdev_del(&gpioled.cdev); 246 del_unregister: 247 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); 248 free_gpio: 249 gpio_free(gpioled.led_gpio); 250 return -EIO; 251 } 252 253 /* 254 * @description : 驱动出口函数 255 * @param : 无 256 * @return : 无 257 */ 258 static void __exit led_exit(void) 259 { 260 /* 注销字符设备驱动 */ 261 cdev_del(&gpioled.cdev);/* 删除cdev */ 262 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); 263 device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */ 264 class_destroy(gpioled.class);/* 注销类 */ 265 gpio_free(gpioled.led_gpio); /* 释放GPIO */ 266 } 267 268 module_init(led_init); 269 module_exit(led_exit); 270 MODULE_LICENSE("GPL"); 271 MODULE_AUTHOR("ALIENTEK"); 272 MODULE_INFO(intree, "Y");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
第42行，原子变量lock，用来实现一次只能允许一个应用访问LED灯，led_init驱动入口函数会将lock的值设置为1。
第57~61行，每次调用open函数打开驱动设备的时候先申请lock，如果申请成功的话就表示LED灯还没有被其他的应用使用，如果申请失败就表示LED灯正在被其他的应用程序使用。每次打开驱动设备的时候先使用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。
第121行，LED灯使用完毕，应用程序调用close函数关闭的驱动文件，led_release函数执行，调用atomic_inc释放lcok，也就是将lock加1。
第146行，初始化原子变量lock，初始值设置为0。
第149行，原子变量lock设置为1，这样每次就只允许一个应用使用LED灯。
3、编写测试APP
示例代码12.1.1.2 atomicApp.c文件代码
1 #include "stdio.h" 2 #include "unistd.h" 3 #include "sys/types.h" 4 #include "sys/stat.h" 5 #include "fcntl.h" 6 #include "stdlib.h" 7 #include "string.h" 8 /*************************************************************** 9 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 10 文件名 : atomicApp.c 11 作者 : 正点原子Linux团队 12 版本 : V1.0 13 描述 : 原子变量测试APP，测试原子变量能不能实现一次 14 只允许一个应用程序使用LED。 15 其他 : 无 16 使用方法 ：./atomicApp /dev/gpioled 0 关闭LED灯 17 ./atomicApp /dev/gpioled 1 打开LED灯 18 论坛 : www.openedv.com 19 日志 : 初版V1.0 2022/12/08 正点原子Linux团队创建 20 ***************************************************************/ 21 22 #define LEDOFF 0 23 #define LEDON 1 24 25 /* 26 * @description : main主程序 27 * @param - argc : argv数组元素个数 28 * @param - argv : 具体参数 29 * @return : 0 成功;其他 失败 30 */ 31 int main(int argc, char *argv[]) 32 { 33 int fd, retvalue; 34 char *filename; 35 unsigned char cnt = 0; 36 unsigned char databuf[1]; 37 38 if(argc != 3){ 39 printf("Error Usage!\r\n"); 40 return -1; 41 } 42 43 filename = argv[1]; 44 45 /* 打开led驱动 */ 46 fd = open(filename, O_RDWR); 47 if(fd < 0){ 48 printf("file %s open failed!\r\n", argv[1]); 49 return -1; 50 } 51 52 databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */ 53 54 /* 向/dev/gpioled文件写入数据 */ 55 retvalue = write(fd, databuf, sizeof(databuf)); 56 if(retvalue < 0){ 57 printf("LED Control Failed!\r\n"); 58 close(fd); 59 return -1; 60 } 61 62 /* 模拟占用25S LED */ 63 while(1) { 64 sleep(5); 65 cnt++; 66 printf("App running times:%d\r\n", cnt); 67 if(cnt >= 5) break; 68 } 69 70 printf("App running finished!"); 71 retvalue = close(fd); /* 关闭文件 */ 72 if(retvalue < 0){ 73 printf("file %s close failed!\r\n", argv[1]); 74 return -1; 75 } 76 return 0; 77 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
12.1.2 运行测试
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为atomic.o，Makefile内容如下所示：
示例代码12.1.2.1 Makefile文件
1 KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
......
4 obj-m := atomic.o
......
11 clean:
12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
- 1
- 2
- 3
- 4
- 5
- 6
第4行，设置obj-m变量的值为atomic.o。
输入如下命令编译出驱动模块文件：
make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“atomic.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试atomicApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc atomicApp.c -o atomicApp
编译成功以后就会生成ledApp这个应用程序。
3、运行测试
在Ubuntu中将上一小节编译出来的atomic.ko和atomicApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push atomic.ko atomicApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载atomic.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe atomic //加载驱动
- 1
- 2
驱动加载成功以后就可以使用atomicApp软件来测试驱动是否工作正常，输入如下命令以后台运行模式打开LED灯，“&”表示在后台运行atomicApp这个软件：
./atomicApp /dev/gpioled 1 & //打开LED灯
输入上述命令以后观察开发板上的绿色LED灯是否点亮，然后每隔5秒都会输出一行“App running times ”，如图12.1.2.1所示：
图12.1.2.1 打开LED灯
从图12.1.2.1可以看出，atomicApp运行正常，输出了“App running times:1”和“App running times:2”等字符串，这就是模拟25S占用，说明atomicApp这个软件正在使用LED灯。此时再输入如下命令关闭LED灯：
./atomicApp /dev/gpioled 0 //关闭LED灯
输入上述命令以后会发现如图12.1.2.2所示输入信息：
图12.1.2.2 关闭LED灯
从图12.1.2.2可以看出，打开/dev/gpioled失败！原因是在图12.1.2.1中运行的atomicAPP软件正在占用/dev/gpioled，如果再次运行atomicApp软件去操作/dev/gpioled肯定会失败。必须等待图12.1.2.1中的atomicApp运行结束，也就是25S结束以后其他软件才能去操作/dev/gpioled。这个就是采用原子变量实现一次只能有一个应用程序访问LED灯。
如果要卸载驱动的话输入如下命令即可：
rmmod atomic.ko
12.2 自旋锁实验
本实验对应的例程路径为：开发板光盘 01、程序源码 Linux驱动例程源码07_spinlock。
上一节我们使用原子变量实现了一次只能有一个应用程序访问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来做保护。
12.2.1 实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的，同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第上一节实验驱动文件atomic.c的基础上修改而来。新建名为“07_spinlock”的文件夹，然后在07_spinlock文件夹里面创建vscode工程，工作区命名为“spinlock”。将7_atomic实验中的atomic.c复制到07_spinlock文件夹中，并且重命名为spinlock.c。将原来使用atomic的地方换为spinlock即可，其他代码不需要修改，完成以后的spinlock.c文件内容如下所示(有省略)：
示例代码12.2.1.1 spinlock.c文件代码
1 #include <linux/types.h> 2 #include <linux/kernel.h> 3 #include <linux/delay.h> ... 17 /*************************************************************** 18 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 19 文件名 : spinlock.c 20 作者 : 正点原子Linux团队 21 版本 : V1.0 22 描述 : 自旋锁实验，使用自旋锁来实现对实现设备的互斥访问。 23 其他 : 无 24 论坛 : www.openedv.com 25 日志 : 初版V1.0 2022/12/08 正点原子Linux团队创建 26 ***************************************************************/ 27 #define GPIOLED_CNT 1 /* 设备号个数 */ 28 #define GPIOLED_NAME "gpioled" /* 名字 */ 29 #define LEDOFF 0 /* 关灯 */ 30 #define LEDON 1 /* 开灯 */ 31 32 /* gpioled设备结构体 */ 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 int dev_stats; /* 设备使用状态，0，设备未使用;>0,设备已经被使用 */ 43 spinlock_t lock; /* 自旋锁 */ 44 }; 45 46 static struct gpioled_dev gpioled; /* led设备 */ 47 48 49 /* 50 * @description : 打开设备 51 * @param – inode : 传递给驱动的inode 52 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量 53 * 一般在open的时候将private_data指向设备结构体。 54 * @return : 0 成功;其他 失败 55 */ 56 static int led_open(struct inode *inode, struct file *filp) 57 { 58 unsigned long flags; 59 filp->private_data = &gpioled; /* 设置私有数据 */ 60 61 spin_lock_irqsave(&gpioled.lock, flags); /* 上锁 */ 62 if (gpioled.dev_stats) { /* 如果设备被使用了 */ 63 spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */ 64 return -EBUSY; 65 } 66 gpioled.dev_stats++; /* 如果设备没有打开，那么就标记已经打开了 */ 67 spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */ 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 static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 81 { 82 return 0; 83 } 84 85 /* 86 * @description : 向设备写数据 87 * @param - filp : 设备文件，表示打开的文件描述符 88 * @param - buf : 要写给设备写入的数据 89 * @param - cnt : 要写入的数据长度 90 * @param - offt : 相对于文件首地址的偏移 91 * @return : 写入的字节数，如果为负值，表示写入失败 92 */ 93 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 94 { 95 int retvalue; 96 unsigned char databuf[1]; 97 unsigned char ledstat; 98 struct gpioled_dev *dev = filp->private_data; 99 100 retvalue = copy_from_user(databuf, buf, cnt); 101 if(retvalue < 0) { 102 printk("kernel write failed!\r\n"); 103 return -EFAULT; 104 } 105 106 ledstat = databuf[0]; /* 获取状态值 */ 107 108 if(ledstat == LEDON) { 109 gpio_set_value(dev->led_gpio, 1); /* 打开LED灯 */ 110 } else if(ledstat == LEDOFF) { 111 gpio_set_value(dev->led_gpio, 0); /* 关闭LED灯 */ 112 } 113 return 0; 114 } 115 116 /* 117 * @description : 关闭/释放设备 118 * @param – filp : 要关闭的设备文件(文件描述符) 119 * @return : 0 成功;其他 失败 120 */ 121 static int led_release(struct inode *inode, struct file *filp) 122 { 123 unsigned long flags; 124 struct gpioled_dev *dev = filp->private_data; 125 126 /* 关闭驱动文件的时候将dev_stats减1 */ 127 spin_lock_irqsave(&dev->lock, flags); /* 上锁 */ 128 if (dev->dev_stats) { 129 dev->dev_stats--; 130 } 131 spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */ 132 133 return 0; 134 } 135 136 /* 设备操作函数 */ 137 static struct file_operations gpioled_fops = { 138 .owner = THIS_MODULE, 139 .open = led_open, 140 .read = led_read, 141 .write = led_write, 142 .release = led_release, 143 }; 144 145 /* 146 * @description : 驱动出口函数 147 * @param : 无 148 * @return : 无 149 */ 150 static int __init led_init(void) 151 { 152 int ret = 0; 153 const char *str; 154 155 /* 初始化自旋锁 */ 156 spin_lock_init(&gpioled.lock); 157 158 /* 设置LED所使用的GPIO */ 159 /* 1、获取设备节点：gpioled */ 160 gpioled.nd = of_find_node_by_path("/gpioled"); 161 if(gpioled.nd == NULL) { 162 printk("gpioled node not find!\r\n"); 163 return -EINVAL; 164 } 165 166 /* 2.读取status属性 */ 167 ret = of_property_read_string(gpioled.nd, "status", &str); 168 if(ret < 0) 169 return -EINVAL; 170 171 if (strcmp(str, "okay")) 172 return -EINVAL; 173 174 /* 3、获取compatible属性值并进行匹配 */ 175 ret = of_property_read_string(gpioled.nd, "compatible", &str); 176 if(ret < 0) { 177 printk("gpioled: Failed to get compatible property\n"); 178 return -EINVAL; 179 } 180 181 if (strcmp(str, "alientek,led")) { 182 printk("gpioled: Compatible match failed\n"); 183 return -EINVAL; 184 } 185 186 /* 4、 获取设备树中的gpio属性，得到LED所使用的LED编号 */ 187 gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0); 188 if(gpioled.led_gpio < 0) { 189 printk("can't get led-gpio"); 190 return -EINVAL; 191 } 192 printk("led-gpio num = %d\r\n", gpioled.led_gpio); 193 194 /* 5.向gpio子系统申请使用GPIO */ 195 ret = gpio_request(gpioled.led_gpio, "LED-GPIO"); 196 if (ret) { 197 printk(KERN_ERR "gpioled: Failed to request led-gpio\n"); 198 return ret; 199 } 200 201 /* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */ 202 ret = gpio_direction_output(gpioled.led_gpio, 1); 203 if(ret < 0) { 204 printk("can't set gpio!\r\n"); 205 } 206 207 /* 注册字符设备驱动 */ 208 /* 1、创建设备号 */ 209 if (gpioled.major) { /* 定义了设备号 */ 210 gpioled.devid = MKDEV(gpioled.major, 0); 211 ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME); 212 if(ret < 0) { 213 pr_err("cannot register %s char driver [ret=%d]\n", GPIOLED_NAME, GPIOLED_CNT); 214 goto free_gpio; 215 } 216 } else { /* 没有定义设备号 */ 217 ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); /* 申请设备号 */ 218 if(ret < 0) { 219 pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", GPIOLED_NAME, ret); 220 goto free_gpio; 221 } 222 gpioled.major = MAJOR(gpioled.devid);/* 获取分配号的主设备号 */ 223 gpioled.minor = MINOR(gpioled.devid);/* 获取分配号的次设备号 */ 224 } 225 printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor); 226 227 /* 2、初始化cdev */ 228 gpioled.cdev.owner = THIS_MODULE; 229 cdev_init(&gpioled.cdev, &gpioled_fops); 230 231 /* 3、添加一个cdev */ 232 cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT); 233 if(ret < 0) 234 goto del_unregister; 235 236 /* 4、创建类 */ 237 gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME); 238 if (IS_ERR(gpioled.class)) { 239 goto del_cdev; 240 } 241 242 /* 5、创建设备 */ 243 gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME); 244 if (IS_ERR(gpioled.device)) { 245 goto destroy_class; 246 } 247 return 0; 248 249 destroy_class: 250 device_destroy(gpioled.class, gpioled.devid); 251 del_cdev: 252 cdev_del(&gpioled.cdev); 253 del_unregister: 254 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); 255 free_gpio: 256 gpio_free(gpioled.led_gpio); 257 return -EIO; 258 } 259 260 /* 261 * @description : 驱动出口函数 262 * @param : 无 263 * @return : 无 264 */ 265 static void __exit led_exit(void) 266 { 267 /* 注销字符设备驱动 */ 268 cdev_del(&gpioled.cdev);/* 删除cdev */ 269 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); 270 device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */ 271 class_destroy(gpioled.class); /* 注销类 */ 272 gpio_free(gpioled.led_gpio); /* 释放GPIO */ 273 } 274 275 module_init(led_init); 276 module_exit(led_exit); 277 MODULE_LICENSE("GPL"); 278 MODULE_AUTHOR("ALIENTEK"); 279 MODULE_INFO(intree, "Y");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
第42行，dev_stats表示设备状态，如果为0的话表示设备还没有被使用，如果大于0的话就表示设备已经被使用了。
第43行，定义自旋锁变量lock。
第61~67行，使用自旋锁实现对设备的互斥访问，第61行调用spin_lock_irqsave函数获取锁，为了考虑到驱动兼容性，这里并没有使用spin_lock函数来获取锁。第62行判断dev_stats是否大于0，如果是的话表示设备已经被使用了，那么就调用spin_unlock_irqrestore函数释放锁，并且返回-EBUSY。如果设备没有被使用的话就在第66行将dev_stats加1，表示设备要被使用了，然后调用spin_unlock_irqrestore函数释放锁。自旋锁的工作就是保护dev_stats变量，真正实现对设备互斥访问的是dev_stats。
第127~131行，在release函数中将dev_stats减1，表示设备被释放了，可以被其他的应用程序使用。将dev_stats减1的时候需要自旋锁对其进行保护。
第156行，在驱动入口函数led_init中调用spin_lock_init函数初始化自旋锁。
3、编写测试APP
测试APP使用12.1.1小节中的atomicApp.c即可，将06_atomic中的atomicApp.c文件拷贝到本例程中，并将atomicApp.c重命名为spinlockApp.c即可。
12.2.2 运行测试
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为spinlock.o，Makefile内容如下所示：
示例代码12.2.2.1 Makefile文件
1 KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
......
4 obj-m := spinlock.o
......
11 clean:
12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
- 1
- 2
- 3
- 4
- 5
- 6
第4行，设置obj-m变量的值为spinlock.o。
输入如下命令编译出驱动模块文件：
make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“spinlock.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试spinlockApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc spinlockApp.c -o spinlockApp
编译成功以后就会生成spinlockApp这个应用程序。
3、运行测试
在Ubuntu中将上一小节编译出来的spinlock.ko和spinlockApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push spinlock.ko spinlockApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载atomic.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe spinlock //加载驱动
驱动加载成功以后就可以使用spinlockApp软件测试驱动是否工作正常，测试方法和12.1.2小节中一样，先输入如下命令让spinlockAPP软件模拟占用25S的LED灯：
./spinlockApp /dev/gpioled 1& //打开LED灯
紧接着再输入如下命令关闭LED灯：
./spinlockApp /dev/gpioled 0 //关闭LED灯
看一下能不能关闭LED灯，驱动正常工作的话并不会马上关闭LED灯，会提示你“file /dev/gpioled open failed!”，必须等待第一个spinlockApp软件运行完成(25S计时结束)才可以再次操作LED灯。
如果要卸载驱动的话输入如下命令即可：
rmmod spinlock.ko
12.3 信号量实验
本节我们使用信号量来实现一次只能有一个应用程序访问LED灯，信号量可以导致休眠，因此信号量保护的临界区没有运行时间限制，可以在驱动的open函数申请信号量，然后在release函数中释放信号量。但是信号量不能用在中断中，本节实验我们不会在中断中使用信号量。
12.3.1 实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的，同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第上一节实验驱动文件spinlock.c的基础上修改而来。新建名为“08_semaphore”的文件夹，然后在08_semaphore文件夹里面创建vscode工程，工作区命名为“semaphore”。将07_spinlock实验中的spinlock.c复制到08_semaphore文件夹中，并且重命名为semaphore.c。将原来使用到自旋锁的地方换为信号量即可，其他的内容基本不变，完成以后的semaphore.c文件内容如下所示(有省略)：
示例代码12.3.1.1 semaphore.c文件代码
1 #include <linux/types.h> ...... 14 #include <linux/semaphore.h> 15 #include <asm/mach/map.h> 16 #include <asm/uaccess.h> 17 #include <asm/io.h> 18 /*************************************************************** 19 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 20 文件名 : semaphore.c 21 作者 : 正点原子Linux团队 22 版本 : V1.0 23 描述 : 信号量实验，使用信号量来实现对实现设备的互斥访问。 24 其他 : 无 25 论坛 : www.openedv.com 26 日志 : 初版V1.0 2022/12/08 正点原子Linux团队创建 27 ***************************************************************/ 28 #define GPIOLED_CNT 1 /* 设备号个数 */ 29 #define GPIOLED_NAME "gpioled" /* 名字 */ 30 #define LEDOFF 0 /* 关灯 */ 31 #define LEDON 1 /* 开灯 */ 32 33 /* gpioled设备结构体 */ 34 struct gpioled_dev{ 35 dev_t devid; /* 设备号 */ 36 struct cdev cdev; /* cdev */ 37 struct class *class; /* 类 */ 38 struct device *device; /* 设备 */ 39 int major; /* 主设备号 */ 40 int minor; /* 次设备号 */ 41 struct device_node *nd; /* 设备节点 */ 42 int led_gpio; /* led所使用的GPIO编号 */ 43 struct semaphore sem; /* 信号量 */ 44 }; 45 46 static struct gpioled_dev gpioled; /* led设备 */ 47 48 49 /* 50 * @description : 打开设备 51 * @param - inode : 传递给驱动的inode 52 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变 53 * 量一般在open的时候将private_data指向设备结构体。 54 * @return : 0 成功;其他 失败 55 */ 56 static int led_open(struct inode *inode, struct file *filp) 57 { 58 filp->private_data = &gpioled; /* 设置私有数据 */ 59 60 /* 获取信号量 */ 61 if (down_interruptible(&gpioled.sem)) { 62 return -ERESTARTSYS; 63 } 64 #if 0 65 down(&gpioled.sem); /* 不能被信号打断 */ 66 #endif 67 68 return 0; 69 } ...... 120 static int led_release(struct inode *inode, struct file *filp) 121 { 122 struct gpioled_dev *dev = filp->private_data; 123 124 up(&dev->sem); /* 释放信号量，信号量count值加1 */ 125 return 0; 126 } 127 128 /* 设备操作函数 */ 129 static struct file_operations gpioled_fops = { 130 .owner = THIS_MODULE, 131 .open = led_open, 132 .read = led_read, 133 .write = led_write, 134 .release = led_release, 135 }; 136 137 /* 138 * @description : 驱动出口函数 139 * @param : 无 140 * @return : 无 141 */ 142 static int __init led_init(void) 143 { 144 int ret = 0; 145 const char *str; 146 147 /* 初始化信号量 */ 148 sema_init(&gpioled.sem, 1); ...... 250 } 251 252 /* 253 * @description : 驱动出口函数 254 * @param : 无 255 * @return : 无 256 */ 257 static void __exit led_exit(void) 258 { 259 /* 注销字符设备驱动 */ 260 cdev_del(&gpioled.cdev);/* 删除cdev */ 261 unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); 262 device_destroy(gpioled.class, gpioled.devid);/* 注销设备 */ 263 class_destroy(gpioled.class);/* 注销类 */ 264 gpio_free(gpioled.led_gpio); /* 释放GPIO */ 265 } 266 267 module_init(led_init); 268 module_exit(led_exit); 269 MODULE_LICENSE("GPL"); 270 MODULE_AUTHOR("ALIENTEK"); 271 MODULE_INFO(intree, "Y");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
第14行，要使用信号量必须添加<linux/semaphore.h>头文件。
第43行，在设备结构体中添加一个信号量成员变量sem。
第60~66行，在open函数中申请信号量，可以使用down函数，也可以使用down_interruptible函数。如果信号量值大于等于1就表示可用，那么应用程序就会开始使用LED灯。如果信号量值为0就表示应用程序不能使用LED灯，此时应用程序就会进入到休眠状态。等到信号量值大于1的时候应用程序就会唤醒，申请信号量，获取LED灯使用权。
第124行，在release函数中调用up函数释放信号量，这样其他因为没有得到信号量而进入休眠状态的应用程序就会唤醒，获取信号量。
第148行，在驱动入口函数中调用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使用12.1.1小节中的atomicApp.c即可，将06_atomic中的atomicApp.c文件到本例程中，并将atomicApp.c重命名为semaApp.c即可。
12.3.2 运行测试
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为semaphore.o，Makefile内容如下所示：
示例代码12.1.3.1 Makefile文件
1 KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
......
4 obj-m := semaphore.o
......
11 clean:
12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
- 1
- 2
- 3
- 4
- 5
- 6
第4行，设置obj-m变量的值为semaphore.o。
输入如下命令编译出驱动模块文件：
make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“semaphore.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试semaApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc semaApp.c -o semaApp
编译成功以后就会生成semaApp这个应用程序。
3、运行测试
在Ubuntu中将上一小节编译出来的semaphore.ko和semaApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push semaphore.ko semaApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载atomic.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe semaphore //加载驱动
驱动加载成功以后就可以使用semaApp软件测试驱动是否工作正常，测试方法和12.1.2小节中一样，先输入如下命令让semaApp软件模拟占用25S的LED灯：
./semaApp /dev/gpioled 1 & //打开LED灯
紧接着再输入如下命令关闭LED灯：
./semaApp /dev/gpioled 0 & //关闭LED灯
注意两个命令都是运行在后台，第一条命令先获取到信号量，因此可以操作LED灯，将LED灯打开，并且占有25S。第二条命令因为获取信号量失败而进入休眠状态，等待第一条命令运行完毕并释放信号量以后才拥有LED灯使用权，将LED灯关闭，运行结果如图12.3.2.1所示：
图12.3.2.1 命令运行过程
如果要卸载驱动的话输入如下命令即可：
rmmod semaphore.ko
12.4 互斥体实验
前面我们使用原子操作、自旋锁和信号量实现了对LED灯的互斥访问，但是最适合互斥的就是互斥体mutex了。本节我们来学习一下如何使用mutex实现对LED灯的互斥访问。
12.4.1 实验程序编写
1、修改设备树文件
本章实验是在上一节实验的基础上完成的，同样不需要对设备树做任何的修改。
2、LED驱动修改
本节实验在第上一节实验驱动文件semaphore.c的基础上修改而来。新建名为“10_mutex”的文件夹，然后在10_mutex文件夹里面创建vscode工程，工作区命名为“mutex”。将9_semaphore实验中的semaphore.c复制到10_mutex文件夹中，并且重命名为mutex.c。将原来使用到信号量的地方换为mutex即可，其他的内容基本不变，完成以后的mutex.c文件内容如下所示(有省略)：
示例代码12.4.1.1 mutex.c文件代码
第43行，定义互斥体lock。
第60~66行，在open函数中调用mutex_lock_interruptible或者mutex_lock获取mutex，成功的话就表示可以使用LED灯，失败的话就会进入休眠状态，和信号量一样。
第125行，在release函数中调用mutex_unlock函数释放mutex，这样其他应用程序就可以获取mutex了。
第149行，在驱动入口函数中调用mutex_init初始化mutex。
互斥体和二值信号量类似，只不过互斥体是专门用于互斥访问的。
3、编写测试APP
测试APP使用12.1.1小节中的atomicApp.c即可，将06_atomic中的atomicApp.c文件到本例程中，并将atomicApp.c重命名为mutexApp.c即可。
12.4.2 运行测试
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为mutex.o，Makefile内容如下所示：
示例代码12.4.2.1 Makefile文件
1 KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
…
4 obj-m := mutex.o
…
11 clean:
12 $(MAKE) -C
(
K
E
R
N
E
L
D
I
R
)
M
=
(KERNELDIR) M=
(KERNELDIR)M=(CURRENT_PATH) clean
第4行，设置obj-m变量的值为mutex.o。
输入如下命令编译出驱动模块文件：
make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“mutex.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试mutexApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc mutexApp.c -o mutexApp
编译成功以后就会生成mutexApp这个应用程序。
3、运行测试
在Ubuntu中将上一小节编译出来的mutex.ko和mutexApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push mutex.ko mutexApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载mutex.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe mutex //加载驱动
驱动加载成功以后就可以使用mutexApp软件测试驱动是否工作正常，测试方法和12.3.2中测试信号量的方法一样。
如果要卸载驱动的话输入如下命令即可：
rmmod mutex.ko
