Linux驱动开发--中断处理原理

已于 2023-06-24 16:50:37 修改
阅读量506 收藏 8
点赞数
文章标签： 驱动开发
于 2023-06-22 14:00:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinqi_1/article/details/131340445
版权

目录

一、什么是中断

二、中断处理原理

三、中断接口

3.1 中断申请

3.2 中断释放

3.3 中断处理函数原型

四、按键驱动

代码示例：

五、中断上半部与下半部

六、下半部机制之tasklet ---- 基于软中断

6.1 结构体

6.2 定义tasklet的中断底半部处理函数

6.3 初始化tasklet

6.4 调度tasklet

6.5 代码示例

七、下半部机制之workqueue ----- 基于内核线程

7.1 工作队列结构体：

7.2 定义工作队列底半部处理函数

7.3 初始化工作队列

7.4 工作队列的调度函数

7.5 代码示例

八、下半部机制比较

一、什么是中断

一种硬件上的通知机制，用来通知CPU发生了某种需要立即处理的事件

分为：

  1. 内部中断 CPU执行程序的过程中，发生的一些硬件出错、运算出错事件（如分母为0、溢出等等），不可屏蔽
  2. 外部中断 外设发生某种情况，通过一个引脚的高、低电平变化来通知CPU （如外设产生了数据、某种处理完毕等等）

二、中断处理原理

任何一种中断产生，CPU都会暂停当前执行的程序，跳转到内存固定位置执行一段程序，该程序被称为总的中断服务程序，在该程序中区分中断源，然后进一步调用该中断源对应的处理函数。

中断源对应的处理函数被称为分中断处理程序，一般每一个分中断处理程序对应一个外设产生的中断

写驱动时，如果外设有中断，则需要编写一个函数（分中断处理程序）来处理这种中断。

三、中断接口

3.1 中断申请

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)
/*
参数：
	irq：所申请的中断号
	handler：该中断号对应的中断处理函数
	flags：中断触发方式或处理方式 
		触发方式：IRQF_TRIGGER_NONE 		//无触发
		 	 	 IRQF_TRIGGER_RISING 	//上升沿触发
			 	 IRQF_TRIGGER_FALLING  //下降沿触发
				IRQF_TRIGGER_HIGH  	//高电平触发
				IRQF_TRIGGER_LOW 		//低电平触发
		处理方式：
			   IRQF_DISABLED		//用于快速中断，处理中屏蔽所有中断
				IRQF_SHARED		  //共享中断
		name：中断名 /proc/interrupts
		dev：传递给中断例程的参数，共享中断时用于区分那个设备，一般为对应设备的结构体地址，无共享中断时写NULL
返回值：成功：0 失败：错误码
*/

3.2 中断释放

void free_irq(unsigned int irq, void *dev_id)；
/*
功能：释放中断号
参数：
	irq：设备号
	dev_id：共享中断时用于区分那个设备一般强转成设备号，无共享中断时写NULL
*/

3.3 中断处理函数原型

typedef irqreturn_t (*irq_handler_t)(int, void *);
/*
参数：
	int：中断号
	void*:对应的申请中断时的dev_id
返回值：
	typedef enum irqreturn irqreturn_t;	//中断返回值类型
	enum irqreturn {
		IRQ_NONE	= (0 << 0),
		IRQ_HANDLED	= (1 << 0),
		IRQ_WAKE_THREAD	= (1 << 1),
	};
	返回IRQ_HANDLED表示处理完了,返回IRQ_NONE在共享中断表示不处理
*/

四、按键驱动

按键原理图：

exynos4412-fs4412.dts中增加节点

mykey2_node {
	compatible = "mykey2,key2";
	key2-gpio = <&gpx1 1 0>;
	interrupt-parent = <&gpx1>;
	interrupts = <1 3>;
};

代码示例：

key.h

#ifndef FS4412_KEY_H
#define FS4412_KEY_H
 
enum KEYCODE
{
    KEY2 = 1002,
    KEY3,
    KEY4,
};
 
enum KEY_STATUS
{
    KEY_DOWN = 0,
    KEY_UP,
};
 
struct keyvalue
{
    int code;//which KEY
    int status;
};
 
#endif

key.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
 
#include "fs4412_key.h"
 
 
int major = 11;
int minor = 0;
int fs4412key2_num  = 1;
 
struct fs4412key2_dev
{
    struct cdev mydev;
 
