【正点原子Linux连载】第五十三章 异步通知实验 -摘自【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.0

1）实验平台：正点原子阿尔法Linux开发板
2）平台购买地址：https://item.taobao.com/item.htm?id=603672744434
2）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-300792-1-1.html
3）对正点原子Linux感兴趣的同学可以加群讨论：935446741
4）关注正点原子公众号，获取最新资料更新

第五十三章 异步通知实验

在前面使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的，对于非阻塞方式来说还需要应用程序通过poll函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，然后应用程序在从驱动程序中读取或写入数据，类似于我们在裸机例程中讲解的中断。Linux提供了异步通知这个机制来完成此功能，本章我们就来学习一下异步通知以及如何在驱动中添加异步通知相关处理代码。

53.1 异步通知
53.1.1 异步通知简介
我们首先来回顾一下“中断”，中断是处理器提供的一种异步机制，我们配置好中断以后就可以让处理器去处理其他的事情了，当中断发生以后会触发我们事先设置好的中断服务函数，在中断服务函数中做具体的处理。比如我们在裸机篇里面编写的GPIO按键中断实验，我们通过按键去开关蜂鸣器，采用中断以后处理器就不需要时刻的去查看按键有没有被按下，因为按键按下以后会自动触发中断。同样的，Linux应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备，通过阻塞方式访问的话应用程序会处于休眠态，等待驱动设备可以使用，非阻塞方式的话会通过poll函数来不断的轮询，查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动的去查询设备的使用情况，如果能提供一种类似中断的机制，当驱动程序可以访问的时候主动告诉应用程序那就最好了。
“信号”为此应运而生，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉给应用程序的。
阻塞、非阻塞、异步通知，这三种是针对不同的场合提出来的不同的解决方法，没有优劣之分，在实际的工作和学习中，根据自己的实际需求选择合适的处理方法即可。
异步通知的核心就是信号，在arch/xtensa/include/uapi/asm/signal.h文件中定义了Linux所支持的所有信号，这些信号如下所示：

示例代码53.1.1.1 Linux信号
34 #define SIGHUP    		1  		/* 终端挂起或控制进程终止  			*/
35 #define SIGINT        	2  		/* 终端中断(Ctrl+C组合键)    		*/
36 #define SIGQUIT       	3  		/* 终端退出(Ctrl+\组合键)    		*/
37 #define SIGILL        	4  		/* 非法指令                 			*/
38 #define SIGTRAP       	5  		/* debug使用，有断点指令产生		*/
39 #define SIGABRT       	6  		/* 由abort(3)发出的退出指令 		*/
40 #define SIGIOT        	6  		/* IOT指令                    		*/
41 #define SIGBUS        	7  		/* 总线错误                 			*/
42 #define SIGFPE        	8  		/* 浮点运算错误           			*/
43 #define SIGKILL       	9  		/* 杀死、终止进程            		*/
44 #define SIGUSR1      	10  	/* 用户自定义信号1           		*/
45 #define SIGSEGV      	11  	/* 段违例(无效的内存段)    			*/
46 #define SIGUSR2      	12  	/* 用户自定义信号2           		*/
47 #define SIGPIPE      	13  	/* 向非读管道写入数据      			*/
48 #define SIGALRM      	14  	/* 闹钟                   			*/
49 #define SIGTERM      	15 	 	/* 软件终止                 			*/
50 #define SIGSTKFLT    	16  	/* 栈异常                    		*/
51 #define SIGCHLD      	17  	/* 子进程结束              			*/
52 #define SIGCONT      	18  	/* 进程继续                 			*/
53 #define SIGSTOP      	19  	/* 停止进程的执行，只是暂停 			*/
54 #define SIGTSTP      	20  	/* 停止进程的运行(Ctrl+Z组合键) 	*/
55 #define SIGTTIN      	21  	/* 后台进程需要从终端读取数据		*/
56 #define SIGTTOU      	22  	/* 后台进程需要向终端写数据 		*/
57 #define SIGURG       	23  	/* 有"紧急"数据            		*/
58 #define SIGXCPU      	24  	/* 超过CPU资源限制            	*/
59 #define SIGXFSZ      	25  	/* 文件大小超额           		*/
60 #define SIGVTALRM    	26  	/* 虚拟时钟信号           		*/
61 #define SIGPROF      	27 	 	/* 时钟信号描述           		*/
62 #define SIGWINCH     	28		/* 窗口大小改变           		*/
63 #define SIGIO        	29 		/* 可以进行输入/输出操作  		*/
64 #define SIGPOLL      	SIGIO   
65 /* #define SIGLOS    29 */
66 #define SIGPWR       	30 		/* 断点重启                 		*/
67 #define SIGSYS       	31  	/* 非法的系统调用            	*/
68 #define  SIGUNUSED   	31  	/* 未使用信号              		*/

在示例代码53.1.1.1中的这些信号中，除了SIGKILL(9)和SIGSTOP(19)这两个信号不能被忽略外，其他的信号都可以忽略。这些信号就相当于中断号，不同的中断号代表了不同的中断，不同的中断所做的处理不同，因此，驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。
我们使用中断的时候需要设置中断处理函数，同样的，如果要在应用程序中使用信号，那么就必须设置信号所使用的信号处理函数，在应用程序中使用signal函数来设置指定信号的处理函数，signal函数原型如下所示：
sighandler_t signal(int signum, sighandler_t handler)
函数参数和返回值含义如下：
signum：要设置处理函数的信号。
handler：信号的处理函数。
返回值：设置成功的话返回信号的前一个处理函数，设置失败的话返回SIG_ERR。
信号处理函数原型如下所示：
typedef void (*sighandler_t)(int)
我们前面讲解的使用“kill -9 PID”杀死指定进程的方法就是向指定的进程(PID)发送SIGKILL这个信号。当按下键盘上的CTRL+C组合键以后会向当前正在占用终端的应用程序发出SIGINT信号，SIGINT信号默认的动作是关闭当前应用程序。这里我们修改一下SIGINT信号的默认处理函数，当按下CTRL+C组合键以后先在终端上打印出“SIGINT signal！”这行字符串，然后再关闭当前应用程序。新建signaltest.c文件，然后输入如下所示内容：

示例代码53.1.1.2 信号测试
1  #include "stdlib.h"
2  #include "stdio.h"
3  #include "signal.h"
4  
5  void sigint_handler(int num)
6  {
7      printf("\r\nSIGINT signal!\r\n");
8      exit(0);
9  }
10 
11 int main(void)
12 {
13     signal(SIGINT, sigint_handler);
14     while(1);
15     return 0;
16 }

在示例代码53.1.1.2中我们设置SIGINT信号的处理函数为sigint_handler，当按下CTRL+C向signaltest发送SIGINT信号以后sigint_handler函数就会执行，此函数先输出一行“SIGINT signal!”字符串，然后调用exit函数关闭signaltest应用程序。
使用如下命令编译signaltest.c：

gcc signaltest.c -o signaltest
然后输入“./signaltest”命令打开signaltest这个应用程序，然后按下键盘上的CTRL+C组合键，结果如图53.1.1.1所示：

图53.1.1.1 signaltest软件运行结果
从图53.1.1.1可以看出，当按下CTRL+C组合键以后sigint_handler这个SIGINT信号处理函数执行了，并且输出了“SIGINT signal！”这行字符串。
53.1.2 驱动中的信号处理
1、fasync_struct结构体
首先我们需要在驱动程序中定义一个fasync_struct结构体指针变量，fasync_struct结构体内容如下：

示例代码53.1.2.1 fasync_struct发结构体
struct fasync_struct {
    spinlock_t      		fa_lock;
    int         				magic;
    int         				fa_fd;
    struct fasync_struct	*fa_next; 
    struct file     		*fa_file;
    struct rcu_head     	fa_rcu;
};

一般将fasync_struct结构体指针变量定义到设备结构体中，比如在上一章节的imx6uirq_dev结构体中添加一个fasync_struct结构体指针变量，结果如下所示：

示例代码53.1.2.2 在设备结构体中添加fasync_struct类型变量指针
1  struct imx6uirq_dev {    
2   	struct device *dev;
3   	struct class *cls;
4   	struct cdev cdev;
......
14  	struct fasync_struct *async_queue;  /* 异步相关结构体 */
15 };

第14行就是在imx6uirq_dev中添加了一个fasync_struct结构体指针变量。

2、fasync函数
如果要使用异步通知，需要在设备驱动中实现file_operations操作集中的fasync函数，此函数格式如下所示：
int (*fasync) (int fd, struct file *filp, int on)
fasync函数里面一般通过调用fasync_helper函数来初始化前面定义的fasync_struct结构体指针，fasync_helper函数原型如下：
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
fasync_helper函数的前三个参数就是fasync函数的那三个参数，第四个参数就是要初始化的fasync_struct结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync标记的时候，驱动程序file_operations操作集中的fasync函数就会执行。
驱动程序中的fasync函数参考示例如下：

