Linux驱动_异步通知

Linux应用通常有三种方式查询设备驱动是否可以访问，分别是：阻塞式、非阻塞式和异步通知。

异步通知：  “信号”为此应运而生，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报
告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个
过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在
整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉
给应用程序的。

        在arch/xtensa/include/uapi/asm/signal.h文件中定义了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 /* 未使用信号 */

        在所有的信号当中，只有9和19不能被忽略！

信号的接收：

        在单片机开发中，使用中断的时候需要执行中断处理函数。同样在Linux系统中，应用程序接受到相应的信号的时候，也需要执行信号处理函数。在应用程序中使用 signal 函数来设置指定信号的处理函数， signal 函数原型如下所示：

sighandler_t signal(int signum, sighandler_t handler)

函数参数和返回值含义如下：
signum：要设置处理函数的信号。
handler： 信号的处理函数。
返回值： 设置成功的话返回信号的前一个处理函数，设置失败的话返回 SIG_ERR。 

驱动中信号的处理发送：

        1、fasync_struct 结构体

        需要在驱动程序中定义一个 fasync_struct 结构体指针变量， 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 函数

        要使用异步通知，需要在设备驱动中实现 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)

 代码举例：

struct xxx_dev {
  // ......
 struct fasync_struct *async_queue; /* 异步相关结构体 */
 };

static int xxx_fasync(int fd, struct file *filp, int on)
{
 struct xxx_dev *dev = (xxx_dev)filp->private_data;

 if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)
 return -EIO;
 return 0;
 }

 static struct file_operations xxx_ops = {
 //......
 .fasync = xxx_fasync,
 //......
 };

在卸载驱动的时候，需要释放前面定义的fasync_struct结构体，参考如下：

static int xxx_release(struct inode *inode, struct file *filp)
{
    return xxx_fasync(-1, filp, 0); /* 删除异步通知 */
}

        当设备可以访问的时候，驱动程序需要向应用程序发出信号，。 kill_fasync函数负责发送指定的信号， kill_fasync 函数原型如下所示：

void kill_fasync(struct fasync_struct **fp, int sig, int band)

函数参数和返回值含义如下：
fp：要操作的 fasync_struct。
sig： 要发送的信号。
band： 可读时设置为 POLL_IN，可写时设置为 POLL_OUT。
返回值： 无。

应用程序对异步通知的处理：

        应用程序对异步通知的处理包括以下三步：
1、注册信号处理函数
        应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用 signal 函数来
设置信号的处理函数。前面已经详细的讲过了，这里就不细讲了。
2、将本应用程序的进程号告诉给内核
        使用 fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。
3、开启异步通知
        使用如下两行程序开启异步通知：
        flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态 */
        fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能 */
        重点就是通过 fcntl 函数设置进程状态为 FASYNC，经过这一步，驱动程序中的 fasync 函
数就会执行。

驱动代码：

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/ide.h>
#include <linux/poll.h>
#include <linux/fcntl.h>


#define IMX6ULIRQ_COUNT 1
#define IMX6ULIRQ_NAME "asyncnoti"

#define KEY_NUM 1   /*因为一块板子上按键不只有1个，所有创建一个结构体数组来描述按键*/
#define KEY0VALUE 0X01
#define INVALKEY 0XFF


/*按键结构体*/
struct irq_keydesc{
    int gpio;  /*io编号*/
    int irqnum; /*中断编号*/
    unsigned char value; /*按键值*/
    char name[10];  /*中断名字*/
    irqreturn_t (*handler) (int, void *);  /*中断处理函数*/
};

/*设备结构体*/
struct imx6ulirq_dev{
    dev_t devid;    /*设备号*/
    int major;  /*主设备号*/
    int minor;  /*次设备号*/
    struct cdev cdev;   /*字符设备*/
    struct class *class;    /*创建类*/
    struct device *device;  /*创建设备*/
    struct device_node *node; /*设备节点*/
    struct irq_keydesc irqkey[KEY_NUM]; 
    struct timer_list timer;    /*添加定时器*/
    atomic_t keyval; /*按键值*/
    atomic_t releasekey;
    wait_queue_head_t r_wait;   /*读等待队列头*/
    struct fasync_struct *async_queue;  /*异步通讯结构体*/

};


struct imx6ulirq_dev imx6ulirq;


static int imx6ulirq_open(struct inode *inode, struct file *filp){
    filp->private_data = &imx6ulirq; /* 设置私有数据 */
    return 0;
}
 