    int gpio;
    int irqno;
 
    struct keyvalue data;
    int newflag;
    spinlock_t lock;
 
    wait_queue_head_t rq;
};
 
struct fs4412key2_dev *pgmydev = NULL;
 
int fs4412key2_open(struct inode *pnode,struct file *pfile)
{
    pfile->private_data =(void *) (container_of(pnode->i_cdev,struct fs4412key2_dev,mydev));
    return 0;
}
 
int fs4412key2_close(struct inode *pnode,struct file *pfile)
{
 
    return 0;
}
 
ssize_t fs4412key2_read(struct file *pfile,char __user *puser,size_t count,loff_t *p_pos)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    int size = 0;
    int ret = 0;
 
    if(count < sizeof(struct keyvalue))
    {
        printk("expect read size is invalid\n");
        return -1;
    }
 
    spin_lock(&pmydev->lock);
    if(!pmydev->newflag)
    {
        if(pfile->f_flags & O_NONBLOCK)
        {//非阻塞
            spin_unlock(&pmydev->lock);
            printk("O_NONBLOCK No Data Read\n");
            return -1;
        }
        else
        {//阻塞
            spin_unlock(&pmydev->lock);
            ret = wait_event_interruptible(pmydev->rq,pmydev->newflag == 1);
            if(ret)
            {
                printk("Wake up by signal\n");
                return -ERESTARTSYS;
            }
            spin_lock(&pmydev->lock);
        }
    }
 
    if(count > sizeof(struct keyvalue))
    {
        size = sizeof(struct keyvalue);
    }
    else
    {
        size = count;
    }
 
    ret = copy_to_user(puser,&pmydev->data,size);
    if(ret)
    {
        spin_unlock(&pmydev->lock);
        printk("copy_to_user failed\n");
        return -1;
    }
 
    pmydev->newflag = 0;
 
    spin_unlock(&pmydev->lock);
 
    return size;
}
 
unsigned int fs4412key2_poll(struct file *pfile,poll_table *ptb)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    unsigned int mask = 0;
 
    poll_wait(pfile,&pmydev->rq,ptb);
 
    spin_lock(&pmydev->lock);
    if(pmydev->newflag)
    {
        mask |= POLLIN | POLLRDNORM;
    }
    spin_unlock(&pmydev->lock);
 
    return mask;
}
 
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = fs4412key2_open,
    .release = fs4412key2_close,
    .read = fs4412key2_read,
    .poll = fs4412key2_poll,
};
 
irqreturn_t key2_irq_handle(int no,void *arg)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
    int status1 = 0;
    int status2 = 0;
    int status = 0;
 
    status1 = gpio_get_value(pmydev->gpio);
    mdelay(1);
    status2 = gpio_get_value(pmydev->gpio);
 
    if(status1 != status2)
    {
        return IRQ_NONE;
    }
 
    status = status1;
 
    spin_lock(&pmydev->lock);
    if(status == pmydev->data.status)
    {
        spin_unlock(&pmydev->lock);
        return IRQ_NONE;
    }
 
    pmydev->data.code = KEY2;
    pmydev->data.status = status;
    pmydev->newflag = 1;
 
    spin_unlock(&pmydev->lock);
    wake_up(&pmydev->rq);
 
    return IRQ_HANDLED;
}
 
int __init fs4412key2_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major,minor);
 
    struct device_node *pnode = NULL;
 
    pnode = of_find_node_by_path("/mykey2_node");
    if(NULL == pnode)
    {
        printk("find node failed\n");
        return -1;
    }
 
 
    pgmydev = (struct fs4412key2_dev *)kmalloc(sizeof(struct fs4412key2_dev),GFP_KERNEL);
    if(NULL == pgmydev)
    {
        printk("kmallc for struct fs4412key2_dev failed\n");
        return -1;
    }
 
    pgmydev->gpio = of_get_named_gpio(pnode,"key2-gpio",0);
 
    pgmydev->irqno = irq_of_parse_and_map(pnode,0);
 
    /*申请设备号*/
    ret = register_chrdev_region(devno,fs4412key2_num,"fs4412key2");
    if(ret)
    {
        ret = alloc_chrdev_region(&devno,minor,fs4412key2_num,"fs4412key2");
        if(ret)
        {
            kfree(pgmydev);
            pgmydev = NULL;
            printk("get devno failed\n");
            return -1;
        }
        major = MAJOR(devno);//容易遗漏，注意
    }
 
    /*给struct cdev对象指定操作函数集*/  
    cdev_init(&pgmydev->mydev,&myops);
 
    /*将struct cdev对象添加到内核对应的数据结构里*/
    pgmydev->mydev.owner = THIS_MODULE;
    cdev_add(&pgmydev->mydev,devno,fs4412key2_num);
 
 
    init_waitqueue_head(&pgmydev->rq);
 
    spin_lock_init(&pgmydev->lock);
     
    ret = request_irq(pgmydev->irqno,key2_irq_handle,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,"fs4412key2",pgmydev);
    if(ret)
    {
        printk("request_irq failed\n");
        cdev_del(&pgmydev->mydev);
        kfree(pgmydev);
        pgmydev = NULL;
        unregister_chrdev_region(devno,fs4412key2_num);
        return -1;
    }
    return 0;
}
 
