关于_linux外部中断驱动异步通知应用程序

1，file 1,-> ent_test.c

file ent_test.c
Copyright by jiangdou QQ:344283973
RK3188 ENT test 20140902
how to compile: $ arm-linux-gnueabihf-gcc -o ent_test ENT_test.c -static
*/

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

    printf("by jiangdou............\n");

}

int main(void)
{
unsigned char key_val;
int ret;
int Oflags;
signal(SIGIO, my_signal_fun);
fd = open("/dev/key", O_RDWR);
if (fd < 0)
{
printf(“can’t open!\n”);
}
ret = fcntl(fd, F_SETOWN, getpid());
if(ret < 0)
{
printf(“can’t fcntl_1!\n”);
}

    Oflags = fcntl(fd, F_GETFL); 
    printf("Oflags is : %d\n", Oflags);//is 2
    if(Oflags < 0)
    {
            printf("can't fcntl_2!\n");
    }
    ret = fcntl(fd, F_SETFL, Oflags | FASYNC);
    if(ret < 0)
    {
            printf("can't fcntl_3!\n");
    }
    while (1)
    {
            sleep(1000);
    }
    
    return 0;

}

2,file 2,-> irq_.c

file ent_test.c
Driver for irq on GPIO lines capable of generating interrupts.
Copyright by jiangdou

#include <linux/module.h>

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/adc.h>

#include <asm/gpio.h>
#include <mach/board.h>
#include <plat/key.h>
#include <linux/poll.h>

static struct class *keydrv_class;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static struct fasync_struct *button_async;

//static volatile int ev_press = 0;

#define ENT0 RK30_PIN1_PB7
#define GPIO_IRQ 207

static irqreturn_t irq_isr(int irq, void *dev_id)
{
//printk(“jiangdou…irq_isr…\n”);

    ev_press = 1;

wake_up_interruptible(&button_waitq);  

    
    kill_fasync(&button_async, SIGIO, POLL_IN);
    
    return IRQ_RETVAL(IRQ_HANDLED);
    
    //return 0;

}

static int irq_open(struct inode*inode, struct file *file)
{
int error;

    printk("jiangdou....irq_open...\n");
    if(gpio_request(ENT0,NULL) != 0){
  gpio_free(ENT0);
  printk("gpio_request error\n");
  return -EIO;
}
    error = request_irq(GPIO_IRQ, irq_isr, IRQF_TRIGGER_FALLING, "irq_dou", 1);
    if(error){
            printk("failed to register irq_isr interrupt\n");
    }
    return error;

}

int irq_close(struct inode *inode,struct file *file)
{
free_irq(GPIO_IRQ,1);
return 0;
}

static unsigned irq_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 irq_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 irq_drv_fops= {

    .owner        =        THIS_MODULE,    
    .open        =        irq_open,             
    .release        =        irq_close,
    //.fasync         =  irq_fasync,
    //.poll    =  irq_poll,

};

int major;

static int irq_init(void)
{
printk(“jiangdou…irq_init…\n”);
major = register_chrdev(0, “irq_drv”, &irq_drv_fops);
keydrv_class = class_create(THIS_MODULE,“irq_drv”);
device_create(keydrv_class,NULL,MKDEV(major,0),NULL,“key”);

    return 0;

}
static void irq_drv_exit(void)

{
unregister_chrdev(major, “irq_drv”);
device_destroy(keydrv_class,MKDEV(major,0));
class_destroy(keydrv_class);

}

module_init(irq_init);

module_exit(irq_drv_exit);

MODULE_LICENSE(“GPL”);

来源：CSDN

作者：“资深“码农

链接：https://blog.csdn.net/weixin_44936219/article/details/103501124

标签

外部中断

linux系统