欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

驱动开发----中断下半部

程序员文章站 2022-07-14 11:43:56
...

中断下半部,什么是中断下半部呢?其实我们之前做的中断都是中断的上半部

驱动开发----中断下半部
为什么需要中断下半部呢?原因是当我们在正常运行程序时候,如果与遇到中断会直接停止然后去执行中断程序,如果中断的程序用时很长,那么主程序将被一直阻塞不能执行,所以就需要把中断分成两部分,一个是上部分一个是下部分,上部分完成对全局变量的初始化,并且启动下半部分,而下半部分则执行耗时的操作,放在全局,在后台慢慢执行,不影响主程序。

实现中断的下半部有三种方法:
1.软中断(soft irq)
2.tasklet
3.workqueue

软中断用得比较少,也不推荐使用,接下来将用tasklet 和 workqueue 来实现中断的下半部

用tasklet 实现:
中断的下半部其实是丢到一个队列里面,然后依次执行,和中断唤醒队列很像
所以我们需要在入口函数中用tasklet_init初始化队列
我们来看看这个函数的原型:

static inline void tasklet_init(struct tasklet_struct *tasklet,
                                void (*func)(unsigned long),
                                unsigned long data)
                        需要用到一个struct tasklet_struct *类型的结构体,所以我们在描述按键的结构体中定义这个类型的成员
                        还有一个参数是void (*func)(unsigned long),这个函数里面用于实现中断下半部的代码,所以我们将下半部要做的事情丢到这里就好了
                        实现这个函数,就ok了.
                        第三个参数是将这个参数通过初始化函数tasklet_init处理后存到定义的tasklet_struct 指针类型的结构体中

初始化这个队列以后我们需要在中断处理函数中完成上半部的操作,并且启动下半部

irqreturn_t key_handle_t(int irq,void *dev_id){
        int dn=0;
        dn=gpio_get_value(EXYNOS4_GPX3(2));//根据这个函数获取GPX3_2的按键状态
        if(!dn)
                {
                        printk("\n key   down !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=1;
                }
        else
                {
                        printk("\n key   up !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=0;
                }
		tasklet_schedule(&my_key.my_task);//让出调度,执行中断下半部
        return IRQ_HANDLED;

}

然后在中断下半部中实现:

void key_task_half_irq(unsigned long data)
{
	printk("\n\nkey_task_half_irq!!!!\n\n");
	wake_up_interruptible(&my_key.key_hand_queue);//唤醒进程
	my_key.key_state=1;//此时有数据,将状态置1
}

驱动卸载时候要将该队列销毁

tasklet_kill(&my_key.my_task);//注销这个队列

这些都是在驱动中完成的,无需改动app代码

完整驱动代码如下:

#include<linux/init.h>
#include<linux/module.h>
#include<linux/device.h>
#include<linux/fs.h>
#include <asm/uaccess.h>
#include<linux/interrupt.h> //中断注册注销头文件
#include<linux/gpio.h>   //gpio相关的头文件
#include<linux/cdev.h>
#include <linux/string.h>
#include<linux/sched.h>


struct key_event{
        int code;//按键类型
        int value;//按键状态,按下或者抬起(    0  /  1 )
};

struct key_dsc{
         int major;
         struct cdev *key_cdev;
        struct  class *key_class;
        struct  device *key_dev;
        int irq;//中断号
         unsigned long flag;
        struct key_event my_event;
		wait_queue_head_t key_hand_queue;
		int key_state;
		struct tasklet_struct my_task;
};
#define device_name "qin_key"
#define class_name "qin_class"
#define KEY_ENTER 28

struct key_dsc my_key;


ssize_t key_read(struct file *file, const char __user *buffer, size_t count, loff_t *fpos){
        //  ****************read函数目的是将案按键的数组传到应用层,kbuf[4]   ************

		//没有数据将会休眠进行到这一步,不会再往下执行
 		wait_event_interruptible(my_key.key_hand_queue,my_key.key_state);//将进程休眠,用my_ke中的state状态判断

		//有数据将会继续往下执行
        if(copy_to_user(buffer,&my_key.my_event,sizeof(struct key_event)))//copy_to_user 返回零代表copy失败,1代表成功
                {
                        printk("\n   copy  fail!!   \n");
                }
    
                memset(&my_key.my_event,0,sizeof(struct key_event));
				my_key.key_state=0;//本次数据传送完需要将状态置0,继续休眠
        return count;
}

ssize_t key_write (struct file *file, const char __user *buf, size_t count, loff_t *fpos){
        printk("\n              key_ is write!!         \n");

}


int  key_open (struct inode *inode, struct file *file){
                printk("\n              key_ is open!!          \n");
                                return 0;
}

int key_close(struct inode *inode, struct file *file){
                printk("\n              key_ is close!!         \n");
}

irqreturn_t key_handle_t(int irq,void *dev_id){
        int dn=0;
        dn=gpio_get_value(EXYNOS4_GPX3(2));//根据这个函数获取GPX3_2的按键状态
        if(!dn)
                {
                        printk("\n key   down !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=1;
                }
        else
                {
                        printk("\n key   up !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=0;
                }
		tasklet_schedule(&my_key.my_task);//让出调度,执行中断下半部
        return IRQ_HANDLED;

}
void key_task_half_irq(unsigned long data)
{
	printk("\n\nkey_task_half_irq!!!!\n\n");
	wake_up_interruptible(&my_key.key_hand_queue);//唤醒进程
	my_key.key_state=1;//此时有数据,将状态置1
}


static struct file_operations myfops={
        .owner=THIS_MODULE,
        .open=key_open,
        .release=key_close,
        .write=key_write,
        .read=key_read,
};

static int __init mykey_init(void)
{
                my_key.irq=0;
        my_key.major=250;

        my_key.flag=IRQF_DISABLED |
                    IRQF_TRIGGER_FALLING |
                    IRQF_TRIGGER_RISING;//设置属性,上升,下降沿触发

        my_key.irq=gpio_to_irq(EXYNOS4_GPX3(2));//获取中断号
        request_irq(my_key.irq,key_handle_t,my_key.flag,"key1",NULL);//将这个按键注册到内核,这样才能识别
                if(register_chrdev(my_key.major,"qin",&myfops))//返回值为1则失败
                        {
                                        printk("\nregister is faile !\n");
                        }
                else
                        {
                                                printk("\nregister is ok !\n");
                        }

        my_key.key_class=class_create(THIS_MODULE,"class");
        my_key.key_dev=device_create(my_key.key_class,NULL,MKDEV(my_key.major,0),NULL,"qin");
        printk("\nI am key_dev\n");

		my_key.key_state=0;
		init_waitqueue_head(&my_key.key_hand_queue);//初始化等待队列头
		tasklet_init(&my_key.my_task,key_task_half_irq,45);

		
        return 0;
}
static int __exit mykey_exit(void)
{
		tasklet_kill(&my_key.my_task);//注销这个队列
        free_irq(my_key.irq,NULL); //注销key1中断
                device_destroy(my_key.key_class,MKDEV(my_key.major,0));//注销dev
                class_destroy(my_key.key_class);//注销class
        unregister_chrdev(my_key.major,"qin");

        printk("\n   bye      bye~~~~~~~\n");
        return 0;
}
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");


使用workqueue实现步骤是一模一样的只不过换了一个结构体和队列初始化函数
驱动开发----中断下半部