Linux驱动开发之按键驱动（3）--------- 中断下半部的实现方法

---

中断上下文

************

---

中断下半部的实现方法

---

1.中断下半部的实现方法：

• softirq：处理比较快，但是内核级别的机制，需要修改整个内核源码，不常用
• tasklet：内部实际调用了softirq
• work queue：工作队列，使用方法类似tasklet

2.tasklet和work queue实现的基本逻辑

---

1.tasklet的实现

---

struct tasklet_struct
{
	struct tasklet_struct *next;
	unsigned long state;
	atomic_t count;
	void (*func)(unsigned long);      //中断下半部执行函数
	unsigned long data;
};

【1】初始化：

	//初始化tasklet
	tasklet_init(&key_dev->mytasklet, key_tasklet_half_irq, 45);

【2】在上半部放到内核线程中--------->启动下半部

//启动下半部
	tasklet_schedule(&key_dev->mytasklet);

【3】模块卸载时

	tasklet_kill(&key_dev->mytasklet);

按键驱动的完整代码：（包含四种IO模型接口）

#include <linux/module.h>
#include <linux/init.h>
#include <linux/of.h>
#include <linux/interrupt.h>
#include <mach/irqs.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/poll.h>  

#define GPH0DATA  0xE0200C04     //GHH0_2 (eint2data寄存器的物理地址)
#define KEY_ENTER 28

//描述按键数据的对象
struct key_event{
	int code;  //表示按键的类型
	int value; //表示按键的按下还是抬起
};

//描述按键的信息
struct key_desc{
	unsigned int dev_major;
	struct class* cls;
	struct device* dev;
	int irqno;
	void *reg_base;
	struct key_event event;
	wait_queue_head_t wq_head;
	int key_state;   //表示是否有数据
	struct fasync_struct * fasync;
	struct tasklet_struct mytasklet;
};

struct key_desc* key_dev;

void key_tasklet_half_irq(unsigned long data)
{
	printk("-----%s----\n",__FUNCTION__);
	//表示有数据，需要去唤醒等待队列,同时设置标志位
	wake_up_interruptible(&key_dev->wq_head);
	 key_dev->key_state = 1;
	//发送信号
	kill_fasync(&key_dev->fasync, SIGIO, POLLIN);
}

irqreturn_t key_irq_handler (int irq, void * dev_id)
{
	printk("------%s----\n",__FUNCTION__);
	int value = readl(key_dev->reg_base) & (1<<2);
	if(value)
	{
		//按键抬起
		printk("key up\n");
		key_dev->event.code = KEY_ENTER;
		key_dev->event.value = 0;
	}
	else
	{
		//按键按下
		printk("key press\n");
		key_dev->event.code = KEY_ENTER;
		key_dev->event.value = 1;
	}
	
	//启动下半部
	tasklet_schedule(&key_dev->mytasklet);
	return IRQ_HANDLED;
}

ssize_t  key_drv_read (struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
	int ret;
	//如果当前是非阻塞模式，并且没有数据，立马返回一个错误码
	if(filp->f_flags & O_NONBLOCK && !key_dev->key_state)
		return -EAGAIN;

	//在等待数据的时候进行休眠
	wait_event_interruptible(key_dev->wq_head, key_dev->key_state);

	//表示有数据了
	ret = copy_to_user(buf, &key_dev->event, count);
	if(ret > 0)
	{
		printk("copy_to_user error.\n");
		return -EFAULT;
	}
	//传递给用户之后将数据清除
	memset(&key_dev->event, 0, sizeof(key_dev->event));
	//数据传递完成把标志位置回0
	 key_dev->key_state = 0;
	return count;
}

ssize_t key_drv_write (struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
{
	printk("-----%s----\n",__FUNCTION__);
	return 0;
}

int key_drv_open(struct inode *inode, struct file *filp)
{
	printk("-----%s----\n",__FUNCTION__);
	return 0;
}

int key_drv_close (struct inode *inode, struct file *filp)
{
	printk("-----%s----\n",__FUNCTION__);
	return 0;
}

unsigned int key_dev_poll (struct file *filp, struct poll_table_struct *pts)
{
	printk("----%s----\n",__FUNCTION__);
	//返回一个mask值
	unsigned int mask;
	//调用poll_wait将当前等待队列注册到系统中
	poll_wait(filp, &key_dev->wq_head,pts);
	// 1，没有数据的时候返回一个0
	if(!key_dev->key_state)
	{
		mask = 0;
	}
	// 2，当有数据的时候返回一个POLLIN
	if(key_dev->key_state)
	{
		mask |= POLLIN;
	}
	return mask;
}

int key_dev_fasync (int fd, struct file *filp, int on)
{
	//只需要调用一个函数记录信号该发送给谁
	return fasync_helper(fd, filp,on, &key_dev->fasync);
}

const struct file_operations key_fops = {
	.open = key_drv_open,
	.read = key_drv_read,
	.write = key_drv_write,
	.release = key_drv_close,
	.poll = key_dev_poll,
	.fasync = key_dev_fasync,
};

static int __init key_drv_init(void)
{
	int ret;
	// 1，设定一个全局的设备对象
	key_dev = kzalloc(sizeof(struct key_desc), GFP_KERNEL);
	
	// 2，申请主设备号
	key_dev->dev_major = register_chrdev(0, "key_drv", &key_fops);
	
	// 3，创建设备结点
	key_dev->cls = class_create(THIS_MODULE, "key_cls");
	key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major ,0), NULL, "key0");
	
	// 4，硬件初始化：--地址映射和中断申请
	key_dev->irqno = IRQ_EINT2; 
	
	ret = request_irq(key_dev->irqno, key_irq_handler,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "key5_eint2", NULL);
	if(ret != 0)
	{
		printk("request_irq error.\n");
	}
	//5，硬件如何获取数据---读取gph0data寄存器
	key_dev->reg_base = ioremap(GPH0DATA, 8);

	//6，初始化等待队列头
	init_waitqueue_head(&key_dev->wq_head);

	//7，初始化tasklet
	tasklet_init(&key_dev->mytasklet, key_tasklet_half_irq, 45);
	return 0;
}


static void __exit key_drv_exit(void)
{
	tasklet_kill(&key_dev->mytasklet);
	iounmap(key_dev->reg_base);
	free_irq(key_dev->irqno, NULL);
	device_destroy(key_dev->cls, MKDEV(key_dev->dev_major,0));
	class_destroy(key_dev->cls);
	unregister_chrdev(key_dev->dev_major, "key_drv");
	kfree(key_dev);
}

module_init(key_drv_init);
module_exit(key_drv_exit);
MODULE_LICENSE("GPL");

2.工作队列workqueue的实现

使用原理和tasklet类似：(具体代码在这里就不再累述)
struct work_struct：

 typedef void (*work_func_t)(struct work_struct *work);
 struct work_struct {
	atomic_long_t data;
	struct list_head entry;
	work_func_t func;
};

【1】初始化：

//初始化workqueue
INIT_WORK(struct work_struct* work,work_func_t func);

【2】在上半部放到内核线程中--------->启动下半部

//启动下半部
	schedule_work(struct work_struct* work);