static ssize_t imx6ulirq_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt){
    int ret = 0;
    unsigned char keyval;
    unsigned char releasekey;
    struct imx6ulirq_dev *dev = filp->private_data;


    keyval = atomic_read(&dev->keyval);
    releasekey = atomic_read(&dev->releasekey);

    if(releasekey){ /*如果releasekey为真表示一次完整的按键过程*/
        if(keyval & 0X80){  /*前面将真实按键值或了0X80，现在判断是否为真，若为真则返回原按键值*/
            keyval &= ~0X80;
            ret = copy_to_user(buf, &keyval, sizeof(keyval));
        }
        else{
            goto failed_error;
        }
        atomic_set(&dev->releasekey, 0);    /*按下标志清0*/
    }
    else{
        goto failed_error;
    }

failed_error:
    return ret;

}



static int imx6uirq_fasync(int fd, struct file *filp, int on){
    struct imx6ulirq_dev *dev = filp->private_data;
    return fasync_helper(fd, filp, on, &dev->async_queue);  /*利用fasync_helper函数，初始化结构体成员变量*/
}

static int imx6ulirq_release(struct inode *inode, struct file *filp){
    
    return imx6uirq_fasync(-1, filp, 0);    /*释放掉 fasync_struct 指针变量*/
}

static const struct file_operations imx6ulirq_fops = { /*字符设备操作函数集合*/
    .owner = THIS_MODULE,
    .open = imx6ulirq_open,
    .read = imx6ulirq_read,
    .release = imx6ulirq_release,
    .fasync = imx6uirq_fasync,
    
};

/*中断处理函数*/
static irqreturn_t key0_handler(int irq, void *dev_id){
    struct imx6ulirq_dev *dev = dev_id;

    dev->timer.data = (volatile long)dev_id;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(15)); /*15ms定时*/
    

    return IRQ_HANDLED;
}

/*定时器超市处理函数*/
static void timer_func(unsigned long arg) {
    int value = 0;
    struct imx6ulirq_dev *dev = (struct imx6ulirq_dev *)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0 ){
        atomic_set(&dev->keyval, dev->irqkey[0].value); /*如果按键按下设置按键为设置的值*/
    }
    else{
        atomic_set(&dev->keyval, 0X80 | (dev->irqkey[0].value));/*松开则设置按键为设置的值高位或1,来区分*/
        atomic_set(&dev->releasekey, 1);    /*releasekey设置为1表示一次完整的按键过程*/
    }

    if(atomic_read(&dev->releasekey)){   /*如果是一次完整的按键，则向应用发送信号*/
        if(dev->async_queue){
            kill_fasync(&dev->async_queue, SIGIO, POLL_IN); /* 释放SIGIO信号 */
         }
        }
    

}

/*按键初始化*/
static int keyio_init(struct imx6ulirq_dev *dev){
    int ret = 0;
    int i = 0;
    /*1、按键初始化*/
    dev->node = of_find_node_by_path("/key");
    if(dev->node == NULL){
        ret = -EINVAL;
        goto failed_findnode;
    }

    /*循环找到节点*/
    for (i = 0; i < KEY_NUM; i++){
        dev->irqkey[i].gpio = of_get_named_gpio(dev->node, "key-gpios", i); 
        if(dev->irqkey[i].gpio < 0){
            printk("can't get gpio %d\r\n",i);
            ret = -EINVAL;
            goto failed_findnode;
        }   
    }
    /*循环申请gpio*/
     for (i = 0; i < KEY_NUM; i++){ 
        memset(dev->irqkey[i].name, 0, sizeof(dev->irqkey[i].name));
        sprintf(dev->irqkey[i].name, "KEY%d", i);
        ret = gpio_request(dev->irqkey[i].gpio, dev->irqkey[i].name);
        if(ret){
            printk("Failed to request gpio \r\n");
            ret = -EINVAL;
            goto failed_findnode;
    }
    ret = gpio_direction_input(dev->irqkey[i].gpio);
    if(ret < 0){
        goto failed_setinput;
     }
    dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio);   /*获取中断号*/
     }
    /*2、按键中断初始化*/

    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value = KEY0VALUE;

    for(i = 0;i< KEY_NUM; i++){
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].handler, 
                         IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, dev->irqkey[i].name, &imx6ulirq);
        if(ret){
            printk("irq %d request failed!\r\n",i);
            goto failed_irq;
        }
    }

    /*初始化定时器*/
    init_timer(&dev->timer);
    dev->timer.function = timer_func;    /*定时器超时处理函数*/

    return 0;

failed_irq:
failed_setinput:
    for(i = 0;i< KEY_NUM;i++) {
        gpio_free(dev->irqkey[i].gpio);
    }
failed_findnode:
    return ret;
}


