Linux 异步通知实验-基于正点原子IMX6ULL开发板

使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的，对于非阻塞方式来说还需要应用程序通过 poll 函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，然后应用程序在从驱动程序中读取或写入数据，类似于裸机例程中的中断。Linux 提供了异步通知这个机制来完成此功能，

1 异步通知

1.1异步通知简介

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

异步通知的核心就是信号，在 arch/xtensa/include/uapi/asm/signal.h 文件中定义了 Linux 所支持的所有信号，这些信号如下所示：

#define SIGHUP		 1
#define SIGINT		 2
#define SIGQUIT		 3
#define SIGILL		 4
#define SIGTRAP		 5
#define SIGABRT		 6
#define SIGIOT		 6
#define SIGBUS		 7
#define SIGFPE		 8
#define SIGKILL		 9
#define SIGUSR1		10
#define SIGSEGV		11
#define SIGUSR2		12
#define SIGPIPE		13
#define SIGALRM		14
#define SIGTERM		15
#define SIGSTKFLT	16
#define SIGCHLD		17
#define SIGCONT		18
#define SIGSTOP		19
#define SIGTSTP		20
#define SIGTTIN		21
#define SIGTTOU		22
#define SIGURG		23
#define SIGXCPU		24
#define SIGXFSZ		25
#define SIGVTALRM	26
#define SIGPROF		27
#define SIGWINCH	28
#define SIGIO		29
#define SIGPOLL		SIGIO
/* #define SIGLOST		29 */
#define SIGPWR		30
#define SIGSYS		31
#define	SIGUNUSED	31

/* These should not be considered constants from userland.  */
#define SIGRTMIN	32
#define SIGRTMAX	(_NSIG-1)

我们使用中断的时候需要设置中断处理函数，同样的，如果要在应用程序中使用信号，那么就必须设置信号所使用的信号处理函数，在应用程序中使用 signal 函数来设置指定信号的处理函数，signal 函数原型如下所示：

sighandler_t signal(int signum, sighandler_t handler)

信号处理函数原型如下所示：

typedef void (*sighandler_t)(int)

使用“kill -9 PID”杀死指定进程的方法就是向指定的进程(PID)发送SIGKILL 这个信号。

当按下键盘上的 CTRL+C 组合键以后会向当前正在占用终端的应用程序发出 SIGINT 信号，SIGINT 信号默认的动作是关闭当前应用程序。这里我们修改一下 SIGINT 信号的默认处理函数，当按下 CTRL+C组合键以后先在终端上打印出“SIGINT signal！”这行字符串，然后再关闭当前应用程序。新建 signaltest.c 文件，然后输入如下所示内容：

 #include "stdlib.h"
 #include "stdio.h"
 #include "signal.h"

/*信号处理函数*/
 void sigint_handler(int num) { 
  printf("\r\nSIGINT signal!\r\n");
 exit(0);
 }

 int main(void)
 {
 /*signal函数*/
 signal(SIGINT, sigint_handler);
 while(1);
 return 0;
 }

上面例程我们设置 SIGINT 信号的处理函数为 sigint_handler，当按下 CTRL+C向 signaltest 发送 SIGINT 信号以后 sigint_handler 函数就会执行，此函数先输出一行“SIGINT signal!”字符串，然后调用 exit 函数关闭 signaltest 应用程序。

使用如下命令编译 signaltest.c：

gcc signaltest.c -o signaltest

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

从上图可以看出，当按下 CTRL+C 组合键以后 sigint_handler 这个 SIGINT 信号处理函数执行了，并且输出了“SIGINT signal！”这行字符串。

1.2 驱动中的信号处理

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;
};

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

/*imx6uirq 设备结构体*/
struct imx6uirq_dev
{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    struct irq_keydesc irqkey[KEY_NUM];
    struct timer_list timer;

    atomic_t keyvalue;
    atomic_t releasekey;

    struct fasync_struct *fasync_queue;/* 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 函数参考示例如下：

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)/* fasync_helper 函数 */
        return -EIO;
    return 0;
}

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

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

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

