RK3568驱动指南｜第四篇-高级字符设备进阶-第29章 信号驱动IO实验

瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

​
【公众号】迅为电子

【粉丝群】824412014（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第四篇-高级字符设备进阶_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

---

第29章 信号驱动IO实验

本章节要讲解的信号驱动IO是最后一个IO模型，在第25章中我们已经对信号驱动IO有了基本的认识，本章节将对信号驱动IO进行深入的学习，最后通过相应的实验，来加深对信号驱动IO的理解。

29.1 信号驱动IO简介

信号驱动IO不需要应用程序查询设备的状态，一旦设备准备就绪，会触发SIGIO信号，进而调用注册的处理函数。仍旧以钓鱼为例。小马同学喜欢吃新鲜的鱼，但是不想自己钓，所以他请了一个助手来帮他钓鱼，他自己去忙其他的事情（进程不阻塞，立即返回）。如果有鱼上钩助手会帮忙钓上来（将数据拷贝到指定的缓冲区），并立即通知小马同学回来把鱼取走（处理数据）。

如果要实现信号驱动IO，需要应用程序和驱动程序配合，应用程序使用信号驱动IO的步骤有三步：

步骤1 ：注册信号处理函数 应用程序使用signal函数来注册SIGIO信号的信号处理函数。

步骤2： 设置能够接收这个信号的进程

步骤3： 开启信号驱动IO 通常使用fcntl函数的F_SETFL命令打开FASYNC标志。

fcntl函数如下所示：

函数原型：

int fcntl(int fd,int cmd, …)

函数功能

fcntl函数可以用来操作文件描述符

函数参数

fd: 被操作的文件描述符

cmd: 操作文件描述符的命令，cmd参数决定了要如何操作文件描述符fd

…: 根据cmd的参数来决定是不是需要使用第三个参数

操作文件描述符的命令如下表（表 29-1）所示：

命令名	描述
F_DUPFD	复制文件描述符
F_GETFD	获取文件描述符标志
F_SETFD	设置文件描述符标志
F_GETFL	获取文件状态标志
F_SETFL	设置文件状态标志
F_GETLK	获取文件锁
F_SETLK	设置文件锁
F_SETLKW	类似F_SETLK，但等待返回
F_GETOWN	获取当前接收SIGIO和SIGURG信号的进程ID和进程组ID
F_SETOWN	设置当前接收SIGIO和SIGURG信号的进程ID和进程组ID

接下来学习驱动程序实现fasync方法

步骤1

当应用程序开启信号驱动IO时，会触发驱动中的fasync函数。所以首先在file_operations结构体中实现fasync函数，函数原型如下：

int (*fasync) (int fd,struct file *filp,int on)

步骤2

在驱动中的fasync函数调用fasync_helper函数来操作fasync_struct结构体，fasync_helper函数原型如下：

int fasync_helper(int fd,struct file *filp,int on,struct fasync_struct
**fapp)

步骤3：

当设备准备好的时候，驱动程序需要调用kill_fasync函数通知应用程序，此时应用程序的SIGIO信号处理函数就会被执行。kill_fasync负责发送指定的信号，函数原型如下：

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

函数参数：

fp: 要操作的fasync_struct

sig: 发送的信号

band: 可读的时候设置成POLLIN ，可写的时候设置成POLLOUT

29.2 实验程序编写

29.2.1 编写测试 APP

本实验对应的应用程序网盘路径为：iTOP-RK3568开发板【底板V1.7版本】\03_【iTOP-RK3568开发板】指南教程\02_Linux驱动配套资料\04_Linux驱动例程\23\app。

编写应用程序write.c，在此代码中，调用write函数向/dev/test设备写入数据“nihao”。编写好的程序如下所示：

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

