第5个驱动程序_异步通知读取按键

目的：

前面讲了3中读取按键的方式
（1）查询方式： CPU一直在查询按键的状态值。
（2）中断方式： 按键按下触发中断，返回按键值；如果按键没按下，则read函数将进入休眠，一直不返回。---> 阻塞的方式
（3）poll机制 +中断方式： 在（2）的基础上加入poll机制，设定了一个超时时间。即如果没有按键被按下，但是到了超时时间，也需要返回。--> 非阻塞方式
这三种方式，都需要由应用程序不断的去查询是不是有按键被按下（在POLL机制中，是在超时时间里面进行查询按键值）。
有没有一种方式，是按键被按下的时候，驱动主动发送一个通知到应用程序，表示它按下了，赶紧过来处理了。这有点类似于“中断”的工作方式，而不需要在应用程序里一直查询这个按键的状态。当然有，这就是异步通知。
【点击：异步通知原理】

本节目标：按下按键时，驱动主动去通知应用程序。

问：如何实现异步通知，有哪些要素？

答：有四个要素：

一、应用程序要实现有：注册信号处理函数，使用signal函数

二、谁来发？驱动来发

三、发给谁？发给应用程序，但应用程序必须告诉驱动PID

四、怎么发？驱动程序使用kill_fasync函数

问：应该在驱动的哪里调用kill_fasync函数？

答：kill_fasync函数的作用是，当有数据时去通知应用程序，理所当然的应该在用户终端处理函数里调用。

问：file_operations需要添加什么函数指针成员吗？

答：要的，需要添加fasync函数指针，要实现这个函数指针，幸运的是，这个函数仅仅调用了fasync_helper函数，而且这个函数是内核帮我们实现好了，驱动工程师不用修改，fasync_helper函数的作用是初始化/释放fasync_struct

---

---

---

---

1. 硬件连接图
2. 驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.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>


static struct class *fifthdrv_class;
static struct class_device    *fifthdrv_class_dev;

volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;

volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;


static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，fifth_drv_read将它清0 */
static volatile int ev_press = 0;

static struct fasync_struct *button_async;


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


/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

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


/*
  * 确定按键值
  */
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;
    }

    ev_press = 1; /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */

    // 在中断里面，发送SIGIO信号，通知应用程序。
    kill_fasync (&button_async, SIGIO, POLL_IN);

    return IRQ_RETVAL(IRQ_HANDLED);
}

static int fifth_drv_open(struct inode *inode, struct file *file)
{
    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    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;
}

ssize_t fifth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    /* 如果没有按键动作, 休眠 */
    wait_event_interruptible(button_waitq, ev_press);

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;

    return 1;
}


int fifth_drv_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 unsigned fifth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (ev_press)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}


// 这个函数在什么时候被调用呢？？？？     必须要自己定义的函数。
static int fifth_drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: fifth_drv_fasync\n");
    return fasync_helper (fd, filp, on, &button_async);
}


static struct file_operations sencod_drv_fops = {
    .owner   = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    = fifth_drv_open,
    .read    = fifth_drv_read,
    .release = fifth_drv_close,
    .poll    = fifth_drv_poll,
    .fasync  = fifth_drv_fasync,
};


