嵌入式Linux驱动开发(六)——异步通知

字数 1179阅读 289

之前,获取按键值的方式都是应用程序主动去查询,无论是 poll 机制还是阻塞的 read,那么,另外一种思路就是让驱动程序来通知应用程序,而不让他自己去查询,那么这样做的好处就是不会干扰到应用程序的工作,只需要等具体的事情发生了再去处理即可。

  • 应用程序从硬件获取信息主要有三种方式:
    • 死循环read:耗费资源严重,无意义
    • read + wait_event_interruptible
    • poll + read

关于异步通知,会用到信号的概念,可以参考我之前的文章,来看如何发送和接收信号的。
->《Linux 信号(signal)》

那么发送和接收信号,有几个要素必须成立,在这里简单归纳:

  1. 接受者注册信号处理函数 (等于signal 或 sigaction 函数)
  2. 接收者需要告诉自己的 PID (等于 ps 命令来获取 pid)
  3. 发送者需要知道接受者是谁(kill 命令中输入的 pid )
  4. 发送者要发送信号(kill 命令发送信号或者 kill 函数、sigqueue 函数发送信号)

了解了以上几个要点,现在可以理一下具体的思路了。
目标:按下按键时,驱动程序通过发送信号的方式通知应用程序状态发生了变化,可以去读取相应的数据了。
那么应用程序是接收者,驱动程序是发送者,他们分别都需要做哪些工作呢?

  • 应用程序作为 接收者 需要:
    将自己的 PID 告诉驱动程序,并且注册某种信号的捕捉函数
  • 驱动程序作为 发送者 需要:
    将信号发送到应用程序(PID),发送信号

根据信号的开发经验,我们知道对于信号的发送函数无论是 kill 还是 sigqueue 函数都是实际都是综合发送者的两个要素的,通过这个函数既可以告诉内核接收者的 pid,调用的同时也发送了具体的信号。那么驱动程序是不是也是通过这样的方式来发送信号呢?
发送的几个要素肯定都要完成,但是其中问题就出现在,发送者需要知道接受者是谁,往往驱动程序是先于应用程序完成开发的,那么,在获取应用程序的 PID 环节肯定需要一套应用程序向驱动程序注册的机制。

驱动程序发送信号的具体流程如下:

  1. 定义一个全局静态变量指针static struct fasync_struct *xxx_async_queue
  2. struct file_operations结构体中,注册fasync成员,他的函数指针类型为:int (*fasync) (int, struct file *, int);,定义该函数
  3. 在 fasync 函数中,使用int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)函数对全局静态的变量进行初始化,以上的步骤就是为了方便应用程序向驱动程序注册 PID 的
  4. 使用函数void kill_fasync(struct fasync_struct **fp, int sig, int band)在需要发送信号的地方进行调用,调用时,指定了发送信号的类型,一般驱动程序常用的信号类型是 SIGIO,bind 是 POLL_IN 代表,应用程序可以读取数据了。

那么应用程序,想要接受驱动程序发送的信号,需要做以下的工作:

  1. signal(SIGIO, signal_fun);:注册新号捕捉函数
  2. fcntl(fd, F_SETOWN, getpid());:设置文件描述符 fd 接收进程或者进程组接收 SIGIO 或 SIGURG 信号。
  3. oflags = fcntl(fd, F_GETFL);//获取文件描述符的 flag
  4. fcntl(fd, F_SETFL, oflags | FASYNC);:将文件描述符设置为FASYNC模式

ps:发送和接收信号驱动程序和应用程序的流程已完成了,那么系统帮我们完成了一件事,就是让驱动程序知道应该把信号发送到哪个PID,实际这个阶段是内核通过设置结构体中的变量来完成的:fasync_struct->fa_file->f_owner->pid,这一步内核完成了,无需驱动程序来完成了,只需要调用fasync_helper函数初始化即可。

那么,Show me the code!
驱动程序:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <asm/irq.h>

#include <asm/signal.h>


#define EINT_PIN_COUNT 4

static const char* dev_name = "fasync_eint";
static volatile unsigned int major = 0;

static struct class* fasync_class;
static struct class_device* fasync_class_device;

struct pin_desc
{
    unsigned int pin;
    unsigned int value;
};