int main(int argc, char *argv[])  
{
    int fd;
    char buf1[32] = {0};   
    char buf2[32] = "nihao";
    fd = open("/dev/test",O_RDWR);  //打开/dev/test设备
    if (fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    printf("write before \n");
    write(fd,buf2,sizeof(buf2));  //向/dev/test文件写入数据
    printf("write after\n");
    close(fd);     //关闭文件
    return 0;
}

然后来编写应用程序read.c，在此代码中要使用信号驱动IO读取数据。编写好的应用程序如下所示：

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

int fd;
char buf1[32] = {0};   


//SIGIO信号的信号处理函数
static void func(int signum)
{
    read(fd,buf1,32);
    printf ("buf is %s\n",buf1);
}
int main(int argc, char *argv[])  
{
    int ret;
    int flags;
       fd = open("/dev/test", O_RDWR);  //打开led驱动
    if (fd < 0)
    {
        perror("open error \n");
        return fd;
    }

    signal(SIGIO,func);  //步骤一：使用signal函数注册SIGIO信号的信号处理函数
     //步骤二：设置能接收这个信号的进程
     //fcntl函数用来操作文件描述符，
     //F_SETOWN 设置当前接收的SIGIO的进程ID
     fcntl(fd,F_SETOWN,getpid()); 

    flags = fcntl(fd,F_GETFD); //获取文件描述符标志
    //步骤三  开启信号驱动IO 使用fcntl函数的F_SETFL命令打开FASYNC标志
    fcntl(fd,F_SETFL,flags| FASYNC);
    while(1);    
    close(fd);     //关闭文件
    return 0;
}

29.2.2 驱动程序编写

本实验对应的驱动程序网盘路径为：iTOP-RK3568开发板【底板V1.7版本】\03_【iTOP-RK3568开发板】指南教程\02_Linux驱动配套资料\04_Linux驱动例程\23\module。

接下来编写驱动程序，在29.1小节中介绍了驱动程序中实现fasync方法的三个步骤，按照这个思路，依次实现这三步，编写好的驱动程序如下所示：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include  <linux/wait.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/signal.h>

struct device_test{
   
    dev_t dev_num;  //设备号
     int major ;  //主设备号
    int minor ;  //次设备号
    struct cdev cdev_test; // cdev
    struct class *class;   //类
    struct device *device; //设备
    char kbuf[32];
    int  flag;  //标志位
    struct fasync_struct *fasync;
};


struct  device_test dev1;  

DECLARE_WAIT_QUEUE_HEAD(read_wq); //定义并初始化等待队列头

/*打开设备函数*/
static int cdev_test_open(struct inode *inode, struct file *file)
{
    file->private_data=&dev1;//设置私有数据
   
    return 0;
}

/*向设备写入数据函数*/
static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
     struct device_test *test_dev=(struct device_test *)file->private_data;

    if (copy_from_user(test_dev->kbuf, buf, size) != 0) // copy_from_user:用户空间向内核空间传数据
    {
        printk("copy_from_user error\r\n");
        return -1;
    }
    test_dev->flag=1;
    wake_up_interruptible(&read_wq);
    kill_fasync(&test_dev->fasync,SIGIO,POLLIN);
    

    return 0;
}

/**从设备读取数据*/
static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
    
    struct device_test *test_dev=(struct device_test *)file->private_data;
    if(file->f_flags & O_NONBLOCK ){
        if (test_dev->flag !=1)
        return -EAGAIN;
    }
    wait_event_interruptible(read_wq,test_dev->flag);

    if (copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf)) != 0) // copy_to_user:内核空间向用户空间传数据
    {
        printk("copy_to_user error\r\n");
        return -1;
    }

    return 0;
}

static int cdev_test_release(struct inode *inode, struct file *file)
{
    
    return 0;
}

static  __poll_t  cdev_test_poll(struct file *file, struct poll_table_struct *p){
     struct device_test *test_dev=(struct device_test *)file->private_data;  //设置私有数据
     __poll_t mask=0;    
     poll_wait(file,&read_wq,p);     //应用阻塞

     if (test_dev->flag == 1)    
     {
         mask |= POLLIN;
     }
     return mask;
     
}

static int cdev_test_fasync (int fd, struct file *file, int on)
{
     struct device_test *test_dev=(struct device_test *)file->private_data;  //设置私有数据
    return  fasync_helper(fd,file,on,&test_dev->fasync);
}
/*设备操作函数*/
struct file_operations cdev_test_fops = {
    .owner = THIS_MODULE, //将owner字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
    .open = cdev_test_open, //将open字段指向chrdev_open(...)函数
    .read = cdev_test_read, //将open字段指向chrdev_read(...)函数
    .write = cdev_test_write, //将open字段指向chrdev_write(...)函数
    .release = cdev_test_release, //将open字段指向chrdev_release(...)函数
    .poll = cdev_test_poll,  //将poll字段指向chrdev_poll(...)函数
    .fasync = cdev_test_fasync,   //将fasync字段指向cdev_test_fasync(...)函数
};