int major;
static int fifth_drv_init(void)
{
    major = register_chrdev(0, "fifth_drv", &sencod_drv_fops);

    fifthdrv_class = class_create(THIS_MODULE, "fifth_drv");
    fifthdrv_class_dev = class_device_create(fifthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

    gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
    gpfdat = gpfcon + 1;

    gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
    gpgdat = gpgcon + 1;

    return 0;
}

static void fifth_drv_exit(void)
{
    unregister_chrdev(major, "fifth_drv");
    class_device_unregister(fifthdrv_class_dev);
    class_destroy(fifthdrv_class);
    iounmap(gpfcon);
    iounmap(gpgcon);
    return 0;
}


module_init(fifth_drv_init);
module_exit(fifth_drv_exit);
MODULE_LICENSE("GPL");

3. 测试程序

#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>


/* fifthdrvtest
  */
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;

    /**
       void (*signal(int signum,void(* handler)(int)))(int);
    *  第一个参数signum指明了所要处理的信号类型
    *  第二个参数handler描述了与信号关联的动作
    **/
    signal(SIGIO, my_signal_fun);    // 驱动程序里面，当有按键按下时，发送一个SIGIO信号，应用程序调用回调函数my_signal_fun

    fd = open("/dev/buttons", O_RDWR);
    if (fd < 0)
    {
        printf("can't open!\n");
    }

    fcntl(fd, F_SETOWN, getpid());  //指定当前进程作为文件fd（设备文件）的owner，目的是让内核（内核操作设备文件）知道应该通知那个进程
    Oflags = fcntl(fd, F_GETFL);          //获取标志位
    fcntl(fd, F_SETFL, Oflags | FASYNC);  //启用异步通知机制


    while (1)
    {
        sleep(1000);
    }

    return 0;
}

表头文件#include

功 能：设置某一信号的对应动作

函数原型：void (*signal(int signum,void(* handler)(int)))(int);

或者：typedef void (*sig_t)( int );

sig_t signal(int signum,sig_t handler);

参数说明：

第一个参数signum指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。

第二个参数handler描述了与信号关联的动作，它可以取以下三种值：

（1）一个无返回值的函数地址

此函数必须在signal()被调用前申明，handler中为这个函数的名字。当接收到一个类型为signum的信号时，就执行handler 所指定的函数。这个函数应有如下形式的定义：

void func(int sig);

（2）SIG_IGN

这个符号表示忽略该信号，执行了相应的signal()调用后，进程会忽略类型为sig的信号。

（3）SIG_DFL

这个符号表示恢复系统对信号的默认处理。

函数说明：

signal()会依参数signum 指定的信号编号来设置该信号的处理函数。当指定的信号到达时就会跳转到参数handler指定的函数执行。当一个信号的信号处理函数执行时，如果进程又接 收到了该信号，该信号会自动被储存而不会中断信号处理函数的执行，直到信号处理函数执行完毕再重新调用相应的处理函数。但是如果在信号处理函数执行时进程 收到了其它类型的信号，该函数的执行就会被中断。

返回值：返回先前的信号处理，如果有错误则返回SIG_ERR(-1)。

下面的情况可以产生Signal：

1. 按下CTRL+C产生SIGINT
2. ，如除0，非法内存访问（SIGSEV）等等
3. Kill函数可以对进程发送Signal
4. Kill命令。实际上是对Kill函数的一个包装
5. 软件中断。如当Alarm Clock超时（SIGURG），当Reader中止之后又向管道写数据（SIGPIPE），等等

4. 测试

5. 小结

异步通知的方式：从驱动发送信号到应用层。和前面的实现方式都不同。

（1）目标：
     按下按键，驱动程序通知应用程序。

（2）涉及的知识点：

（1）应用程序： 注册信号处理函数
（2）谁发新号： 驱动
（3）发给谁：应用程序（驱动程序<-->应用程序PID）
（4）怎么发？ kill_fasyn()函数（源码里面找）

（3）具体实现：

为了使设备支持异步通知机制，驱动程序中涉及以下3项工作：

1. 支持F_SETOWN命令，能在这个控制命令处理中设置filp->f_owner为对应进程ID。
   不过此项工作已由内核完成，设备驱动无须处理。
2. 支持F_SETFL命令的处理，每当FASYNC标志改变时，驱动程序中的fasync()函数将得以执行（驱动中构造fasync()函数函数的原因）。
   驱动中应该实现fasync()函数。
3. 在设备资源可获得时，调用kill_fasync()函数激发相应的信号

应用程序：

fcntl(fd, F_SETOWN, getpid());  // 告诉内核，发给谁
Oflags = fcntl(fd, F_GETFL);   
fcntl(fd, F_SETFL, Oflags | FASYNC);  // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct