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

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

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

实现中断的下半部有三种方法：
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实现步骤是一模一样的只不过换了一个结构体和队列初始化函数