static struct file_operations xxx_ops = {
    ......
        .release = xxx_release,

};

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

3、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。
返回值：无。

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 函数就会执行。

2 硬件原理图分析

略

3 实验程序编写

本次实验我们实现当按键按下以后驱动程序向应用程序发送 SIGIO 信号，应用程序获取到 SIGIO 信号以后读取并且打印出按键值。

3.1 修改设备树文件

无需修改

3.2 程序编写

驱动文件asyncnoti.c 内容如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.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/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/ide.h>

#define IMX6UIRQ_CNT 1
#define IMX6UIRQ_NAME "asyncnoti"
#define KEY_NUM 1
#define KEY0VALUE 0x01
#define INVAKEY 0xFF

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

/*imx6uirq 设备结构体*/
struct imx6uirq_dev
{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    struct irq_keydesc irqkey[KEY_NUM];
    struct timer_list timer;

    atomic_t keyvalue;
    atomic_t releasekey;

    struct fasync_struct *fasync_queue; /* fasync_struct 结构体指针变量*/
};

struct imx6uirq_dev imx6uirq; /*irq设备 */

static int imx6uirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6uirq;
    return 0;
}

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

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

    if (releasekey) /*有效按键*/
    {
        if (keyvalue & 0x80) /*释放*/
        {
            keyvalue &= ~0x80;
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
        }
        else
        {
            goto data_error;
        }
        atomic_set(&dev->releasekey, 0); /*按下标志清0*/
    }
    else
    {
        goto data_error;
    }

    return 0;
data_error:

    return -EINVAL;
}

/*
* @description : fasync 函数，用于处理异步通知
* @param - fd : 文件描述符
* @param - filp : 要打开的设备文件(文件描述符)
* @param - on : 模式 * @return : 负数表示函数执行失败
*/
static int imx6uirq_fasync(int fd, struct file *filp, int on)
{
    struct imx6uirq_dev *dev = filp->private_data;

    return fasync_helper(fd, filp, on, &dev->fasync_queue);
}

/*
* @description : release 函数，应用程序调用 close 关闭驱动文件的时候会执行
* @param – inode : inode 节点
* @param – filp : 要打开的设备文件(文件描述符)
* @return : 负数表示函数执行失败
*/

static int imx6uirq_release(struct inode *innode, struct file *filp)
{
    return imx6uirq_fasync(-1, filp, 0);
}

/*操作集*/
static const struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
    .open = imx6uirq_open,
    .read = imx6uirq_read,
    .fasync = imx6uirq_fasync,
    .release = imx6uirq_release,
};

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

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

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

    value = gpio_get_value(dev->irqkey[0].gpio);
    if (value == 0) /*按下*/
    {
        atomic_set(&dev->keyvalue, dev->irqkey[0].value);
    }
    else if (value == 1) /*释放*/
    {
        atomic_set(&dev->keyvalue, 0x80 | (dev->irqkey[0].value));
        atomic_set(&dev->releasekey, 1); /*完整的按键过程*/
    }

    if (atomic_read(&dev->releasekey)) /*有效的按键过程*/
    {
        if (dev->fasync_queue)
        {
            kill_fasync(&dev->fasync_queue, SIGIO, POLL_IN); /* 通过 kill_fasync 函数发送 SIGIO 信号。 */
        }
    }
}

/*按键初始化*/
static int keyio_init(struct imx6uirq_dev *dev)
{
    int ret = 0;
    int i = 0;
    /*1,按键初始化*/
    dev->nd = of_find_node_by_path("/key");
    if (dev->nd == NULL)
    {
        ret = -EINVAL;
        goto fail_nd;
    }

    for (i = 0; i < KEY_NUM; i++)
    {
        dev->irqkey[i].gpio = of_get_named_gpio(dev->nd, "key-gpios", i);
    }

    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);
        gpio_request(dev->irqkey[i].gpio, dev->irqkey[i].name);
        gpio_direction_input(dev->irqkey[i].gpio);

        dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio); /*获取中断号*/
