异步通知

驱动：

/*
 * gpio irq
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>

#define SUCCESS (0)
#define ERROR (-1)

static struct fasync_struct *fasync_queue;

#define IRQ_PIN 115
int flag = 0;

struct cdev *irq_dev;
int major;
static struct class *irq_class;
//static unsigned int irq_num;

int dev_open(struct inode *inode, struct file *filp)
{
    return 0;
}

ssize_t dev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_ops)
{
    return count;
}

ssize_t dev_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_ops)
{
    return count;
}


static irqreturn_t irq_handler(int irq, void *dev)
{
    printk("driver irq work\n");
    if(fasync_queue){
        kill_fasync(&fasync_queue, SIGIO, POLL_IN);
    }

    return IRQ_HANDLED;
}

static int dev_fasync(int fd, struct file *filp, int on)
{
    int retval;
    retval = fasync_helper(fd, filp, on, &fasync_queue);
    if(retval < 0){
        return retval;
    }
    return 0;
}

int dev_release(struct inode *inode, struct file *filp)
{
    dev_fasync(-1, filp, 0);
    return 0;
}

static struct file_operations dev_fops = {
    .owner = THIS_MODULE,
    .open = dev_open,
    .release = dev_release,
    .read = dev_read,
    .write = dev_write,
    .fasync = dev_fasync,
};

static int dev_init(void)
{
    int err;
    major = register_chrdev(0, "irq_dev", &dev_fops);
    if(major < 0){
        printk("Unable to register character device %d\n", major);
        return major;
    }

    irq_class = class_create(THIS_MODULE, "irq_class");
    device_create(irq_class, NULL, MKDEV(major, 0), NULL, "irq_dev");


    printk(KERN_INFO "irq init\n");
    err = gpio_request(IRQ_PIN, "power_down");
    if(err){
        return err;
    }

    err = request_irq(gpio_to_irq(IRQ_PIN), irq_handler, IRQF_TRIGGER_FALLING, "power down", NULL);

    if(err < 0) {
        printk("irq_request failed\n");
        return err;
    }

    printk("module init sucessful !!!\n");
    flag = 1;
    return 0;
}


static void dev_exit(void)
{
    printk(KERN_INFO "gpio irq exit\n");
    unregister_chrdev(major, "irq_dev");
    device_destroy(irq_class, MKDEV(major,0));
    class_destroy(irq_class);

    if(flag){
        free_irq(gpio_to_irq(IRQ_PIN), NULL);
        gpio_free(IRQ_PIN);
    }
    printk("module exit successful !!!\n");
}


module_init(dev_init);
module_exit(dev_exit);

MODULE_LICENSE("Dual BSD/GPL");

测试程序：

/*
 * irq test
 */
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>

static int fd;

void sigterm_handler(int signo)
{
    int i = 0;
    printf("app irq work !!!\n");
    while(1)
    {
        printf("%d do something ...\r", i++);
        fflush(stdout);
        usleep(10000);
    }
}

int main(void)
{
    int i = 0;
    int oflags;
    fd = open("/dev/irq_dev", O_RDWR);
    printf("open fd = %d\n", fd);
    if(fd < 0)
    {
        perror("open");
        return -1;
    }

    signal(SIGIO, sigterm_handler);
    fcntl(fd, F_SETOWN, getpid());

    oflags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, oflags | FASYNC);

    while(1)
    {
        printf("sleep %d\n", i++);
        sleep(1);
    }

    close(fd);
    return 0;
}