/*入口函数*/
static int __init imx6ulirq_init(void){
    int ret = 0;


    /*注册字符设备*/
    imx6ulirq.major = 0;     /*内核自动申请设备号*/
    if(imx6ulirq.major){     /*如果定义了设备号*/
        imx6ulirq.devid = MKDEV(imx6ulirq.major, 0);
        ret = register_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT, IMX6ULIRQ_NAME); 
    }
    else{   /*否则自动申请设备号*/
        ret = alloc_chrdev_region(&imx6ulirq.devid, 0, IMX6ULIRQ_COUNT, IMX6ULIRQ_NAME);
        imx6ulirq.major = MAJOR(imx6ulirq.devid); /*保存主设备号*/
        imx6ulirq.minor = MINOR(imx6ulirq.devid); /*保存次设备号*/
    }
    if(ret < 0){
        goto failed_devid;
    }
    printk("imx6ulirq_dev major = %d minor = %d \r\n",imx6ulirq.major,imx6ulirq.minor);  /*打印主次设备号*/

    /*添加字符设备*/
    imx6ulirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6ulirq.cdev, &imx6ulirq_fops);
    ret = cdev_add(&imx6ulirq.cdev, imx6ulirq.devid, IMX6ULIRQ_COUNT);
    if(ret < 0){    /*添加字符设备失败*/
        goto failed_cdev;
    }

    /*自动添加设备节点*/
    /*创建类*/
    imx6ulirq.class = class_create(THIS_MODULE, IMX6ULIRQ_NAME); /*class_creat(owner,name);*/
    if(IS_ERR(imx6ulirq.class)){   /*判断是否创建类成功*/
        ret = PTR_ERR(imx6ulirq.class);
        goto failed_class;
    }

    /*创建设备*/

    imx6ulirq.device = device_create(imx6ulirq.class, NULL, imx6ulirq.devid, NULL, IMX6ULIRQ_NAME);
     if(IS_ERR(imx6ulirq.device)){   /*判断是否创建类成功*/
        ret = PTR_ERR(imx6ulirq.device);
        goto failed_device;
    }

    /*初始化IO*/
    ret = keyio_init(&imx6ulirq);
    if(ret < 0) {
        goto failed_keyinit;
    }

    /*初始化原子变量*/
    atomic_set(&imx6ulirq.keyval, INVALKEY);
    atomic_set(&imx6ulirq.releasekey, 0);


    return 0;

failed_keyinit:
failed_device:
    class_destroy(imx6ulirq.class);
failed_class:
    cdev_del(&imx6ulirq.cdev);
failed_cdev:
    unregister_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT);
failed_devid:
    return ret;
}

/*出口函数*/
static void __exit imx6ulirq_exit(void){
    int i = 0;

    /*释放中断*/
    for(i = 0;i< KEY_NUM;i++) {
        free_irq(imx6ulirq.irqkey[i].irqnum, &imx6ulirq); 
    }
    /*释放io*/
     for(i = 0;i< KEY_NUM;i++) {
        gpio_free(imx6ulirq.irqkey[i].gpio);
    }
    
    /*删除定时器*/
    del_timer_sync(&imx6ulirq.timer);

    /*注销字符设备*/
    cdev_del(&imx6ulirq.cdev);
    /*卸载设备*/
    unregister_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT);

    device_destroy(imx6ulirq.class, imx6ulirq.devid);
    class_destroy(imx6ulirq.class);

}


/*模块入口和出口*/
module_init(imx6ulirq_init);
module_exit(imx6ulirq_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZYC");

应用代码： 

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>


static int fd = 0; /* 文件描述符 */

/*
28 * SIGIO 信号处理函数
29 * @param - signum : 信号值
30 * @return : 无
31 */
static void sigio_signal_func(int signum)
{
    int err = 0;
    unsigned int keyvalue = 0;

    err = read(fd, &keyvalue, sizeof(keyvalue));
    if(err < 0) {
    /* 读取错误 */
    } else {
    printf("sigio signal! key value=%d\r\n", keyvalue);
    }
}



int main(int argc, char *argv[]) {
    int flags = 0;
    char *filename;


    if(argc != 2){
        printf("Error used!\r\n");
        return -1;
    }
    
    filename = argv[1];        /*保存文件名*/
    fd = open(filename, O_RDWR);
    if(fd < 0 ){
        printf("Can't open file %s\r\n",filename);
    }

    /* 设置信号 SIGIO 的处理函数 */
    signal(SIGIO, sigio_signal_func);

    fcntl(fd, F_SETOWN, getpid()); /* 将当前进程的进程号告诉给内核 */
    flags = fcntl(fd, F_GETFD); /* 获取当前的进程状态 */
    fcntl(fd, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能 */

    while(1) {
    sleep(2);
    }

    close(fd);
    return 0;
    }