按键驱动程序设计---混杂设备、中断分层处理、工作队列、阻塞型驱动
2017-07-26 10:51
615 查看
混杂设备
概念:在Linux系统中,存在一类字符设备,它们拥有相同的主设备号,主设备号都为10,但次设备号不同,我们称这类设备为混杂设备(miscdevice)。所有的混杂设备形成一个链表,对设备访问时内核根据次设备号查找到相应的混杂设备。
设备描述符:
Linux中使用 结构体struct miscdevice 来描述一个混杂设备。
//至少前三项需要指明 struct miscdevice { int minor; /* 次设备号 */ const char *name; /* 设备名 */ const struct file_operations *fops; /* 文件操作 */ struct list_head list; struct device *parent; struct device *this_device; };
设备注册和注销
Linux中使用 misc_ register 函数 和 misc_ dregister函数 来注册或注销一个混杂设备驱动。
//注册: int misc_register(struct miscdevice * misc) //注销: int misc_dregister(struct miscdevice * misc)
中断处理程序
中断处理流程:首先获取中断号,根据中断号来找到中断处理程序,一个中断号可以对应多个中断处理程序,通过dev_id来区分。
中断注册:
request_irq函数用于注册中断。
int request_irq ( unsigned int irq, //中断号 void (*handler)(int, void*, struct pt_regs *), //中断处理函数 unsigned long flags, //与中断管理有关的各种选项 const char *devname, //设备名 void *dev_id //共享中断时使用 )
函数返回0表示成功,或者返回一个错误码。
在flags参数中,可以选择一些与中断管理有关的选项,如:
IRQF_ DISABLED(SA_INTERRUPT)
如果设置该位,表示是一个“快速”中断处理程序;如果没有设置这位,那么是一个“慢速”中断处理程序。
快/慢速中断的主要区别在于:快速中断保证中断处理的原子性(不被打断),而慢速中断则不保证。换句话说,也就是“开启中断”标志位(处理器IF)在运行快速中断处理程序时是关闭的,因此在服务该中断时,不会被其他类型的中断打断;而调用慢速中断处理时,其它类型的中断仍可以得到服务。
IRQF_ SHARED(SA_SHIRQ)
该位表明该中断号是多个设备共享的。
中断处理:
中断处理程序的特别之处是在中断上下文中运行的,它的行为受到某些限制:
1、不能使用可能引起阻塞的函数
2、不能使用可能引起调度的函数
注销中断:
当设备不再需要使用中断时(通常在驱动卸载时),应当把它们注销,使用函数:
void free_irq(unsigned int irq, void *dev_id) //irq指定了中断号,然后用 dev_id 来区分共享中断。
中断分层处理
在慢速中断的情况下,如果正在处理某一中断,此时,发生了相同类型的中断,CPU会忽略后面发生的中断。在快速中断的情况下,CPU会忽略其他任何类型的中断。因此,在处理中断时,无论快速还是慢速中断都会产生忽略其他中断的情况,如果可以尽可能的缩短中断处理的时间,则可以让忽略的中断数量尽可能的减少。因此,可以对中断进行分层的处理:
上半部:当中断发生时,它进行相应地硬件读写,并“登记”该中断。通常由中断处理程序充当上半部。
下半部:在系统空闲的时候对上半部“登记”的中断进行后续处理。
工作队列:
可以采用工作队列的的方式实现中断处理的分层:
工作队列是一种将任务推后执行的形式,它把推后的任务交由一个内核线程去执行。这样下半部会在进程上下文执行,它允许重新调度甚至睡眠。 每个被推后的任务叫做“工作”,由这些工作组成的队列称为工作队列。
挂载的时候并不是work执行的时候,是内核线程来执行的work的工作。
Linux内核使用 struct work_struct 结构体 来描述一个工作队列:
struct workqueue_struct { struct cpu_workqueue_struct *cpu_wq; struct list_head list; const char *name; /*workqueue name*/ int singlethread; int freezeable; /* Freeze threads during suspend */ int rt; };
Linux内核使用 struct work_struct 结构体 来描述一个工作项:
struct work_struct { atomic_long_t data; struct list_head entry; work_func_t func; }; typedef void (*work_func_t)(struct work_struct *work);
工作流程:
1、创建工作队列 create_workqueue
2、创建工作 INIT_WORK
3、提交工作 queue_work
代码范例:
#include <linux/init.h> #include <linux/module.h> struct workqueue_struct *my_wq; //工作队列结构体 struct work_struct *work1; //工作结构体 struct work_struct *work2; MODULE_LICENSE("GPL"); void work1_func(struct work_struct *work) { printk("this is work1->\n"); } void work2_func(struct work_struct *work) { printk("this is work2->\n"); } int init_que(void) { //1. 创建工作队列 my_wq = create_workqueue("my_que"); //2. 创建工作 work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL); INIT_WORK(work1, work1_func); //3. 挂载(提交)工作 queue_work(my_wq,work1); //2. 创建工作(创建第二个work) work2 = kmalloc(sizeof(struct work_struct),GFP_KERNEL); INIT_WORK(work2, work2_func); //3. 挂载(提交)工作 queue_work(my_wq,work2); return 0; } void clean_que(){ } module_init(init_que); module_exit(clean_que);
在大多数情况下, 驱动并不需要自己建立工作队列,只需定义工作, 然后将工作提交到内核已经定义好的工作队列 keventd_wq 中。
可以采用下面的函数,提交工作到默认队列: schedule_work 函数。
使用默认工作队列范例代码:
#include <linux/init.h> #include <linux/module.h> struct work_struct *work1; struct work_struct *work2; MODULE_LICENSE("GPL"); void work1_func(struct work_struct *work) { printk("this is work1->\n"); } void work2_func(struct work_struct *work) { printk("this is work2->\n"); } int init_que(void) { //2. 创建工作 work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL); INIT_WORK(work1, work1_func); //3. 挂载(提交)工作,采用默认的工作队列,不需要创建工作队列 schedule_work(work1); //2. 创建工作 work2 = kmalloc(sizeof(struct work_struct),GFP_KERNEL); INIT_WORK(work2, work2_func); //3. 挂载(提交)工作 schedule_work(work2); return 0; } void clean_que(){ } module_init(init_que); module_exit(clean_que);
采用定时器来按键去抖
按键抖动按键所用开关为机械弹性开关,当机械触点断开、闭合时,由于机械触点的弹性作用,开关不会马上稳定地接通或断开。因而在闭合及断开的瞬间总是伴随有一连串的抖动。
按键去抖动的方法主要有二种,一种是硬件电路去抖;另一种就是软件延时去抖。而延时又一般分为二种,一种是for循环等待,另一种是定时器延时。在操作系统中,由于效率方面的原因,一般不允许使用for循环来等待,只能使用定时器。
内核定时器
Linux内核使用 struct timer_list 结构体 来描述一个定时器:
struct timer_list { struct list_head entry; unsigned long expires; void (*function)(unsigned long); unsigned long data; struct tvec_base *base; };
定时器范例代码见下方。
阻塞型驱动程序设计
阻塞必要性当一个设备无法立刻满足用户的读写请求时应当如何处理? 例如:调用read时,设备没有数据提供, 但以后可能会有;或者一个进程试图向设备写入数据,但是设备暂时没有准备好接收数据。当上述情况发生的时候,驱动程序应当(缺省地)阻塞进程,使它进入等待(睡眠)状态,直到请求可以得到满足。
内核等待队列
在实现阻塞驱动的过程中,也需要有一个“ 候车室 ”来安排被阻塞的进程“休息”,当唤醒它们的条件成熟时,则可以从“候车室”中将这些进程唤醒。而这个“候车室”就是等待队列。
1、定义等待队列
wait_queue_head_t my_queue
2、初始化等待队列
init_waitqueue_head(&my_queue)
3、定义+初始化等待队列
DECLARE_WAIT_QUEUE_HEAD(my_queue)
4、进入等待队列,睡眠
wait_event(queue,condition) /* 当condition(布尔表达式)为真时,立即返回;否则让进程进入TASK_UNINTERRUPTIBLE模式的睡眠,并挂在queue参数所指定的等待队列上。 */
wait_event_interruptible(queue,condition) /* 当condition(布尔表达式)为真时,立即返回;否则让进程进入TASK_INTERRUPTIBLE的睡眠,并挂在queue参数所指定的等待队列上。 */
int wait_event_killable(queue, condition) /* 当condition(一个布尔表达式)为真时,立即返回;否则让进程进入TASK_KILLABLE的睡眠,并挂在queue参数所指定的等待队列上。 */
5、从等待队列中唤醒进程
wake_up(wait_queue_t *q) /* 从等待队列q中唤醒状态为TASK_UNINTERRUPTIBLE, TASK_INTERRUPTIBLE , TASK_KILLABLE 的所有进程。 */
wake_up_interruptible(wait_queue_t *q) /* 从等待队列q中唤醒状态为TASK_INTERRUPTIBLE 的进程。 */
范例代码
驱动程序代码:#include <linux/module.h> #include <linux/init.h> #include <linux/miscdevice.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/fs.h> #include <asm/uaccess.h> #define GPFCON 0x56000050 //寄存器地址 #define GPFDAT 0x56000054 struct work_struct *work1; //工作结构体 struct timer_list buttons_timer; //定时器结构体 unsigned int *gpio_data; unsigned int key_num = 0; wait_queue_head_t key_q; //定义等待队列 void work1_func(struct work_struct *work) { mod_timer(&buttons_timer, jiffies + (HZ /10)); //启动定时器,100ms //jiffies是全局变量,表示当前时间。HZ 是 1 秒钟 } void buttons_timer_function(unsigned long data) //定时器超时函数 { unsigned int key_val; key_val = readw(gpio_data)&0x1; //定义两个按键 if (key_val == 0) key_num = 4; key_val = readw(gpio_data)&0x4; if (key_val == 0) key_num = 3; wake_up(&key_q); //唤醒等待队列中的进程 } irqreturn_t key_int(int irq, void *dev_id) { //1. 检测是否发生了按键中断 //2. 清除已经发生的按键中断 //3. 提交下半部(中断处理程序) schedule_work(work1); //return 0; return IRQ_HANDLED; } void key_hw_init() //硬件初始化函数 { unsigned int *gpio_config; unsigned short data; gpio_config = ioremap(GPFCON,4);//转化为虚拟地址 data = readw(gpio_config); //读出数据 data &= ~0b110011; //设置中断模式 data |= 0b100010; writew(data,gpio_config); //写回寄存器 gpio_data = ioremap(GPFDAT,4); } int key_open(struct inode *node,struct file *filp) { return 0; } ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos) //支持应用程序对设备文件的读取 { wait_event(key_q,key_num); //进入等待队列,睡眠 //在读数据时,如果没有数据可读,就需要进入等待队列 printk("in kernel :key num is %d\n",key_num); copy_to_user(buf, &key_num, 4); key_num = 0; return 4; } struct file_operations key_fops = { //设备操作函数集 .open = key_open, .read = key_read, }; struct miscdevice key_miscdev = { //混杂设备结构体 .minor = 200, .name = "key", .fops = &key_fops, }; static int button_init() { int ret; ret = misc_register(&key_miscdev); //注册混杂设备 if (ret !=0) printk("register fail!\n"); //注册中断处理程序,两个按键分属不同的中断 request_irq(IRQ_EINT0,key_int,IRQF_TRIGGER_FALLING,"key",(void *)4);//下降沿 request_irq(IRQ_EINT2,key_int,IRQF_TRIGGER_FALLING,"key",(void *)3); //按键硬件初始化 key_hw_init(); //创建工作,将剩余的中断处理工作放到work中 work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL); INIT_WORK(work1, work1_func); /* 初始化定时器 */ init_timer(&buttons_timer); buttons_timer.function = buttons_timer_function; //设置超时函数 /* 向内核注册一个定时器 */ add_timer(&buttons_timer); /* 初始化等待队列 */ init_waitqueue_head(&key_q); return 0; } static void button_exit() { misc_deregister(&key_miscdev); //注销混杂设备 } module_init(button_init); module_exit(button_exit);
应用程序代码:
#include <stdio.h> #include <stdlib.h> #include <errno.h> int main(int argc, char **argv) { int fd; int key_num; fd = open("/dev/2440key", 0); //需要在相应目录下创建设备文件, //混杂设备主设备号10,次设备号在驱动程序中设为200 if (fd<0) printf("open fail\n"); read(fd, &key_num, 4); printf("key is %d\n",key_num); close(fd); return 0; }
makefile文件
obj-m := key.o KDIR := /home/S5-driver/lesson7/linux-tq2440/ all: make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm clean: rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.bak *.order
相关文章推荐
- 12.按键驱动程序设计(1)-混杂设备驱动模型
- 第12课第4.1节 字符设备驱动程序之中断方式的按键驱动_Linux异常处理结构
- 第12课第4.2节 字符设备驱动程序之中断方式的按键驱动_Linux中断处理结构
- 字符设备驱动之按键处理二(中断处理的按键驱动程序)
- Linux按键驱动程序设计(1)-混杂设备驱动模型
- 字符设备驱动程序开发之基于中断的按键驱动加去抖动
- 【Tiny6410 And Linux】—(2.3)—使用工作队列处理按键中断——代码
- 基于platform总线的中断(按键)字符设备驱动设计
- 字符设备驱动程序按键驱动---中断方式
- 中断分层处理-工作队列
- 【Tiny6410 And Linux】—(2.3)—使用工作队列处理按键中断——原理
- Linux设备驱动开发基础---字符设备驱动程序开发之基于中断的按键驱动
- 嵌入式学习-驱动开发-lesson3-混杂设备驱动模型与linux中断处理流程
- 12.按键驱动程序设计(2)-Linux中断处理
- 基于platform总线的中断(按键)字符设备驱动设计
- OK6410中断按键 混杂设备驱动
- 12.按键驱动程序设计(4)-中断分层
- 字符设备驱动程序之中断方式的按键驱动
- Linux驱动开发-中断分层机制_工作队列 笔记 7
- 字符设备驱动笔记——中断方式按键驱动之linux中断处理结构(五)