查询方式,中断方式和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;
};
可以知道这个里面就存放了应用进程的一些属性。