Linux驅動之異步通知的應用

前面的按鍵驅動方式都是應用程序通過主動查詢的方式獲得按鍵值的：

1、查詢方式

2、中斷方式

3、poll機制

下面介紹第四種按鍵驅動的方式

4、異步通知：它可以做到應用程序不用隨時去查詢按鍵的狀態，而等待有按鍵被按下后，驅動程序主動發消息給應用程序，應用程序再去處理。

比如說:kill -9 pid即是一種發信號的過程：其中9就是信號值,pid就是被發送的進程的進程號

a、一個簡單的異步通知的例子

b、編寫測試程序實現異步通知

c、更改按鍵驅動實現異步通知

 

1、一個簡單的異步通知的例子

直接看到程序源碼，可以看到這個程序在主程序里面什么事情也沒有做，一直處於睡眠狀態。

#include <signal.h>


void my_signal_test(int signum)
{
    static int cnt = 0;
    printf("signal = %d,%d times\n",signum,++cnt);
}

int main(int argc,char **argv)
{
    signal(SIGUSR1, my_signal_test);//建立一個信號函數，接收的信號是SIGUSR1表示用戶可用的信號值

    while(1)
    {
        sleep(1000);
    }
    return 0;
}

首先這個程序調用了signal這個C庫中的函數，在linux下查詢它的用法輸入man 2 signal

#include <signal.h> //需要包含的頭文件

typedef void (*sighandler_t)(int);//信號函數原型，它的參數是信號值

sighandler_t signal(int signum, sighandler_t handler);//函數，其中signum代表發送的信號值，handler表示信號函數

編譯這個程序，然后在命令行輸入kill -USR1 2333，my_signal函數被運行。

 

 2、更改測試程序實現異步通知

直接看代碼，從代碼可以看出，實現異步通知在應用層需要如下幾步：

1、利用signal(SIGIO, fifth_testsignal)函數注冊一個信號，信號處理的函數為fifth_testsignal。SISGIO說明是IO信號量，因為按鍵驅動屬於IO型的。

2、利用fcntl(fd, F_SETOWN, getpid())函數將本應用程序的進程號告訴給內核，最終使得驅動程序可以成功發送信號給應用程序。

3、利用fcntl(fd, F_SETFL, oflags | FASYNC)函數改變fasync標記，最終會調用到驅動的faync > fasync_helper。

4、signal、與fcntl的系統調用過程比較復雜，后面再去分析。這里只能記住是怎么使用它們來是實現異步通知的功能。

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

static int fd;

static void fifth_testsignal(int signum)
{
    unsigned char key_val;
    
    printf("signal = %d\n",signum);

    read(fd, &key_val, 1);//讀取按鍵數據，只有收到按鍵數據驅動層才會發送消息給應用層。
         printf("signumkey_val: 0x%x\n\n",key_val);
}

/*
  *usage ./buttonstest
  */
int main(int argc, char **argv)
{
    char* filename="dev/buttons";
   int oflags;

    
    fd = open(filename, O_RDWR);//打開dev/firstdrv設備文件
    if (fd < 0)//小於0說明沒有成功
    {
        printf("error, can't open %s\n", filename);
        return 0;
    }
    
    if(argc !=1)
    {
        printf("Usage : %s ",argv[0]);
     return 0;
    }
    signal(SIGIO, fifth_testsignal);//注冊一個信號，函數為fifth_testsignal
    
    fcntl(fd, F_SETOWN, getpid());  // 告訴內核，發給誰
    
    oflags = fcntl(fd, F_GETFL); //取得當前的狀態
    
    fcntl(fd, F_SETFL, oflags | FASYNC);  // 改變fasync標記，最終會調用到驅動的faync > fasync_helper：初始化/釋放fasync_struct
    
  while(1)
  {
    sleep(1000);
  }
    
   return 0;
}

 

 3、更改按鍵驅動實現異步通知功能

與原先的按鍵驅動程序相比：

1、定義fasync_struct結構

struct fasync_struct *fifth_fasync;//定義fasync_struct結構

2、在fifth_drv_ops 結構體中增加fifth_drv_fasync異步通知處理函數

static struct file_operations fifth_drv_ops = 
{
    .owner   = THIS_MODULE,
    .open    =  fifth_drv_open,
    .read     = fifth_drv_read,
    .release = fifth_drv_close,
    .poll      =  fifth_drv_poll,
    .fasync   = fifth_drv_fasync,//增加異步通知處理的函數
    
};

3、編寫fifth_drv_fasync異步通知處理函數，這個函數會在C庫函數fcntl設置FASYNC時被調用

static int fifth_drv_fasync(int fd, struct file * file, int on)
{
    int err;
    printk("fansync_helper\n");
    err = fasync_helper(fd, file, on, &fifth_fasync);//利用fasync_helper初始化fifth_fasync
    if (err < 0)
        return err;
    return 0;
}

下面是完整的代碼

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <asm/io.h>        //含有iomap函數iounmap函數
#include <asm/uaccess.h>//含有copy_from_user函數
#include <linux/device.h>//含有類相關的處理函數
#include <asm/arch/regs-gpio.h>//含有S3C2410_GPF0等相關的
#include <linux/irq.h>    //含有IRQ_HANDLED\IRQ_TYPE_EDGE_RISING
#include <asm-arm/irq.h>   //含有IRQT_BOTHEDGE觸發類型
#include <linux/interrupt.h> //含有request_irq、free_irq函數
#include <linux/poll.h>
//#include <asm-arm\arch-s3c2410\irqs.h>



static struct class *fifth_drv_class;//類
static struct class_device *fifth_drv_class_dev;//類下面的設備
static int fifthmajor;

static unsigned long *gpfcon = NULL;
static unsigned long *gpfdat = NULL;
static unsigned long *gpgcon = NULL;
static unsigned long *gpgdat = NULL;

struct fasync_struct *fifth_fasync;//定義fasync_struct結構
    
static unsigned int key_val;

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

static struct pin_desc  pins_desc[4] = 
{
    {S3C2410_GPF0,0x01},
    {S3C2410_GPF2,0x02},
    {S3C2410_GPG3,0x03},
    {S3C2410_GPG11,0x04}
};


unsigned int ev_press;
DECLARE_WAIT_QUEUE_HEAD(button_waitq);//注冊一個等待隊列button_waitq

 
/*
  *0x01、0x02、0x03、0x04表示按鍵被按下
  */
  
/*
  *0x81、0x82、0x83、0x84表示按鍵被松開
  */

/*
  *利用dev_id的值為pins_desc來判斷是哪一個按鍵被按下或松開
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    unsigned int pin_val;
    struct pin_desc * pin_desc = (struct pin_desc *)dev_id;//取得哪個按鍵被按下的狀態
    
    pin_val = s3c2410_gpio_getpin(pin_desc->pin);
    
    if(pin_val) //按鍵松開
        key_val = 0x80 | pin_desc->key_val;
    else
        key_val = pin_desc->key_val;


    wake_up_interruptible(&button_waitq);   /* 喚醒休眠的進程 */
    ev_press = 1;    
    
    kill_fasync(&fifth_fasync, SIGIO, POLL_IN);//發生信號給進程
    
    return IRQ_HANDLED;
}



static int fifth_drv_open (struct inode * inode, struct file * file)
{
    int ret;
    ret = request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "s1", (void * )&pins_desc[0]);
    if(ret)
    {
        printk("open failed 1\n");
        return -1;
    }
    ret = request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "s2", (void * )& pins_desc[1]);
    if(ret)
    {
        printk("open failed 2\n");
        return -1;
    }
    ret = request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "s3", (void * )&pins_desc[2]);
    if(ret)
    {
        printk("open failed 3\n");
        return -1;
    }
    ret = request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "s4", (void * )&pins_desc[3]);
    if(ret)
    {
        printk("open failed 4\n");
        return -1;
    }
    
    return 0;
}


static int fifth_drv_close(struct inode * inode, struct file * file)
{
    free_irq(IRQ_EINT0 ,(void * )&pins_desc[0]);

     free_irq(IRQ_EINT2 ,(void * )& pins_desc[1]);

    free_irq(IRQ_EINT11 ,(void * )&pins_desc[2]);

    free_irq(IRQ_EINT19 ,(void * )&pins_desc[3]);

    return 0;
}

static ssize_t fifth_drv_read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
{
    int ret;

    if(count != 1)
    {
        printk("read error\n");
        return -1;
    }

//    wait_event_interruptible(button_waitq, ev_press);//將當前進程放入等待隊列button_waitq中
    
    ret = copy_to_user(userbuf, &key_val, 1);
    ev_press = 0;//按鍵已經處理可以繼續睡眠
    
    if(ret)
    {
        printk("copy error\n");
        return -1;
    }
    
    return 1;
}

static unsigned int fifth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int ret = 0;
    poll_wait(file, &button_waitq, wait);//將當前進程放到button_waitq列表

    if(ev_press)
        ret |=POLLIN;//說明有數據被取到了

    return ret;
}



static int fifth_drv_fasync(int fd, struct file * file, int on)
{
    int err;
    printk("fansync_helper\n");
    err = fasync_helper(fd, file, on, &fifth_fasync);//利用fasync_helper初始化fifth_fasync
    if (err < 0)
        return err;
    return 0;
}


static struct file_operations fifth_drv_ops = 
{
    .owner   = THIS_MODULE,
    .open    =  fifth_drv_open,
    .read     = fifth_drv_read,
    .release = fifth_drv_close,
    .poll      =  fifth_drv_poll,
    .fasync   = fifth_drv_fasync,//增加異步通知處理的函數
    
};

static int fifth_drv_init(void)
{
    fifthmajor = register_chrdev(0, "buttons", &fifth_drv_ops);//注冊驅動程序

    if(fifthmajor < 0)
        printk("failes 1 buttons_drv register\n");
    
    fifth_drv_class = class_create(THIS_MODULE, "buttons");//創建類
    if(fifth_drv_class < 0)
        printk("failes 2 buttons_drv register\n");
    fifth_drv_class_dev = class_device_create(fifth_drv_class, NULL, MKDEV(fifthmajor,0), NULL,"buttons");//創建設備節點
    if(fifth_drv_class_dev < 0)
        printk("failes 3 buttons_drv register\n");

    
    gpfcon = ioremap(0x56000050, 16);//重映射
    gpfdat = gpfcon + 1;
    gpgcon = ioremap(0x56000060, 16);//重映射
    gpgdat = gpgcon + 1;

    printk("register buttons_drv\n");
    return 0;
}

static void fifth_drv_exit(void)
{
    unregister_chrdev(fifthmajor,"buttons");

    class_device_unregister(fifth_drv_class_dev);
    class_destroy(fifth_drv_class);

    iounmap(gpfcon);
    iounmap(gpgcon);

    printk("unregister buttons_drv\n");
}


module_init(fifth_drv_init);
module_exit(fifth_drv_exit);

MODULE_LICENSE("GPL");

 

將測試程序與驅動程序編譯后測試成功。以上就是異步通知的應用實現。