示例代码53.1.2.3 驱动中fasync函数参考示例
1  struct xxx_dev { 
2   	......
3   	struct fasync_struct *async_queue;  /* 异步相关结构体 */ 
4  };
5 
6  static int xxx_fasync(int fd, struct file *filp, int on)
7  {
8   	struct xxx_dev *dev = (xxx_dev)filp->private_data;
9  
10  	if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)
11      	return -EIO;
12  	return 0;
13 }
14
15 static struct file_operations xxx_ops = {
16  	......
17  	.fasync = xxx_fasync,
18 	 	......
19 };

在关闭驱动文件的时候需要在file_operations操作集中的release函数中释放fasync_struct，fasync_struct的释放函数同样为fasync_helper，release函数参数参考实例如下：

示例代码53.1.2.4 释放fasync_struct参考示例
1 static int xxx_release(struct inode *inode, struct file *filp)
2 {
3   	return xxx_fasync(-1, filp, 0); /* 删除异步通知 */
4 }
5 
6 static struct file_operations xxx_ops = {
7  	 ......
8   	.release = xxx_release,
9 };

第3行通过调用示例代码53.1.2.3中的xxx_fasync函数来完成fasync_struct的释放工作，但是，其最终还是通过fasync_helper函数完成释放工作。

1、kill_fasync函数
当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync函数负责发送指定的信号，kill_fasync函数原型如下所示：
void kill_fasync(struct fasync_struct *fp, int sig, int band)
函数参数和返回值含义如下：
fp：要操作的fasync_struct。
sig：要发送的信号。
band：可读时设置为POLL_IN，可写时设置为POLL_OUT。
返回值：无。
53.1.3 应用程序对异步通知的处理
应用程序对异步通知的处理包括以下三步：
1、注册信号处理函数
应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用signal函数来设置信号的处理函数。前面已经详细的讲过了，这里就不细讲了。
2、将本应用程序的进程号告诉给内核
使用fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。
3、开启异步通知
使用如下两行程序开启异步通知：
flags = fcntl(fd, F_GETFL); / 获取当前的进程状态 /
fcntl(fd, F_SETFL, flags | FASYNC); / 开启当前进程异步通知功能 */
重点就是通过fcntl函数设置进程状态为FASYNC，经过这一步，驱动程序中的fasync函数就会执行。
53.2 硬件原理图分析
本章实验硬件原理图参考15.2小节即可。
53.3 实验程序编写
本实验对应的例程路径为：开发板光盘-> 2、Linux驱动例程-> 16_asyncnoti。
本章实验我们在上一章实验“15_noblockio”的基础上完成，在其中加入异步通知相关内容即可，当按键按下以后驱动程序向应用程序发送SIGIO信号，应用程序获取到SIGIO信号以后读取并且打印出按键值。
53.3.1 修改设备树文件
因为是在实验“15_noblockio”的基础上完成的，因此不需要修改设备树。
53.3.2 程序编写
新建名为“16_asyncnoti”的文件夹，然后在16_asyncnoti文件夹里面创建vscode工程，工作区命名为“asyncnoti”。将“15_noblockio”实验中的noblockio.c复制到16_asyncnoti文件夹中，并重命名为asyncnoti.c。接下来我们就修改asyncnoti.c这个文件，在其中添加异步通知关的代码，完成以后的asyncnoti.c内容如下所示(因为是在上一章实验的noblockio.c文件的基础上修改的，因为了减少篇幅，下面的代码有省略)：