void __exit fs4412key2_exit(void)
{
    dev_t devno = MKDEV(major,minor);
 
    free_irq(pgmydev->irqno,pgmydev);
 
    cdev_del(&pgmydev->mydev);
 
    unregister_chrdev_region(devno,fs4412key2_num);
 
    kfree(pgmydev);
    pgmydev = NULL;
}
 
 
MODULE_LICENSE("GPL");
 
module_init(fs4412key2_init);
module_exit(fs4412key2_exit);

key_app.c

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
#include <stdio.h>
 
#include "fs4412_key.h"
 
int main(int argc,char *argv[])
{
    int fd = -1;
    struct keyvalue keydata = {0};
    int ret = 0;
 
    if(argc < 2)
    {
        printf("The argument is too few\n");
        return 1;
    }
 
    fd = open(argv[1],O_RDONLY);
    if(fd < 0)
    {
        printf("open %s failed\n",argv[1]);
        return 3;
    }
 
    while((ret = read(fd,&keydata,sizeof(keydata))) == sizeof(keydata))
    {
        if(keydata.status == KEY_DOWN)
        {
            printf("Key2 is down!\n");
        }
        else
        {
            printf("Key2 is up!\n");
        }
    }
 
    close(fd);
    fd = -1;
    return 0;
}

五、中断上半部与下半部

起源：

  1. 中断处理程序执行时间过长引起的问题
  2. 有些设备的中断处理程序必须要处理一些耗时操作

六、下半部机制之tasklet ---- 基于软中断

6.1 结构体

struct tasklet_struct

{

​ struct tasklet_struct *next;

​ unsigned long state;

​ atomic_t count;

​ void (*func)(unsigned long);

​ unsigned long data;

};

6.2 定义tasklet的中断底半部处理函数

void tasklet_func(unsigned long data);

6.3 初始化tasklet

DECLARE_TASKLET(name, func, data);
/*
定义变量并初始化
参数：name:中断底半部tasklet的名称
	 Func:中断底半部处理函数的名字
	 data:给中断底半部处理函数传递的参数
*/

void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)

6.4 调度tasklet

void tasklet_schedule(struct tasklet_struct *t)
//参数:t:tasklet的结构体

6.5 代码示例

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
 
#include "fs4412_key.h"
 
 
int major = 11;
int minor = 0;
int fs4412key2_num  = 1;
 
struct fs4412key2_dev
{
    struct cdev mydev;
 
    int gpio;
    int irqno;
 
    struct keyvalue data;
    int newflag;
    spinlock_t lock;
 
    wait_queue_head_t rq;
 
    struct tasklet_struct tsk;
};
 
struct fs4412key2_dev *pgmydev = NULL;
 
int fs4412key2_open(struct inode *pnode,struct file *pfile)
{
    pfile->private_data =(void *) (container_of(pnode->i_cdev,struct fs4412key2_dev,mydev));
    return 0;
}
 
int fs4412key2_close(struct inode *pnode,struct file *pfile)
{
 
    return 0;
}
 