static int __init chr_fops_init(void) //驱动入口函数
{
    /*注册字符设备驱动*/
    int ret;
    /*1 创建设备号*/
    ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "alloc_name"); //动态分配设备号
    if (ret < 0)
    {
       goto err_chrdev;
    }
    printk("alloc_chrdev_region is ok\n");

    dev1.major = MAJOR(dev1.dev_num); //获取主设备号
   dev1.minor = MINOR(dev1.dev_num); //获取次设备号

    printk("major is %d \r\n", dev1.major); //打印主设备号
    printk("minor is %d \r\n", dev1.minor); //打印次设备号
     /*2 初始化cdev*/
    dev1.cdev_test.owner = THIS_MODULE;
    cdev_init(&dev1.cdev_test, &cdev_test_fops);

    /*3 添加一个cdev,完成字符设备注册到内核*/
   ret =  cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
    if(ret<0)
    {
        goto  err_chr_add;
    }
    /*4 创建类*/
  dev1. class = class_create(THIS_MODULE, "test");
    if(IS_ERR(dev1.class))
    {

        ret=PTR_ERR(dev1.class);
        goto err_class_create;
    }
    /*5  创建设备*/
  dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "test");
    if(IS_ERR(dev1.device))
    {
        ret=PTR_ERR(dev1.device);
        goto err_device_create;
    }

return 0;

 err_device_create:
        class_destroy(dev1.class);                 //删除类

err_class_create:
       cdev_del(&dev1.cdev_test);                 //删除cdev

err_chr_add:
        unregister_chrdev_region(dev1.dev_num, 1); //注销设备号

err_chrdev:
        return ret;
}
static void __exit chr_fops_exit(void) //驱动出口函数
{
    /*注销字符设备*/
    unregister_chrdev_region(dev1.dev_num, 1); //注销设备号
    cdev_del(&dev1.cdev_test);                 //删除cdev
    device_destroy(dev1.class, dev1.dev_num);       //删除设备
    class_destroy(dev1.class);                 //删除类
}
module_init(chr_fops_init);
module_exit(chr_fops_exit);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("topeet");

29.3 运行测试

29.3.1 编译程序

在上一小节中的fasync.c代码同一目录下创建 Makefile 文件，Makefile 文件内容如下所示：

export ARCH=arm64#设置平台架构
export CROSS_COMPILE=aarch64-linux-gnu-#交叉编译器前缀
obj-m +=fasync.o    #此处要和你的驱动源文件同名
KDIR :=/home/topeet/Linux/linux_sdk/kernel    #这里是你的内核目录                                                                                                                            
PWD ?= $(shell pwd)
all:
    make -C $(KDIR) M=$(PWD) modules    #make操作
clean:
    make -C $(KDIR) M=$(PWD) clean    #make clean操作

对于Makefile的内容注释已在上图添加，保存退出之后，来到存放fasync.c.c和Makefile文件目录下，如下图（图 29-2）所示：

图 29-2

然后使用命令“make”进行驱动的编译，编译完成如下图（图29-3）所示：

编译完生成fasync.ko目标文件，如下图（图 29-4）所示：

至此驱动模块就编译成功了，下面进行交叉编译应用程序。

29.3.2 编译应用程序

来到存放应用程序read.c和write.c的文件夹下，使用以下命令对read.c和write.c进行交叉编译，编译完成如下图（图 29-5）所示：

aarch64-linux-gnu-gcc -o read read.c -static

aarch64-linux-gnu-gcc -o write write.c -static

生成的read write文件就是之后放在开发板上运行的可执行文件，至此应用程序的编译就完成了。

29.3.3 测试

输入以下命令加载驱动程序。

insmod fasync.ko

输入以下命令运行read应用程序，如下图（图 29-7）所示：

然后输入以下命令运行write应用程序，如下图（图 29-8）所示：

如下图（图29-9）所示，read程序窗口打印读取的数据。