//%kernel%\include\asm-arm\arch\irqs.h
//#define IRQ_EINT0      S3C2410_IRQ(0)     /* 16 */
//中断号数组
static const int eints[EINT_PIN_COUNT] =
{
    IRQ_EINT0,
    IRQ_EINT2,
    IRQ_EINT11,
    IRQ_EINT19
};

static struct pin_desc pins[4] =
{
    {S3C2410_GPF0,  0x1},
    {S3C2410_GPF2,  0x2},
    {S3C2410_GPG3,  0x3},
    {S3C2410_GPG11, 0x4},
};

unsigned int status = 0;
unsigned char value = 0;
static struct fasync_struct * fs;
static irqreturn_t irq_handler(int irq, void *dev_id)
{
    struct pin_desc* desc = (struct pin_desc*) dev_id;
    status = s3c2410_gpio_getpin(desc->pin);
    if(status)
        value = desc->value | 0x80;
    else
        value = desc->value;
    
    //void kill_fasync(struct fasync_struct **fp, int sig, int band)
    kill_fasync(&fs, SIGIO, POLL_IN);
    
    return 0;
}


static ssize_t fasync_read (struct file *file, char __user *buff, size_t size, loff_t *ppos)
{
    copy_to_user(buff, &value, 1);
    
    return 0;
}



static int fasync_open (struct inode *inode, struct file *file)
{
    int i;
    for(i = 0; i < EINT_PIN_COUNT; ++i){
        request_irq(eints[i], irq_handler, IRQT_BOTHEDGE, dev_name, &pins[i]);
    }
    printk("interrupt register\n");

    return 0;
}


int fasync_fasync (int fd, struct file * filp, int on)
{
    //int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
    fasync_helper(fd, filp, on, &fs);
    return 0;
}

static int fasync_release (struct inode *inode, struct file *file)
{
    //void free_irq(unsigned int irq, void *dev_id)
    int i = 0;
    for(;i < EINT_PIN_COUNT; ++i){
        free_irq(eints[i], &pins[i]);
    }
    
    printk("button released\n");
    return 0;
}

struct file_operations fasync_fops = 
{
    .owner = THIS_MODULE,
    .open = fasync_open,
    .read = fasync_read,
    .fasync = fasync_fasync,
    .release = fasync_release,
};

static int __init fasync_init(void)
{
    major = register_chrdev(major, dev_name, &fasync_fops);
    fasync_class = class_create(THIS_MODULE, dev_name);
    fasync_class_device = class_device_create(fasync_class, NULL, MKDEV(major, 0), NULL, dev_name);
    printk("init\n");
    return 0;
}

static void __exit fasync_exit(void)
{
    unregister_chrdev(major, dev_name);
    class_device_unregister(fasync_class_device);
    class_destroy(fasync_class);
    printk("exit\n");
}

module_init(fasync_init);
module_exit(fasync_exit);

MODULE_AUTHOR("Ethan Lee <4128127@qq.com>");
MODULE_LICENSE("GPL");

应用程序:

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

void signal_fun(int signum);

int fd;

int main()
{
    fd = open("/dev/fasync_eint", O_RDWR);
    int oflags;
    if(fd < 0)
    {
        printf("open error\n");
        return -1;
    }
    
    signal(SIGIO, signal_fun);//注册捕捉函数
    
    fcntl(fd, F_SETOWN, getpid());//设置文件描述符 fd 接收进程或者进程组接收 SIGIO 或 SIGURG 信号。
    oflags = fcntl(fd, F_GETFL);//获取 flag
    fcntl(fd, F_SETFL, oflags | FASYNC);//原来 flag或上 FASYNC,并设置 flag
    //将 fd 设置为 FASYNC 方式打开
    //该设置,会触发驱动程序中`file_operations`中注册的 fasync 函数。
    //驱动程序中,该函数调用了 fasync_helper 函数来初始化了 fasync_struct 结构体。
    //该结构体中维护了要接收信号的进程 PID(fasync_struct->fa_file->f_owner->pid)
    
    
    while(1)
    {
        sleep(1000);
    }
    
    return 0;
}
void signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x\n", key_val);
}

那么现在基本上完成了字符设备的驱动程序的编写,还存在一些小问题,在下次来解决吧。

推荐阅读更多精彩内容