示例代码53.3.2.1 asyncnoti.c文件代码段
1   #include <linux/types.h>
......
20  #include <linux/fcntl.h>
21  #include <asm/mach/map.h>
22  #include <asm/uaccess.h>
23  #include <asm/io.h>
24  /***************************************************************
25  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
26  文件名  	: asyncnoti.c
27  作者   	: 左忠凯
28  版本   	: V1.0
29  描述   	: 非阻塞IO访问
30  其他    	: 无
31  论坛   	: www.openedv.com
32  日志   	: 初版V1.0 2019/8/13 左忠凯创建
33  ***************************************************************/
34  #define IMX6UIRQ_CNT    	1           		/* 设备号个数  		*/
35  #define IMX6UIRQ_NAME  	"asyncnoti" 	/* 名字       		*/
36  #define KEY0VALUE        	0X01        	/* KEY0按键值    	*/
37  #define INVAKEY          	0XFF        	/* 无效的按键值 		*/
38  #define KEY_NUM          	1           		/* 按键数量     		*/
...... 
49  /* imx6uirq设备结构体 */
50  struct imx6uirq_dev{
......
64      struct fasync_struct *async_queue;      /* 异步相关结构体 */
65  };
66  
67  struct imx6uirq_dev imx6uirq;   /* irq设备 */
68  
......
84  
85  /* @description 	: 定时器服务函数，用于按键消抖，定时器到了以后
86   *                   再次读取按键值，如果按键还是处于按下状态就表示按键有效。
87   * @param - arg 	: 设备结构变量
88   * @return      	: 无
89   */
90  void timer_function(unsigned long arg)
91  {
92      unsigned char value;
93      unsigned char num;
94      struct irq_keydesc *keydesc;
95      struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;
......             
109     if(atomic_read(&dev->releasekey)) {     /* 一次完整的按键过程 */
110         if(dev->async_queue) 
111             kill_fasync(&dev->async_queue, SIGIO, POLL_IN); 
112     }
113 
114 #if 0
115     /* 唤醒进程 */
116     if(atomic_read(&dev->releasekey)) { 	/* 完成一次按键过程 	*/
117         /* wake_up(&dev->r_wait); */
118         wake_up_interruptible(&dev->r_wait);
119     }
120 #endif
121 }
......
262 /*
263  * @description 	: fasync函数，用于处理异步通知
264  * @param - fd   	: 文件描述符
265  * @param - filp 	: 要打开的设备文件(文件描述符)
266  * @param - on   	: 模式
267  * @return        	: 负数表示函数执行失败
268  */
269 static int imx6uirq_fasync(int fd, struct file *filp, int on)
270 {
271     struct imx6uirq_dev *dev = (struct imx6uirq_dev *)
filp->private_data;
272     return fasync_helper(fd, filp, on, &dev->async_queue);
273 }
274 
275 /*
276  * @description	: release函数，应用程序调用close关闭驱动文件的时候会执行
277  * @param – inode	: inode节点
278  * @param – filp	: 要打开的设备文件(文件描述符)
279  * @return       	: 负数表示函数执行失败
280  */
281 static int imx6uirq_release(struct inode *inode, struct file *filp)
282 {
283     return imx6uirq_fasync(-1, filp, 0);
284 }
285 
286 /* 设备操作函数 */
287 static struct file_operations imx6uirq_fops = {
288     .owner = THIS_MODULE,
289     .open = imx6uirq_open,
290     .read = imx6uirq_read,
291     .poll = imx6uirq_poll,
292     .fasync = imx6uirq_fasync,
293     .release = imx6uirq_release,
294 };
295 
296 /*
297  * @description 	: 驱动入口函数
298  * @param       	: 无
299  * @return      	: 无
300  */
301 static int __init imx6uirq_init(void)
302 {
......
328         
329     /* 5、始化按键 */
330     atomic_set(&imx6uirq.keyvalue, INVAKEY);
331     atomic_set(&imx6uirq.releasekey, 0);
332     keyio_init();
333     return 0;
334 }
335 
336 /*
337  * @description 	: 驱动出口函数
338  * @param       	: 无
339  * @return      	: 无
340  */
341 static void __exit imx6uirq_exit(void)
342 {
343     unsigned i = 0;
......
354     class_destroy(imx6uirq.class);
355 }   
356     
357 module_init(imx6uirq_init);
358 module_exit(imx6uirq_exit);
359 MODULE_LICENSE("GPL");

第20行，添加fcntl.h头文件，因为要用到相关的API函数。
第64行，在设备结构体imx6uirq_dev中添加fasync_struct指针变量。
第109~112行，如果是一次完整的按键过程，那么就通过kill_fasync函数发送SIGIO信号。
第114~120行，屏蔽掉以前的唤醒进程相关程序。
第269~273行，imx6uirq_fasync 函数，为file_operations操作集中的fasync函数，此函数内容很简单，就是调用一下fasync_helper。
第281~284行，release函数，应用程序调用close函数关闭驱动设备文件的时候此函数就会执行，在此函数中释放掉fasync_struct指针变量。
第292~293行，设置file_operations操作集中的fasync和release这两个成员变量。
53.3.3 编写测试APP
测试APP要实现的内容很简单，设置SIGIO信号的处理函数为sigio_signal_func，当驱动程序向应用程序发送SIGIO信号以后sigio_signal_func函数就会执行。sigio_signal_func函数内容很简单，就是通过read函数读取按键值。新建名为asyncnotiApp.c的文件，然后输入如下所示内容：

