一.异步通知简介
1.信号简介
信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉给应用程序的。
2.Linux所支持的信号
#define SIGHUP 1 /* 终端挂起或控制进程终止 */
#define SIGINT 2 /* 终端中断(Ctrl+C 组合键) */
#define SIGQUIT 3 /* 终端退出(Ctrl+\组合键) */
#define SIGILL 4 /* 非法指令 */
#define SIGTRAP 5 /* debug 使用，有断点指令产生 */
#define SIGABRT 6 /* 由 abort(3)发出的退出指令 */
#define SIGIOT 6 /* IOT 指令 */
#define SIGBUS 7 /* 总线错误 */
#define SIGFPE 8 /* 浮点运算错误 */
#define SIGKILL 9 /* 杀死、终止进程 */
#define SIGUSR1 10 /* 用户自定义信号 1 */
#define SIGSEGV 11 /* 段违例(无效的内存段) */
#define SIGUSR2 12 /* 用户自定义信号 2 */
#define SIGPIPE 13 /* 向非读管道写入数据 */
#define SIGALRM 14 /* 闹钟 */
#define SIGTERM 15 /* 软件终止 */
#define SIGSTKFLT 16 /* 栈异常 */
#define SIGCHLD 17 /* 子进程结束 */
#define SIGCONT 18 /* 进程继续 */
#define SIGSTOP 19 /* 停止进程的执行，只是暂停 */
#define SIGTSTP 20 /* 停止进程的运行(Ctrl+Z 组合键) */
#define SIGTTIN 21 /* 后台进程需要从终端读取数据 */
#define SIGTTOU 22 /* 后台进程需要向终端写数据 */
#define SIGURG 23 /* 有"紧急"数据 */
#define SIGXCPU 24 /* 超过 CPU 资源限制 */
#define SIGXFSZ 25 /* 文件大小超额 */
#define SIGVTALRM 26 /* 虚拟时钟信号 */
#define SIGPROF 27 /* 时钟信号描述 */
#define SIGWINCH 28 /* 窗口大小改变 */
#define SIGIO 29 /* 可以进行输入/输出操作 */
#define SIGPOLL SIGIO
/* #define SIGLOS 29 */
#define SIGPWR 30 /* 断点重启 */
#define SIGSYS 31 /* 非法的系统调用 */
#define SIGUNUSED 31 /* 未使用信号 */二.应用程序信号相关函数
1.设置信号处理函数 - signal
函数原型：
/**
* @description: 设置信号处理函数
* @param - signum : 要设置处理函数的信号
* @param - handler : 信号的处理函数
* @return : 成功则返回（信号的前一个处理函数），失败则返回（SIG_ERR）
*/
sighandler_t signal(int signum,sighandler_t handler)2.信号处理函数
/**
* @description: 信号处理函数
*/
typedef void (*sighandler_t)(int)三.驱动程序信号相关函数
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;
};2.处理异步通知 - fasync 函数
函数原型：
/*
* @description: 处理异步通知
* @param - fd : 文件描述符
* @param - filp : 要打开的设备文件（文件描述符）
* @param - on : 模式
* @return : 执行失败则返回（负数）
*/
int (*fasync)(int fd,struct file *filp,int on)3.处理异步通知 - fasync_helper
一般在 fasync 函数中调用 fasync_helper 函数来初始化前面定义的 fasync_struct 结构体指针，或者在 release 函数中释放掉 fasync_struct 指针变量;
函数原型：
/**
* @description: 初始化 fasync_struct 结构体
* @param - fd : 文件描述符
* @param - filp : 要打开的设备文件（文件描述符）
* @param - on : 模式
* @param - fapp : fasync_struct 的二级指针
* @return : 执行失败则返回（负数）
*/
int fasync_helper(int fd,struct file *filp,int on,struct fasync_struct **fapp)
4.驱动程序向应用程序发送信号 - kill_fasync
函数原型：
/**
* @description: 驱动程序向应用程序发送信号
* @param - fp : 要操作的 fasync_struct 结构体的二级指针
* @param - sig : 要发送的信号
* @param - band : 可读时设置为 POLL_IN , 可写时设置为 POLL_OUT
* @return : 无
*/
void kill_fasync(struct fasync_struct **fp,int sig,int band)四.实验代码
1.设备树
（1）.流程图
（2）.设备树代码
2.驱动部分
（1）.流程图
（2）.驱动代码
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/fcntl.h>
#define IMX6UIRQ_CNT 1 /* 设备号个数 */
#define IMX6UIRQ_NAME "asyncnoti" /* 设备名字 */
#define KEY0VALUE 0X01 /* KEY0按键值 */
#define INVAKEY 0XFF /* 无效的按键值 */
#define KEY_NUM 1 /* 按键数量 */
/* 中断 IO 描述结构体 */
struct irq_keydesc
{
int gpio; /* gpio */
int irqnum; /* 中断号 */
unsigned char value; /* 按键对应的键值 */
char name[10]; /* 名字 */
irqreturn_t (*handler)(int,void *); /* 指向中断服务函数的函数指针 */
};
/* imx6uirq 设备结构体 */
struct imx6uirq_dev
{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
int major; /* 主设备号 */
int minor; /* 次设备号 */
struct device_node *nd; /* 设备结点 */
atomic_t keyvalue; /* 有效的按键值 */
atomic_t releasekey; /* 标记是否完成一次完整的按键动作 */
struct timer_list timer; /* 定义一个定时器 */
struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按键中断信息描述数组 */
unsigned char curkeynum; /* 当前的按键号 */
struct fasync_struct *async_queue; /* 异步相关结构体 */
};
/* irq 设备 */
struct imx6uirq_dev imx6uirq;
/**
* @description: KEY0 按键中断服务函数，开启定时器，延时 10 ms，定时器用于按键消抖
* @param - irq : 中断号
* @param - dev_id : 设备结构
* @return : 中断执行结果
*/
static irqreturn_t key0_handler(int irq,void *dev_id)
{
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;
/* 表示按键中断触发（双边沿触发） （因为按键平时为上拉状态） */
dev->curkeynum = 0;
dev->timer.data = (volatile long)dev_id;
/* 2.让定时器回调函数 10 ms 后触发 */
mod_timer(&dev->timer,jiffies + msecs_to_jiffies(10));
return IRQ_RETVAL(IRQ_HANDLED);
}
/**
* @description: 定时器服务函数，用于按键消抖，定时器到了以后再次读取按键值，
* 如果按键还是处于按下的状态就表示按键动作有效
* @param - arg : 设备结构体变量
* @return : 无
*/
void timer_function(unsigned long arg)
{
unsigned char value;
unsigned char num;
struct irq_keydesc *keydesc;
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;
/* 获取上一刻的按键状态 */
num = dev->curkeynum;
keydesc = &dev->irqkeydesc[num];
/* 读取当前 gpio 的状态 */
value = gpio_get_value(keydesc->gpio);
/* 若此刻 gpio 的状态为低电平 ， 则消抖后确认按键确实是按下了 （因为这个定时器服务函数是在按键中断之后触发的） */
if(0 == value)
{
atomic_set(&dev->keyvalue,keydesc->value);
}
/* 若此刻 gpio 的状态为高电平 ， 则消抖后确认按键确实是松开了 （因为这个定时器服务函数是在按键中断之后触发的） */
else
{
atomic_set(&dev->keyvalue, 0x80 | keydesc->value); //最高为置 1
atomic_set(&dev->releasekey, 1); //标记松开按键
}
/* 如果消抖后判断为完成了一次按键 , 则向应用程序发送信号 */
if(atomic_read(&dev->releasekey))
{
if(dev->async_queue)
{
kill_fasync(&dev->async_queue,SIGIO,POLL_IN);
}
}
}
/**
* @description: 按键 IO 初始化
* @param : 无
* @return : 成功返回（0），返回其他则为失败
*/
static int keyio_init(void)
{
unsigned char i = 0;
int ret = 0;
/* 1.获取设备结点 */
imx6uirq.nd = of_find_node_by_path("/key");
if(NULL == imx6uirq.nd)
{
printk("key node not find!\r\n");
return -EINVAL;
}
/* 2.获取 KEY 的 GPIO 编号 */
for(i = 0;i < KEY_NUM;i++)
{
imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd,"key-gpio",i);
/* 若获取 gpio 编号失败 */
if(imx6uirq.irqkeydesc[i].gpio < 0)
{
printk("can not get key%d\r\n",i);
}
}
for(i = 0;i < KEY_NUM;i++)
{
memset(imx6uirq.irqkeydesc[i].name,0,sizeof(imx6uirq.irqkeydesc[i].name));
sprintf(imx6uirq.irqkeydesc[i].name,"KEY%d",i);
/* 3.申请 GPIO */
gpio_request(imx6uirq.irqkeydesc[i].gpio,imx6uirq.irqkeydesc[i].name);
/* 4.设置 IO 为输入 */
gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);
/* 5.获取 GPIO 的中断号 */
imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd,i);
#if 0
/* 若使用 GPIO 的话，可以使用 gpio_to_irq 函数来获取 gpio 对应中断号 */
imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio);
#endif
printk("key : %d ; gpio = %d , irqnum = %d\r\n",i,imx6uirq.irqkeydesc[i].gpio,imx6uirq.irqkeydesc[i].irqnum);
}
/* 6.申请中断 */
imx6uirq.irqkeydesc[0].handler = key0_handler;
imx6uirq.irqkeydesc[0].value = KEY0VALUE;
for(i = 0;i < KEY_NUM;i++)
{
ret = request_irq(imx6uirq.irqkeydesc[i].irqnum,
imx6uirq.irqkeydesc[i].handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
imx6uirq.irqkeydesc[i].name,
&imx6uirq);
}
/* 7.创建定时器 */
init_timer(&imx6uirq.timer);
imx6uirq.timer.function = timer_function;
return 0;
}
/**
* @description: 打开设备
* @param - inode : 传递给驱动的 inode
* @param - filp : 设备文件
* @return : 0 为成功 ， 其他为失败
*/
static int imx6uirq_open(struct inode *inode,struct file *filp)
{
/* 设置私有数据 */
filp->private_data = &imx6uirq;
return 0;
}
/**
* @description: 从设备读取数据
* @param - filp : 文件描述符
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的字节数
* @param - offt : 相对于文件首地址的偏移量
* @return : 成功读取的字节数，如果为负值，则表示失败
*/
static ssize_t imx6uirq_read(struct file *filp,char __user *buf,size_t cnt,loff_t *offt)
{
int ret = 0;
unsigned char keyvalue = 0;
unsigned char releasekey = 0;
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;
/* 读取消抖后的键值 */
keyvalue = atomic_read(&dev->keyvalue);
releasekey = atomic_read(&dev->releasekey);
/* 如果有按键按下 */
if(releasekey)
{
if(keyvalue & 0x80)
{
keyvalue &= ~0x80; //将 keyvalue 最高为清零
ret = copy_to_user(buf,&keyvalue,sizeof(keyvalue));
}
else
{
goto data_error;
}
/* 清除按下标志 */
atomic_set(&dev->releasekey,0);
}
else
{
goto data_error;
}
return 0;
data_error:
return -EINVAL;
}
/**
* @description: 处理异步通知
* @param - fd : 文件描述符
* @param - filp : 要打开的文件（文件描述符）
* @param - on : 模式
* @return : 执行失败时返回（负数）
*/
static int imx6uirq_fasync(int fd,struct file *filp,int on)
{
struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;
return fasync_helper(fd,filp,on,&dev->async_queue);
}
/**
* @description: 关闭/释放设备
* @param - inode : inode 节点
* @param - filp : 要打开的文件（文件描述符）
* @return : 执行失败则返回（负数）
*/
static int imx6uirq_release(struct inode *inode,struct file *filp)
{
return imx6uirq_fasync(-1,filp,0);
}
/* 设备操作函数 */
static struct file_operations imx6uirq_fops =
{
.owner = THIS_MODULE,
.open = imx6uirq_open,
.read = imx6uirq_read,
.fasync = imx6uirq_fasync,
.release = imx6uirq_release,
};
/**
* @description: 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init imx6uirq_init(void)
{
/* 1.创建设备号 */
if(imx6uirq.major) //若定义了设备号
{
imx6uirq.devid = MKDEV(imx6uirq.major,0);
register_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
}
else //若没有定义设备号
{
alloc_chrdev_region(&imx6uirq.devid,0,IMX6UIRQ_CNT,IMX6UIRQ_NAME);
imx6uirq.major = MAJOR(imx6uirq.devid);
imx6uirq.minor = MINOR(imx6uirq.devid);
}
/* 2.初始化cdev */
cdev_init(&imx6uirq.cdev,&imx6uirq_fops);
/* 3,添加一个cdev */
cdev_add(&imx6uirq.cdev,imx6uirq.devid,IMX6UIRQ_CNT);
/* 4.创建类 */
imx6uirq.class = class_create(THIS_MODULE,IMX6UIRQ_NAME);
if(IS_ERR(imx6uirq.class))
{
return PTR_ERR(imx6uirq.class);
}
/* 5.创建设备 */
imx6uirq.device = device_create(imx6uirq.class,NULL,imx6uirq.devid,NULL,IMX6UIRQ_NAME);
if(IS_ERR(imx6uirq.device))
{
return PTR_ERR(imx6uirq.device);
}
/* 6.初始化按键 */
atomic_set(&imx6uirq.keyvalue,INVAKEY);
atomic_set(&imx6uirq.releasekey,0);
keyio_init();
return 0;
}
/**
* @description: 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit imx6uirq_exit(void)
{
unsigned int i = 0;
/* 1.删除定时器 */
del_timer_sync(&imx6uirq.timer);
/* 2.释放 中断 与 GPIO */
for(i = 0;i < KEY_NUM;i++)
{
free_irq(imx6uirq.irqkeydesc[i].irqnum,&imx6uirq);
gpio_free(imx6uirq.irqkeydesc[i].gpio);
}
/* 3. 注销字符设备驱动 */
cdev_del(&imx6uirq.cdev);
unregister_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT);
device_destroy(imx6uirq.class,imx6uirq.devid);
class_destroy(imx6uirq.class);
}
module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("kaneki");
3.应用程序部分
（1）.流程图
（2）.应用部分代码
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
static int fd; //文件描述符
/**
* @description: 信号处理函数
*/
static void sigio_signal_func(int signum)
{
int err = 0;
unsigned int keyvalue = 0;
err = read(fd,&keyvalue,sizeof(keyvalue));
if(0 > err)
{
/* 用户自定义执行读取错误的处理部分...... */
}
else
{
printf("sigio signal ! key value = %d\n",keyvalue);
}
}
int main(int argc, char *argv[])
{
int flags = 0;
char *filename;
if(argc != 2)
{
printf("usage : ./%s <dev_path>\n",argv[0]);
return -1;
}
/* 保存文件路径 */
filename = argv[1];
fd = open(filename,O_RDWR);
if(0 > fd)
{
perror("open dev error");
return -1;
}
/* 1.注册信号处理函数 */
signal(SIGIO,sigio_signal_func);
/* 2.将本应用程序的进程号告诉给内核 */
fcntl(fd,F_SETOWN,getpid());
/* 3.开启异步通知 */
flags = fcntl(fd,F_GETFD); //获取当前的进程状态
fcntl(fd,F_SETFL,flags | FASYNC); //设置进程启用异步通知功能
/* 4.等待接收到信号，在信号处理函数中获取数据 */
while(1)
{
sleep(2);
}
close(fd);
return 0;
}
4.实验现象
可以看到，应用程序因为平时都在休眠，只有收到驱动程序发送的信号，才去执行一次信号处理函数里面的内容，所以消耗 CPU 的资源很少！
