学习笔记 --- LINNUX 使用异步通讯机制实现按键驱动代码分析

查询方式，中断方式和poll方式都需要应用程序去查询，而异步通讯机制可以实现驱动主动把事件发送给应用，应用执行相应的处理函数，相当于一个驱动触发一个软中断，由应用区执行，这样的异步机制对于那些系统通知之类的驱动很有用，比如手机没电了，提示充电，这样的通知在异步通讯机制中称为信号；

下面分析这段代码：

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

#define DEVICE_NAME "keys"

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

static struct class *keys_class;
static struct class_device *keys_class_devs;

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

struct pin_desc pins_desc[4] = {
 {S3C2410_GPF0, 0x01},
 {S3C2410_GPF2, 0x02},
 {S3C2410_GPG3, 0x03},
 {S3C2410_GPG11, 0x04},
};
static struct fasync_struct *button_async;
static unsigned char key_val;
static irqreturn_t buttons_irq(int irq, void *dev_id) 
{
    struct pin_desc * pindesc = (struct pin_desc *)dev_id;
    unsigned int pinval;
    pinval = s3c2410_gpio_getpin(pindesc->pin);
    if (pinval)
 {  
  key_val = 0x80 | pindesc->key_val;
 }
 else
 {
  key_val = pindesc->key_val;
 }
    kill_fasync (&button_async, SIGIO, POLL_IN);    //发送异步通知，类型为信号
    return IRQ_RETVAL(IRQ_HANDLED);
}

static int s3c24xx_keys_open(struct inode *inode, struct file *file)
{
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2",&pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3",&pins_desc[1]);
    request_irq(IRQ_EINT11,buttons_irq, IRQT_BOTHEDGE, "S4",&pins_desc[2]);
    request_irq(IRQ_EINT19,buttons_irq, IRQT_BOTHEDGE, "S5",&pins_desc[3]);
    return 0;
}

static int s3c24xx_keys_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
{
       copy_to_user(buff, &key_val, 1);
        return 1;
}


int s3c24xx_keys_close(struct inode *inode, struct file *file)
{
    free_irq(IRQ_EINT0,  &pins_desc[0]);
    free_irq(IRQ_EINT2,  &pins_desc[1]);
    free_irq(IRQ_EINT11,&pins_desc[2]);
    free_irq(IRQ_EINT19,&pins_desc[3]);
    return 0;
}

static int s3c24xx_keys_fasync(int fd, struct file *filp, int on)
{ 
        printk("driver: fasync test\n");
  return fasync_helper (fd, filp, on, &button_async);      //初始化button_async
}

static struct file_operations s3c24xx_keys_fops = {
    .owner     =   THIS_MODULE,   
    .open       =   s3c24xx_keys_open,     
    .read      = s3c24xx_keys_read,    
    .release   = s3c24xx_keys_close,
    .fasync     =  s3c24xx_keys_fasync,   //应用设置应用进程ID号+设置异步标志后，内核需要调用这个函数，初始化异步button_async
};
int major;
static int __init s3c24xx_keys_init(void)
{
    major=register_chrdev(0, DEVICE_NAME, &s3c24xx_keys_fops); 
    keys_class = class_create(THIS_MODULE, "keys_class");
    keys_class_devs = class_device_create(keys_class, NULL, MKDEV(major, 0), NULL, "keys");
    gpfcon=(volatile unsigned long *)ioremap(0x56000050,16);    //物理地址转换为虚拟地址，再操作
    gpfdat=gpfcon+1;
    gpgcon=(volatile unsigned long *)ioremap(0x56000060,16);
    gpgdat=gpgcon+1;
     printk(DEVICE_NAME " initialized\n");
     return 0;
}

static void __exit s3c24xx_keys_exit(void)
{
    unregister_chrdev(major, DEVICE_NAME);
    class_device_unregister(keys_class_devs);
    class_destroy(keys_class);
    iounmap(gpfcon);
    iounmap(gpgcon);
}
module_init(s3c24xx_keys_init);
module_exit(s3c24xx_keys_exit);
MODULE_LICENSE("GPL");

驱动要做的事情就是：

1  在事件触发之后调用kill_fasync (&button_async, SIGIO, POLL_IN); 向应用发送异步通知，类型为信号

2  实现fasync 函数，初始化信号struct fasync_struct *button_async;  异步结构体，这个供应用初始化异步调用的；驱动开始不知道要把信号发给哪个进程，所以这个结构体里面就包含了这个信息，这个信息是在应用初始化异步后的时候内核调用fasync函数来实现的；

下面看下测试函数：

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

int fd;

void my_signal_fun(int signum)
{
 unsigned char key_val;
 read(fd, &key_val, 1);
 printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
     unsigned char key_val;
 int ret;
 int Oflags;

 signal(SIGIO, my_signal_fun);   //注册信号处理函数，驱动发送信号就会调用这个处理函数
     
 fd = open("/dev/keys", O_RDWR);
 if (fd < 0)
 {
  printf("can't open!\n");
 }
 fcntl(fd, F_SETOWN, getpid());    //告诉内核，要把信号发送自己，即filp->f_owner=getpid();
 Oflags = fcntl(fd, F_GETFL);      //获取当前设备文件标志
 fcntl(fd, F_SETFL, Oflags | FASYNC);  //修改当前设备文件标志添加FASYNC属性，表示使能异步操作，使能后这个函数会调用驱动里面的fasync函数实现初始化fasync_struct 
 while (1)
 {
     sleep(5000);
 }
 return 0;
}

应用与驱动之间传递信息的异步结构体：

struct fasync_struct {
 int magic;
 int fa_fd;
 struct fasync_struct *fa_next; /* singly linked list */
 struct file   *fa_file;
};

可以知道这个里面就存放了应用进程的一些属性。