之前，获取按键值的方式都是应用程序主动去查询，无论是 poll 机制还是阻塞的 read，那么，另外一种思路就是让驱动程序来通知应用程序，而不让他自己去查询，那么这样做的好处就是不会干扰到应用程序的工作，只需要等具体的事情发生了再去处理即可。
- 应用程序从硬件获取信息主要有三种方式：
- 死循环read：耗费资源严重，无意义
- read + wait_event_interruptible
- poll + read
关于异步通知，会用到信号的概念，可以参考我之前的文章，来看如何发送和接收信号的。
->《Linux 信号（signal）》
那么发送和接收信号，有几个要素必须成立，在这里简单归纳：
- 接受者注册信号处理函数 （等于signal 或 sigaction 函数）
- 接收者需要告诉自己的 PID （等于 ps 命令来获取 pid）
- 发送者需要知道接受者是谁（kill 命令中输入的 pid ）
- 发送者要发送信号（kill 命令发送信号或者 kill 函数、sigqueue 函数发送信号）
了解了以上几个要点，现在可以理一下具体的思路了。
目标：按下按键时，驱动程序通过发送信号的方式通知应用程序状态发生了变化，可以去读取相应的数据了。
那么应用程序是接收者，驱动程序是发送者，他们分别都需要做哪些工作呢？
- 应用程序作为 接收者 需要：
将自己的 PID 告诉驱动程序，并且注册某种信号的捕捉函数 - 驱动程序作为 发送者 需要：
将信号发送到应用程序（PID），发送信号
根据信号的开发经验，我们知道对于信号的发送函数无论是 kill 还是 sigqueue 函数都是实际都是综合发送者的两个要素的，通过这个函数既可以告诉内核接收者的 pid，调用的同时也发送了具体的信号。那么驱动程序是不是也是通过这样的方式来发送信号呢？
发送的几个要素肯定都要完成，但是其中问题就出现在，发送者需要知道接受者是谁，往往驱动程序是先于应用程序完成开发的，那么，在获取应用程序的 PID 环节肯定需要一套应用程序向驱动程序注册的机制。
驱动程序发送信号的具体流程如下：
- 定义一个全局静态变量指针
static struct fasync_struct ＊xxx_async_queue - 在
struct file_operations结构体中，注册fasync成员，他的函数指针类型为：int (*fasync) (int, struct file *, int);，定义该函数 - 在 fasync 函数中，使用
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)函数对全局静态的变量进行初始化，以上的步骤就是为了方便应用程序向驱动程序注册 PID 的 - 使用函数
void kill_fasync(struct fasync_struct **fp, int sig, int band)在需要发送信号的地方进行调用，调用时，指定了发送信号的类型，一般驱动程序常用的信号类型是 SIGIO，bind 是 POLL_IN 代表，应用程序可以读取数据了。
那么应用程序，想要接受驱动程序发送的信号，需要做以下的工作：
-
signal(SIGIO, signal_fun);：注册新号捕捉函数 -
fcntl(fd, F_SETOWN, getpid());：设置文件描述符 fd 接收进程或者进程组接收 SIGIO 或 SIGURG 信号。 -
oflags = fcntl(fd, F_GETFL);//获取文件描述符的 flag -
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);
}
那么现在基本上完成了字符设备的驱动程序的编写，还存在一些小问题，在下次来解决吧。