示例代码53.3.3.2 asyncnotiApp.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  #include "poll.h"
9  #include "sys/select.h"
10 #include "sys/time.h"
11 #include "linux/ioctl.h"
12 #include "signal.h"
13 /***************************************************************
14 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
15 文件名      	: asyncnotiApp.c
16 作者       	: 左忠凯
17 版本       	: V1.0
18 描述       	: 异步通知测试APP
19 其他       	: 无
20 使用方法	 	：./asyncnotiApp /dev/asyncnoti 打开测试App
21 论坛       	: www.openedv.com
22 日志       	: 初版V1.0 2019/8/13 左忠凯创建
23 ***************************************************************/
24 
25 static int fd = 0;   /* 文件描述符 */
26 
27 /*
28  * SIGIO信号处理函数
29  * @param - signum   	: 信号值
30  * @return           	: 无
31  */
32 static void sigio_signal_func(int signum)
33 {
34  	int err = 0;
35  	unsigned int keyvalue = 0;
36 
37  	err = read(fd, &keyvalue, sizeof(keyvalue));
38  	if(err < 0) {
39      	/* 读取错误 */
40  	} else {
41      	printf("sigio signal! key value=%d\r\n", keyvalue);
42  	}
43 }
44 
45 /*
46  * @description   	: main主程序
47  * @param - argc  	: argv数组元素个数
48  * @param - argv 	: 具体参数
49  * @return        	: 0 成功;其他 失败
50  */
51 int main(int argc, char *argv[])
52 {
53  	int flags = 0;
54  	char *filename;
55 
56  	if (argc != 2) {
57      	printf("Error Usage!\r\n");
58      	return -1;
59  	}
60 
61  	filename = argv[1];
62  	fd = open(filename, O_RDWR);
63  	if (fd < 0) {
64      	printf("Can't open file %s\r\n", filename);
65      	return -1;
66  	}
67 
68  	/* 设置信号SIGIO的处理函数 */
69  	signal(SIGIO, sigio_signal_func);
70  
71  	fcntl(fd, F_SETOWN, getpid()); 	/* 将当前进程的进程号告诉给内核  */
72  	flags = fcntl(fd, F_GETFD);   	/* 获取当前的进程状态       		*/
73  	fcntl(fd, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能	*/  
74 
75 	 	while(1) {
76      	sleep(2);
77  	}
78 
79  	close(fd);
80  	return 0;
81 }

第32~43行，sigio_signal_func函数，SIGIO信号的处理函数，当驱动程序有效按键按下以后就会发送SIGIO信号，此函数就会执行。此函数通过read函数读取按键值，然后通过printf函数打印在终端上。
第69行，通过signal函数设置SIGIO信号的处理函数为sigio_signal_func。
第71~73行，设置当前进程的状态，开启异步通知的功能。	

第75~77行，while循环，等待信号产生。
53.4 运行测试
53.4.1 编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为asyncnoti.o，Makefile内容如下所示：

示例代码53.4.1.1 Makefile文件
1  KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
...... 
4  obj-m := asyncnoti.o
......
11 clean:
12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

第4行，设置obj-m变量的值为asyncnoti.o。
输入如下命令编译出驱动模块文件：

make -j32
编译成功以后就会生成一个名为“asyncnoti.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试asyncnotiApp.c这个测试程序：
arm-linux-gnueabihf-gcc asyncnotiApp.c -o asyncnotiApp
编译成功以后就会生成asyncnotiApp这个应用程序。
53.4.2 运行测试
将上一小节编译出来asyncnoti.ko和asyncnotiApp这两个文件拷贝到rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录lib/modules/4.1.15中，输入如下命令加载asyncnoti.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe asyncnoti.ko //加载驱动
驱动加载成功以后使用如下命令来测试中断：
./asyncnotiApp /dev/asyncnoti
按下开发板上的KEY0键，终端就会输出按键值，如图53.4.2.1所示：

图53.4.2.1 读取到的按键值
从图53.4.2.1可以看出，捕获到SIGIO信号，并且按键值获取成功，大家可以自行以后台模式运行asyncnotiApp，查看一下这个应用程序的CPU使用率。如果要卸载驱动的话输入如下命令即可：
rmmod asyncnoti.ko