ssize_t fs4412key2_read(struct file *pfile,char __user *puser,size_t count,loff_t *p_pos)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    int size = 0;
    int ret = 0;
 
    if(count < sizeof(struct keyvalue))
    {
        printk("expect read size is invalid\n");
        return -1;
    }
 
    spin_lock(&pmydev->lock);
    if(!pmydev->newflag)
    {
        if(pfile->f_flags & O_NONBLOCK)
        {//非阻塞
            spin_unlock(&pmydev->lock);
            printk("O_NONBLOCK No Data Read\n");
            return -1;
        }
        else
        {//阻塞
            spin_unlock(&pmydev->lock);
            ret = wait_event_interruptible(pmydev->rq,pmydev->newflag == 1);
            if(ret)
            {
                printk("Wake up by signal\n");
                return -ERESTARTSYS;
            }
            spin_lock(&pmydev->lock);
        }
    }
 
    if(count > sizeof(struct keyvalue))
    {
        size = sizeof(struct keyvalue);
    }
    else
    {
        size = count;
    }
 
    ret = copy_to_user(puser,&pmydev->data,size);
    if(ret)
    {
        spin_unlock(&pmydev->lock);
        printk("copy_to_user failed\n");
        return -1;
    }
 
    pmydev->newflag = 0;
 
    spin_unlock(&pmydev->lock);
 
    return size;
}
 
unsigned int fs4412key2_poll(struct file *pfile,poll_table *ptb)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    unsigned int mask = 0;
 
    poll_wait(pfile,&pmydev->rq,ptb);
 
    spin_lock(&pmydev->lock);
    if(pmydev->newflag)
    {
        mask |= POLLIN | POLLRDNORM;
    }
    spin_unlock(&pmydev->lock);
 
    return mask;
}
 
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = fs4412key2_open,
    .release = fs4412key2_close,
    .read = fs4412key2_read,
    .poll = fs4412key2_poll,
};
 
irqreturn_t key2_irq_handle(int no,void *arg)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
 
    tasklet_schedule(&pmydev->tsk);
 
    return IRQ_HANDLED;
}
 
void bottom_irq_func(unsigned long arg)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
    int status1 = 0;
    int status2 = 0;
    int status = 0;
 
    status1 = gpio_get_value(pmydev->gpio);
    mdelay(1);
    status2 = gpio_get_value(pmydev->gpio);
 
    if(status1 != status2)
    {
        return;
    }
 
    status = status1;
 
    spin_lock(&pmydev->lock);
    if(status == pmydev->data.status)
    {
        spin_unlock(&pmydev->lock);
        return;
    }
 
    pmydev->data.code = KEY2;
    pmydev->data.status = status;
    pmydev->newflag = 1;
 
    spin_unlock(&pmydev->lock);
    wake_up(&pmydev->rq);
 
    return;
}
 
int __init fs4412key2_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major,minor);
 
    struct device_node *pnode = NULL;
 
    pnode = of_find_node_by_path("/mykey2_node");
    if(NULL == pnode)
    {
        printk("find node failed\n");
        return -1;
    }
 
 
    pgmydev = (struct fs4412key2_dev *)kmalloc(sizeof(struct fs4412key2_dev),GFP_KERNEL);
    if(NULL == pgmydev)
    {
        printk("kmallc for struct fs4412key2_dev failed\n");
        return -1;
    }
 
    pgmydev->gpio = of_get_named_gpio(pnode,"key2-gpio",0);
 
    pgmydev->irqno = irq_of_parse_and_map(pnode,0);
 
    /*申请设备号*/
    ret = register_chrdev_region(devno,fs4412key2_num,"fs4412key2");
    if(ret)
    {
        ret = alloc_chrdev_region(&devno,minor,fs4412key2_num,"fs4412key2");
        if(ret)
        {
            kfree(pgmydev);
            pgmydev = NULL;
            printk("get devno failed\n");
            return -1;
        }
        major = MAJOR(devno);//容易遗漏，注意
    }
 
    /*给struct cdev对象指定操作函数集*/  
    cdev_init(&pgmydev->mydev,&myops);
 
    /*将struct cdev对象添加到内核对应的数据结构里*/
    pgmydev->mydev.owner = THIS_MODULE;
    cdev_add(&pgmydev->mydev,devno,fs4412key2_num);
 
 
    init_waitqueue_head(&pgmydev->rq);
 
    spin_lock_init(&pgmydev->lock);
 
    tasklet_init(&pgmydev->tsk,bottom_irq_func,(unsigned long)pgmydev);
     
    ret = request_irq(pgmydev->irqno,key2_irq_handle,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,"fs4412key2",pgmydev);
    if(ret)
    {
        printk("request_irq failed\n");
        cdev_del(&pgmydev->mydev);
        kfree(pgmydev);
        pgmydev = NULL;
        unregister_chrdev_region(devno,fs4412key2_num);
        return -1;
    }
    return 0;
}
 
void __exit fs4412key2_exit(void)
{
    dev_t devno = MKDEV(major,minor);
 
    free_irq(pgmydev->irqno,pgmydev);
 
    cdev_del(&pgmydev->mydev);
 
    unregister_chrdev_region(devno,fs4412key2_num);
 
    kfree(pgmydev);
    pgmydev = NULL;
}
 
 
MODULE_LICENSE("GPL");
 
module_init(fs4412key2_init);
module_exit(fs4412key2_exit);

七、下半部机制之workqueue ----- 基于内核线程

7.1 工作队列结构体：

typedef void (*work_func_t)(struct work_struct *work)

struct work_struct {

​ atomic_long_t data;

​ struct list_head entry;

​ work_func_t func;

#ifdef CONFIG_LOCKDEP

​ struct lockdep_map lockdep_map;

#endif

};

7.2 定义工作队列底半部处理函数

void work_queue_func(struct work_struct *work);

7.3 初始化工作队列

struct work_struct work_queue;

初始化：绑定工作队列及工作队列的底半部处理函数

INIT_WORK(struct work_struct * pwork, _func) ;

参数：pwork：工作队列

​ func：工作队列的底半部处理函数

7.4 工作队列的调度函数

bool schedule_work(struct work_struct *work)；

7.5 代码示例

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
 
#include "fs4412_key.h"
 
 
int major = 11;
int minor = 0;
int fs4412key2_num  = 1;
 
struct fs4412key2_dev
{
    struct cdev mydev;
 
    int gpio;
    int irqno;
 
    struct keyvalue data;
    int newflag;
    spinlock_t lock;
 
    wait_queue_head_t rq;
 
    //struct tasklet_struct tsk;
    struct work_struct wk;
};
 
struct fs4412key2_dev *pgmydev = NULL;
 
int fs4412key2_open(struct inode *pnode,struct file *pfile)
{
    pfile->private_data =(void *) (container_of(pnode->i_cdev,struct fs4412key2_dev,mydev));
    return 0;
}
 
int fs4412key2_close(struct inode *pnode,struct file *pfile)
{
 
    return 0;
}
 
ssize_t fs4412key2_read(struct file *pfile,char __user *puser,size_t count,loff_t *p_pos)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    int size = 0;
    int ret = 0;
 
    if(count < sizeof(struct keyvalue))
    {
        printk("expect read size is invalid\n");
        return -1;
    }
 
    spin_lock(&pmydev->lock);
    if(!pmydev->newflag)
    {
        if(pfile->f_flags & O_NONBLOCK)
        {//非阻塞
            spin_unlock(&pmydev->lock);
            printk("O_NONBLOCK No Data Read\n");
            return -1;
        }
        else
        {//阻塞
            spin_unlock(&pmydev->lock);
            ret = wait_event_interruptible(pmydev->rq,pmydev->newflag == 1);
            if(ret)
            {
                printk("Wake up by signal\n");
                return -ERESTARTSYS;
            }
            spin_lock(&pmydev->lock);
        }
    }
 
    if(count > sizeof(struct keyvalue))
    {
        size = sizeof(struct keyvalue);
    }
    else
    {
        size = count;
    }
 
    ret = copy_to_user(puser,&pmydev->data,size);
    if(ret)
    {
        spin_unlock(&pmydev->lock);
        printk("copy_to_user failed\n");
        return -1;
    }
 
    pmydev->newflag = 0;
 
    spin_unlock(&pmydev->lock);
 
    return size;
}
 
unsigned int fs4412key2_poll(struct file *pfile,poll_table *ptb)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)pfile->private_data;
    unsigned int mask = 0;
 
    poll_wait(pfile,&pmydev->rq,ptb);
 
    spin_lock(&pmydev->lock);
    if(pmydev->newflag)
    {
        mask |= POLLIN | POLLRDNORM;
    }
    spin_unlock(&pmydev->lock);
 
    return mask;
}
 
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = fs4412key2_open,
    .release = fs4412key2_close,
    .read = fs4412key2_read,
    .poll = fs4412key2_poll,
};
 
irqreturn_t key2_irq_handle(int no,void *arg)
{
    struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
 
    //tasklet_schedule(&pmydev->tsk);
    schedule_work(&pmydev->wk);
 
    return IRQ_HANDLED;
}
 
//void bottom_irq_func(unsigned long arg)
void bottom_irq_func(struct work_struct *pwk)
{
    //struct fs4412key2_dev *pmydev = (struct fs4412key2_dev *)arg;
    struct fs4412key2_dev *pmydev = container_of(pwk,struct fs4412key2_dev,wk);
    int status1 = 0;
    int status2 = 0;
    int status = 0;
 
    status1 = gpio_get_value(pmydev->gpio);
    mdelay(1);
    status2 = gpio_get_value(pmydev->gpio);
 
    if(status1 != status2)
    {
        return;
    }
 
    status = status1;
 
    spin_lock(&pmydev->lock);
    if(status == pmydev->data.status)
    {
        spin_unlock(&pmydev->lock);
        return;
    }
 
    pmydev->data.code = KEY2;
    pmydev->data.status = status;
    pmydev->newflag = 1;
 
    spin_unlock(&pmydev->lock);
    wake_up(&pmydev->rq);
 
    return;
}
 
int __init fs4412key2_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major,minor);
 
    struct device_node *pnode = NULL;
 
    pnode = of_find_node_by_path("/mykey2_node");
    if(NULL == pnode)
    {
        printk("find node failed\n");
        return -1;
    }
 
 
    pgmydev = (struct fs4412key2_dev *)kmalloc(sizeof(struct fs4412key2_dev),GFP_KERNEL);
    if(NULL == pgmydev)
    {
        printk("kmallc for struct fs4412key2_dev failed\n");
        return -1;
    }
 
    pgmydev->gpio = of_get_named_gpio(pnode,"key2-gpio",0);
 
    pgmydev->irqno = irq_of_parse_and_map(pnode,0);
 
    /*申请设备号*/
    ret = register_chrdev_region(devno,fs4412key2_num,"fs4412key2");
    if(ret)
    {
        ret = alloc_chrdev_region(&devno,minor,fs4412key2_num,"fs4412key2");
        if(ret)
        {
            kfree(pgmydev);
            pgmydev = NULL;
            printk("get devno failed\n");
            return -1;
        }
        major = MAJOR(devno);//容易遗漏，注意
    }
 
    /*给struct cdev对象指定操作函数集*/  
    cdev_init(&pgmydev->mydev,&myops);
 
    /*将struct cdev对象添加到内核对应的数据结构里*/
    pgmydev->mydev.owner = THIS_MODULE;
    cdev_add(&pgmydev->mydev,devno,fs4412key2_num);
 
 
    init_waitqueue_head(&pgmydev->rq);
 
    spin_lock_init(&pgmydev->lock);
 
    //tasklet_init(&pgmydev->tsk,bottom_irq_func,(unsigned long)pgmydev);
    INIT_WORK(&pgmydev->wk,bottom_irq_func);
     
    ret = request_irq(pgmydev->irqno,key2_irq_handle,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,"fs4412key2",pgmydev);
    if(ret)
    {
        printk("request_irq failed\n");
        cdev_del(&pgmydev->mydev);
        kfree(pgmydev);
        pgmydev = NULL;
        unregister_chrdev_region(devno,fs4412key2_num);
        return -1;
    }
    return 0;
}
 
void __exit fs4412key2_exit(void)
{
    dev_t devno = MKDEV(major,minor);
 
    free_irq(pgmydev->irqno,pgmydev);
 
    cdev_del(&pgmydev->mydev);
 
    unregister_chrdev_region(devno,fs4412key2_num);
 
    kfree(pgmydev);
    pgmydev = NULL;
}
 
 
MODULE_LICENSE("GPL");
 
module_init(fs4412key2_init);
module_exit(fs4412key2_exit);

八、下半部机制比较

任务机制

​ workqueue ----- 内核线程 能睡眠 运行时间无限制

异常机制 ------- 不能睡眠 下半部执行时间不宜太长（ < 1s)

​ 软中断 ---- 接口不方便

​ tasklet ----- 无具体延后时间要求时

​ 定时器 -----有具体延后时间要求时