#if 0   
        dev->irqkey[i].irqnum = irq_of_parse_and_map(dev->nd,i);
#endif
    }

    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value = KEY0VALUE;
    /*2,按键中断初始化*/
    for (i = 0; i < KEY_NUM; i++)
    {
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[0].handler,
                          IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                          dev->irqkey[i].name, &imx6uirq);
        if (ret)
        {
            printk("irq %d failed!\r\n", dev->irqkey[i].irqnum);
            goto fail_irq;
        }
    }

    /*初始化定时器*/
    init_timer(&imx6uirq.timer);
    imx6uirq.timer.function = timer_func;
    return 0;

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

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

    /*1,注册字符设备驱动*/
    imx6uirq.major = 0;
    if (imx6uirq.major)
    { /*给定主设备号*/
        imx6uirq.devid = MKDEV(imx6uirq.major, 0);
        ret = register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
    }
    else
    {
        ret = alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
    }

    if (ret < 0)
    {
        goto fail_devid;
    }

    printk("imx6uirq major =%d, minor =%d \r\n", imx6uirq.major, imx6uirq.minor);

    /*2,初始化cdev*/
    imx6uirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);

    /*3,添加cdev*/
    ret = cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);
    if (ret)
    {
        goto fail_cdevadd;
    }
    /*4,创建类*/
    imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);
    if (IS_ERR(imx6uirq.class))
    {
        ret = PTR_ERR(imx6uirq.class);
        goto fail_class;
    }
    /*5,创建设备*/
    imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);
    if (IS_ERR(imx6uirq.device))
    {
        ret = PTR_ERR(imx6uirq.device);
        goto fail_device;
    }

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

    /*初始化原子变量*/
    atomic_set(&imx6uirq.keyvalue, INVAKEY);
    atomic_set(&imx6uirq.releasekey, 0);
    return 0;

fail_keyinit:

fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdevadd:
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);
fail_devid:

    return ret;
}

/*驱动出口函数*/
static void __exit imx6uirq_exit(void)
{
    int i = 0;
    /*1、释放中断*/
    for (i = 0; i < KEY_NUM; i++)
    {
        free_irq(imx6uirq.irqkey[i].irqnum, &imx6uirq);
    }

    /*2、释放IO*/
    for (i = 0; i < KEY_NUM; i++)
    {
        gpio_free(imx6uirq.irqkey[i].gpio);
    }

    /*3、删除定时器*/
    del_timer(&imx6uirq.timer);

    /*注销字符设备驱动*/
    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("supersmart");

3.3 编写测试 APP

测试 APP 要实现的内容很简单，设置 SIGIO 信号的处理函数为 sigio_signal_func，当驱动程序向应用程序发送 SIGIO 信号以后 sigio_signal_func 函数就会执行。sigio_signal_func 函数内容很简单，就是通过 read 函数读取按键值。

asyncnotiAPP.c 的文件内容如下

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

/*
 *argc:应用程序参数个数
 * argv[]:具体的参数内容，字符串形式
 * ./asyncnotiAPP <filename> 
 * ./asyncnotiAPP /dev/asyncnoti
 */

int fd;

/*
* SIGIO 信号处理函数
* @param - signum : 信号值
* @return : 无
*/

static void sigio_signal_func(int num)
{
    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 ret;
    char *filename;
    unsigned char data;
    int flags;

    if (argc != 2)
    {
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("file %s open failed!\r\n", filename);
        return -1;
    }

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

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

    while (1)
    {
        sleep(2);
    }
    close(fd);
    return 0;
}

4 运行测试

4.1 编译驱动程序和测试 APP

略

4.2 运行测试

加载驱动

使用如下命令来测试中断：

./asyncnotiAPP /dev/asyncnoti

按下开发板上的 KEY0 键，终端就会输出按键值


以后台模式运行asyncnotiAPP，输入top 命令查看 cpu占用率为0.0%