Novelty_1
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何使用 Linux 驱动程序处理中断？
shengyin714959的博客
05-22 252
也就是说asm_do_IRQ函数的参数irq的取值范围只有32个值，发生中断可能是一个实际的中断号，也可能是一组中断的中断号。函数s3c_irq_demux_extint4t7()的作用，就是根据寄存器S3C24XX_EINTPEND、S3C24XX_EINTMASK重新计算中断号，这个时候将计算出真正的中断号IRQ_EINT5，然后通过desc_handle_irq(irq, irq_desc + irq)来调用irq_desc[EINT5].handle_irq(irq,desc)。
linux 矩阵键盘驱动-基于max7349
08-29
该驱动基于imx6硬件平台，linux内核版本为3.14，矩阵键盘驱动IC为max7349。对于要基于max7349开发的同仁具备参考意义。原理：max7349与cpu通过i2c通信，当有按键按下，max7349扫描到该事件，产生一个脉冲发往cpu，...
Linux内核5. 中断和中断处理
weixin_39757802的博客
10-13 821
我们先来看一下中断的定义：中断机制：CPU在执行指令时，收到某个中断信号转而去执行预先设定好的代码，然后再返回到原指令流中继续执行，这就是中断机制。可以发现中断的定义非常简单。我们根据中断的定义来画一张图：在图灵机模型中，计算机是一直线性运行的。加入了中断之后，计算机就可以透明地在进程执行流中插入一段代码来执行。那么这么做的目的是什么呢？本文我们从中断的概念开始讲起，一路上分析了中断的作用、中断的产生、中断的处理。其中内容最多的是硬件中断的处理，方法很多很繁杂。
Linux 中断
qq_41720028的博客
09-12 443
根据中断入口跳入方法的不同，中断可分为向量中断和非向量中断。采用向量中断的CPU通常为不同的中断分配不同的中断号，当检测到某个中断号的中断到来后，就自动跳转到与该中断号对应的地址执行，不同中断号的中断有不同的入口地址。非向量中断的多个中断共享一个入口地址，进入到该入口地址后，再通过软件判断中断标志来识别具体是哪个中断
Linux系统对中断的处理
m0_49476241的博客
07-25 732
本篇文章来讲解Linux系统对中断的处理，中断无论是在单片机还是在Linux中都是非常重要的那么这篇文章就来讲解一下Linux系统对中断的处理。本篇文章就讲解到这里，下篇文章继续讲解Linux中的中断处理。
linux中断，中断亲和性，IPI中断，中断线程化，中断计数，软中断 和 调试方法
u010936265的博客
09-16 3639
目录 1 基础知识 1.1 同步中断和异步中断 1.2 中断上下文 1.3 中断处理程序栈 1.4 中断处理程序的重入 1.5 中断的返回 2 顶半部和底半部(推后执行的工作) 2.1 简介 2.2 软中断 2.3 tasklet 2.4 工作队列 2.5 内核定时器 2.6 底半部机制的选择 3 中断亲和性 4 IPI(Interrupt-Procecesorr Interrupt):处理器中间的中断 5 /proc/ 目录下中断相关的文件 5.1 /proc/inter
linux驱动-中断
sty01z的博客
05-29 632
gic 的初始化做了下面的工作映射 gic 的寄存器地址,对 gic 的寄存器做一些初始化设置设置异常处理回调函数 handle_arch_irq = gic_handle_irq为中断控制器创建一个中断域,使用线性映射方式进行初始化设置中断域映射方式的回调函数 gic_irq_domain_hierarchy_ops。
Linux驱动——中断
Linux驱动相关内容及Android开发
04-12 1765
在 Linux 内核中要想使用某个中断是需要申请的，request_irq 函数用于申请中断request_irq函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用 request_irq 函数。disable_irq函数要等到当前正在执行的中断处理函数执行完才返回，因此使用者需要保证不会产生新的中断，并且确保所有已经开始执行的中断处理程序已经全部退出。和 tasklet 一样，工作也是需要调度才能运行的，工作的调度函数为 schedule_work，函数原。
操作系统13：中断处理程序和设备驱动程序
swadian2008的博客
07-11 2637
当一个进程请求 I/O 操作时，该进程将被挂起，直到 I/O 设备完成 I/O 操作后，设备控制器便向 CPU 发送一个中断请求，CPU 响应后便转向中断处理程序，中断处理程序执行相应的处理，处理完后解除相应进程的阻塞状态。具体的 I/O 操作是在设备控制器的控制下进行的，因此，在设备忙于传送数据时，处理机又可以去干其它的事情，实现了处理机与 I/O 设备的并行操作。CPU 的绝大部分时间都处于等待 I/O 设备完成数据 I/O 的循环测试中，造成对 CPU 的极大浪费。
史上最强的嵌入式底层驱动开发课程 Linux系统开发+Linux高级程序+主板开发+ARM等
12-23
├<2 Linux应用系统开发> │ ├001 - GNU开发环境基础1.mp4 │ ├002 - GNU开发环境基础2.mp4 │ ├003 - GNU开发环境基础3.mp4 │ ├004 - GNU开发环境基础4.mp4 │ ├005 - GNU开发环境基础_gcc编译1.mp4 │ ├006...
嵌入式设计及linux驱动开发指南——基于ARM9处理器.pdf
06-22
7.2.2 字符设备驱动开发 第8章 网络设备驱动程序开发 8.1 网络设备驱动程序简介 8.1.1 device数据结构 8.1.2 sk_buff数据结构 8.1.3 内核的驱动程序接口 8.2 以太网控制器CS8900A 8.2.1 特性 8.2.2 工作原理...
嵌入式Linux驱动程序开发要点
12-20
要开发Linux设备驱动，需要掌握以下知识： • C编程 需要掌握深入一些的C语言知识，比如，指针的使 用，位处理函数，等。 • 微处理器编程 需要理解微机的内部工作原理：存贮器地 址，中断，等。这些内容对一个汇编...
windows驱动开发-WDM框架(二)
m0_72813396的博客
04-21 754
DriverEntry、AddDevice、Dispatch、Unload例程详细说明
4.19作业 驱动开发
2301_81255755的博客
04-20 227
【代码】4.19作业 驱动开发。
windows驱动开发-I/O请求(一)
m0_72813396的博客
04-23 816
IRP结构定义介绍
windows驱动开发-WDM框架(一)
m0_72813396的博客
04-20 620
在前面的文章中解释过，NT5.0之后windows确定了新的架构Windows Driver Model (WDM)，在Vista之后又推出了Windows Driver Framework(WDF)，这两个都属于驱动程序框架，那么它们的之间的关系是怎样的？WDF是对WDM进行的封装，是为更快、更简单的进行驱动开发进行的二次封装，故WDM里面的所有概念对于WDF都是适用的，所以理解内核架构可以学习WDM，开发驱动程序则使用WDF框架。
Linux驱动开发——（四）内核定时器
wJen的博客
04-23 1603
Linux内核定时器的简单介绍与使用
行政数据分析看板8.xlsx
最新发布
04-26
Excel数据看板，Excel办公模板，Excel模板下载，Excel数据统计，数据展示
自动驾驶运动规划(Motion Planning).pdf
04-26
自动驾驶运动规划(Motion Planning)问题分析
Linux Wi-Fi驱动开发
05-15
Linux Wi-Fi驱动开发是一项高级技能，需要深入了解 Linux 内核和网络协议栈，以及具体的 Wi-Fi硬件设备和驱动程序。以下是一些步骤和技能，可以帮助你开始学习和开发 Linux Wi-Fi驱动程序: 1. 了解 Wi-Fi硬件和协议。Wi-Fi技术涉及到许多不同的标准和协议，包括 IEEE 802.11，WPA2加密等。了解这些协议和标准是必要的，以便理解 Wi-Fi驱动程序的工作原理。 2. 学习 Linux 内核网络协议栈。Wi-Fi驱动程序是内核的一个模块，它需要与网络协议栈紧密集成。因此，了解和熟悉 Linux 的网络协议栈是必要的。 3. 学习 Linux 内核编程。Wi-Fi驱动程序是内核的一个模块，因此需要掌握 Linux 内核编程的技能，包括模块编程、内存管理、进程管理等。 4. 学习 Wi-Fi驱动程序的开发技术。Wi-Fi驱动程序需要与具体的硬件设备紧密集成。因此，需要掌握如何编写和调试设备驱动程序、掌握硬件设备的 I/O 端口、中断处理和 DMA 等技术。 5. 学习 Wi-Fi驱动程序的调试技术。Wi-Fi驱动程序是一个非常复杂的系统，因此需要掌握如何使用调试工具（例如 GDB、SystemTap、LTTng 等）来调试和分析驱动程序的运行时错误。 总之，Linux Wi-Fi驱动开发需要掌握多个领域的知识和技能，包括网络协议、内核编程、硬件驱动程序等。如果你有相关的背景和经验，可以尝试学习和开发 Linux Wi-Fi驱动程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值