【转】深度解析linux设备驱动中断程序

baobeix

1.ARM裸机中断程序流程分析

1.1.中断统一入口
1.2.事先注册中断处理程序
1.3.根据中断源的编号处理程序

2.linux系统中断处理流程分析2.1中断流程概述

Linux系统irq.svc中断入口获得中断源的编号，根据中断号找到irq_desc结构，在irq_desc结构中找到action结构，执行用户注册中断处理函数
驱动程序支持中断应该做什么？
驱动程序实现中断处理程序，注册到中断号所对应irq_desc中
linux设备驱动程序中包含中断处理程序中断注册，中断处理函数实现，注销处理

2.2linux系统中断处理实现

2.2.1中断注册使用request_irq函数用于中断注册
int request_irq(unsigned int irq,void (handler)(int, void, structpt_regs *),unsigned long flags,const char *devname,void *dev_id)
返回0表示成功，或者返回一个错误码
参数：
unsigned int irq
中断号。
void (handler)(int,void )
中断处理函数。
unsigned long flags
与中断管理有关的各种选项。
const char * devname
设备名
void *dev_id
共享中断时使用
在flags参数中，可以选择一些与中断管理有关的选项,如:
IRQF_DISABLED（SA_INTERRUPT）
如果设置该位，表示是一个“快速”中断处理程序；如果没有设置这位，那么是一个“慢速”中断处理程
序。
IRQF_SHARED（SA_SHIRQ）
该位表明该中断号是多个设备共享的。
也可选择为中断触发标志：IRQF_TRIGGER_FALLING（下降沿）
快/慢速中断的主要区别在于：快速中断保证中断处理的原子性(不被打断)，而慢速中断则不保证。换句话说，也就是“开启中断”标志位(处理器IF)
在运行快速中断处理程序时是关闭的，因此在服务该中断时,不会被其他类型的中断打断;而调用慢速中断处理时，其它类型的中断仍可以得到服务。
2.2.2中断处理程序
中断处理程序的特别之处是在中断上下文中运行的，它的行为受到某些限制：1.不能使用可能引起阻塞的函数，2.不能使用肯呢过引起调度的函数
中断处理程序流程
1.检查设备是否产生了中断
2.清除中断产生标志
3.相应的硬件操作
2.2.3.注销中断
void free_irq(unsigned int irq,void *dev_id)

3.按键中断处理框架代码实现

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/miscdevice.h>
   
4. #include<linux/fs.h>
   
5. #include<linux/interrupt.h>
   
6. #include<linux/irq.h>
   
7. #include<linux/io.h>
   
8. #include<linux/slab.h>
   
9. #include<linux/vmalloc.h>
   
10. MODULE_LICENSE("GPL");
    
11. 
    
12. #define GPX1CON 0x11000C20
    
13. //home按键的物理基地址
    
14. unsigned int *gpx1con;
    
15. irqreturn_t key_int(int irq,void *dev_id)
    
16. {
    
17.         //检测是否发生了按键中断
    
18. 
    
19. 
    
20. 
    
21.         //清除按键中断
    
22. 
    
23. 
    
24.         //打印键值
    
25.           printk("press the key\n");
    
26.          return 0;
    
27. }
    
28. void keyinit()
    
29. {
    
30.     gpx1con = ioremap(GPX1CON,4);//物理地址映射为虚拟地址
    
31.     writel(readl(gpx1con)&~(0xf<<4)|(0xf<<4),gpx1con);//将GPIO功能设置为输入
    
32. }
    
33. int key_open(struct inode *node,struct file *filp)
    
34. {
    
35.     return 0;   
    
36. }
    
37. struct file_operations key_fops =
    
38. {
    
39.     .open = key_open,   
    
40. };
    
41. struct miscdevice key_miscdev = {
    
42. 
    
43.     .minor = 200,
    
44.     .name = "mykey",
    
45.     .fops = &key_fops,
    
46. };
    
47. static int key_init()
    
48. {
    
49. 
    
50.     misc_register(&key_miscdev);//注册杂项设备
    
51.     keyinit();按键的硬件初始化
    
52.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);//注册中断
    
53.     return 0;
    
54. }
    
55. 
    
56. static void key_exit()
    
57. {
    
58.     misc_deregister(&key_miscdev);//注销杂项设备
    
59.     free_irq(IRQ_EINT(9),0);//释放中断
    
60. }
    
61. 
    
62. module_init(key_init);
    
63. module_exit(key_exit);

复制代码

4.中断分层4.1.中断嵌套4.2.中断分层方式4.3.使用工作队列实现分层4.1中断嵌套

linux如何处理中断嵌套？
一种类型的中断发生的时候，又产生了其他的中断，其他的中断可以是同类型的，也可以是不同类型的。
不同的系统处理方式不同
慢速中断：在进行中断处理的时候，中断的总开关不关闭，允许其他类型中断产生
情况1：串口中断处理程序运行的时候，运行一段时间，又来一个网卡中断，LINUX系统暂停串口中断处理程序，转去执行网卡处理程序，执行完毕，又去执行串口中断处理程序。
情况2：串口中断处理程序运行的时候，运行一段时间，又来一个串口中断，不会执行新的串口中断，linux系统在处理同类型的中断时，不会处理新的中断，会忽略。
快速中断：在进行中断处理的时候，中断的总开关关闭，不允许其他类型中断产生
情况1：串口中断处理程序运行的时候，运行一段时间，又来一个网卡中断，LINUX系统继续串口中断处理程序，忽略网卡处理程序。
情况2：串口中断处理程序运行的时候，运行一段时间，又来一个串口中断，不会执行新的串口中断，linux系统在处理同类型的中断时，不会处理新的中断，会忽略。
4.2中断分层：

4.2.1linux如何处理中断丢失的问题？

方法：将中断处理程序时间减短，减小中断丢失的概率
如何将中断处理程序的时间尽量减短？
中断处理程序一般做两部分工作，一部分是和硬件相关的，另外一类部分和硬件不密切相关。于是把中断处理程序分成两部分，上半部分做与硬件相关的工作，因为硬件相关工作必须在中断处理程序上下文中进行。下半部分与硬件不相关的抛给内核处理。
上半部：当中断发生时，它进行相应地硬件读写，并“登记”该中断。通常由中断处理程序充当上半部。
下半部：在系统空闲的时候对上半部“登记”的中断进行后续处理。

4.2.2中断分层方式

中断分层的方式有三种
1软中断，2tasklet，3工作队列现在最常用的方式为工作队列
工作队列是一种将任务推后执行的形式，他把推后的任务交由一个内核线程去执行。这样下半部会在进程上下文执行，它允许重新调度甚至睡眠。每个被推后的任务叫做“工作”，由这些工作组成的队列称为工作队列。
创建一个工作队列，3核的CPU，每个CPU上都会挂再一个链表，链表上连的就是工作，将下半部的工作添加到链表中买，内核为每一个链表创建一个线程，当内核空闲时，就处理下半部工作。

4.3工作队列的使用

Linux内核使用workqueue_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);
工作队列使用流程：
step1. 创建工作队列
create_workqueue
step2. 创建工作
INIT_WORK
step3. 提交工作
queue_work

4.4工作队列代码实现

1. #include<linux/init.h>
   
2. #include<linux/module.h>
   
3. #include<linux/slab.h>
   
4. MODULE_LICENSE("GPL");
   
5. struct workqueue_struct *my_wq;
   
6. struct work_struct *work1;
   
7. struct work_struct *work2;
   
8. static void work1_fun(struct work_struct *work)
   
9. {
   
10. 
    
11.     printk("this is work1\n");
    
12. }
    
13. static void work2_fun(struct work_struct *work)
    
14. {
    
15.     printk("this is work2\n");
    
16. 
    
17. }
    
18. MODULE_LICENSE("GPL");
    
19. 
    
20. int init_queue(void)
    
21. {
    
22.     //创建工作队列
    
23.     //my_wq = create_workqueue("mywq");
    
24. 
    
25.     //创建工作
    
26.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
    
27.     INIT_WORK(work1,work1_fun);
    
28.     //挂载工作
    
29.     //queue_work(my_wq,work1);
    
30.     schedule_work(work1);
    
31.     //创建工作
    
32.     work2 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
    
33.     INIT_WORK(work2,work2_fun);
    
34.     //挂载工作
    
35.     //queue_work(my_wq,work2);
    
36.     schedule_work(work2);
    
37. }
    
38. 
    
39. void clean_queue(void)
    
40. {
    
41. 
    
42. }
    
43. module_init(init_queue);
    
44. module_exit(clean_queue);
    

复制代码

4.5内核定时器

linux内核使用struct timer_list来描述定时器：

1. struct timer_list {
   
2. /*
   
3. * All fields that change during normal runtime grouped to the
   
4. * same cacheline
   
5. */
   
6. struct list_head entry;
   
7. unsigned long expires;
   
8. struct tvec_base *base;
   
9. 
   
10. void (*function)(unsigned long);
    
11. unsigned long data;
    
12. }；

复制代码

定时器使用流程
1.定义定时器变量struct timer_list
2初始化定时器
2.1init_timer的初始化
2.2设置超时函数
3.add_timer注册定时器
4.mod_timer启动定时器

按键驱动的分层实现

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/miscdevice.h>
   
4. #include<linux/fs.h>
   
5. #include<linux/interrupt.h>
   
6. #include<linux/io.h>
   
7. #include<linux/irq.h>
   
8. #include<linux/slab.h>
   
9. #include<linux/vmalloc.h>
   
10. #include<linux/uaccess.h>
    
11. MODULE_LICENSE("GPL");
    
12. #define GPX1CON 0x11000C20
    
13. #define GPX1DAT 0x11000C24
    
14. unsigned int *gpx1con;
    
15. unsigned int *gpx1dat;
    
16. unsigned int key_num;
    
17. 
    
18. struct work_struct *work1;
    
19. 
    
20. struct work_struct *work1;
    
21. struct timer_list key_timer;//定义定时器变量struct timer_list
    
22. void work1_fun(struct work_struct *work)
    
23. {
    
24.     mod_timer(&key_timer,jiffies+HZ/10);//mod_timer启动定时器
    
25.     //  printk("press the key\n");
    
26. }
    
27. void key_timer_func(unsigned long data)//超时函数
    
28. {   unsigned int key_val;
    
29.     key_val = readl(gpx1dat)&(0x1<<1);
    
30.     if(key_val==0)
    
31.     {
    
32.         key_num = 1;
    
33.     }
    
34.         //printk("\nhome key down\n");
    
35. 
    
36.     key_val = readl(gpx1dat)&(0x1<<2);
    
37.     if(key_val==0)
    
38.     {
    
39.         key_num = 2;
    
40.     }      
    
41. //printk("\n back key down\n");
    
42. 
    
43. }
    
44. irqreturn_t key_int(int irq,void *dev_id)
    
45. {
    
46.         //检测是否发生了按键中断
    
47.         //清除按键中断
    
48.         //提交下半部分   
    
49.         schedule_work(work1);
    
50.         //printk("press the key\n");
    
51. 
    
52.         return 0;
    
53. }
    
54. void keyinit()
    
55. {
    
56.     gpx1con = ioremap(GPX1CON,4);
    
57. 
    
58.     writel(readl(gpx1con)&~(0xff<<4)|(0xff<<4),gpx1con);
    
59.     gpx1dat = ioremap(GPX1DAT,4);
    
60. 
    
61. 
    
62. }
    
63. ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
    
64. {
    
65.     printk("in kernel :key num is %d\n",key_num);   
    
66.     copy_to_user(buf, &key_num, 4);
    
67. 
    
68.     return 4;
    
69. }
    
70. int key_open(struct inode *node,struct file *filp)
    
71. {
    
72.     return 0;   
    
73. }
    
74. 
    
75. struct file_operations key_fops =
    
76. {
    
77.     .open = key_open,
    
78.     .read = key_read,   
    
79. };
    
80. struct miscdevice key_miscdev = {
    
81. 
    
82.     .minor = 200,
    
83.     .name = "mykey",
    
84.     .fops = &key_fops,
    
85. };
    
86. static int key_init()
    
87. {
    
88. 
    
89.     misc_register(&key_miscdev);
    
90.      keyinit();
    
91. 
    
92.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);
    
93. 
    
94.     request_irq(IRQ_EINT(10),key_int,IRQF_TRIGGER_FALLING,"mykey",0);
    
95. 
    
96.     //创建工作
    
97.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
    
98.     INIT_WORK(work1,work1_fun);
    
99. 
    
100.     init_timer(&key_timer);//init_timer的初始化
     
101.     key_timer.function = key_timer_func;//设置超时函数   
     
102.     add_timer(&key_timer);//add_timer注册定时器
     
103.     return 0;
     
104. }
     
105. 
     
106. static void key_exit()
     
107. {
     
108.     misc_deregister(&key_miscdev);
     
109.     free_irq(IRQ_EINT(9),0);
     
110.     free_irq(IRQ_EINT(10),0);
     
111. }
     
112. 
     
113. module_init(key_init);
     
114. module_exit(key_exit);  

复制代码

5.阻塞型驱动设计5.1.阻塞的必要性

当应用程序调用read读取数据时，设备没有数据提供，但以后可能会有，或者进程正在试图去写，但设备暂时没有准备好去接收数据。当以上情况发生时。驱动程序应当（缺省地）阻塞进程，使它进入等待（睡眠）状态，直到请求得到满足。内核等待队列像是候车室
1.读数据2.睡眠3.唤醒

5.2.内核等待队列

进程在哪里睡眠，就是内核等待队列
5.2.1、定义等待队列
wait_queue_head_t my_queue
5.2.2、初始化等待队列
init_waitqueue_head(&my_queue)
5.2.3、定义+初始化等待队列
DECLARE_WAIT_QUEUE_HEAD(my_queue)
5.2.4、进入等待队列，睡眠
wait_event(queue,condition)
当condition(布尔表达式)为真时，立即返回；否则让进程进入TASK_UNINTERRUPTIBLE模式的睡眠，并挂在queue参数所指定的等待队列上。
wait_event_interruptible(queue,condition)当condition(布尔表达式)为真时，立即返回；否则让进程进入TASK_INTERRUPTIBLE的睡眠，并挂在queue参数所指定的等待队列上。
5.2.5从等待队列中唤醒进程
wake_up(wait_queue_t *q)
从等待队列q中唤醒状态为TASK_UNINTERRUPTIBLE，TASK_INTERRUPTIBLE，TASK_KILLABLE 的所有进程。wake_up_interruptible(wait_queue_t *q)从等待队列q中唤醒状态为TASK_INTERRUPTIBLE 的进程

5.3.阻塞优化驱动

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/miscdevice.h>
   
4. #include<linux/fs.h>
   
5. #include<linux/interrupt.h>
   
6. #include<linux/io.h>
   
7. #include<linux/irq.h>
   
8. #include<linux/slab.h>
   
9. #include<linux/vmalloc.h>
   
10. #include<asm/uaccess.h>
    
11. #include <linux/sched.h>
    
12. MODULE_LICENSE("GPL");
    
13. #define GPX1CON 0x11000C20
    
14. #define GPX1DAT 0x11000C24
    
15. unsigned int *gpx1con;
    
16. unsigned int *gpx1dat;
    
17. unsigned int key_num=0;
    
18. wait_queue_head_t key_queue;//定义等待队列
    
19. struct work_struct *work1;
    
20. 
    
21. struct timer_list key_timer;
    
22. void work1_fun(struct work_struct *work)
    
23. {
    
24.     mod_timer(&key_timer,jiffies+HZ/10);
    
25.     //  printk("press the key\n");
    
26. }
    
27. void key_timer_func(unsigned long data)
    
28. {   unsigned int key_val;
    
29.     key_val = readl(gpx1dat)&(0x1<<1);
    
30.     if(key_val==0)
    
31.     {
    
32.         key_num = 1;
    
33.     }
    
34.         //printk("\nhome key down\n");
    
35.     key_val = readl(gpx1dat)&(0x1<<2);
    
36.     if(key_val==0)
    
37.     {
    
38.         key_num = 2;
    
39.     }      
    
40.     wake_up(&key_queue);//按键按下则唤醒进程
    
41. //printk("\n back key down\n");
    
42. }
    
43. irqreturn_t key_int(int irq,void *dev_id)
    
44. {
    
45.         //检测是否发生了按键中断
    
46. 
    
47. 
    
48. 
    
49.         //清除按键中断
    
50. 
    
51. 
    
52.         //提交下半部分   
    
53.         schedule_work(work1);
    
54.         //printk("press the key\n");
    
55. 
    
56.         return 0;
    
57. }
    
58. void keyinit()
    
59. {
    
60.     gpx1con = ioremap(GPX1CON,4);
    
61. 
    
62.     writel(readl(gpx1con)&~(0xff<<4)|(0xff<<4),gpx1con);
    
63.     gpx1dat = ioremap(GPX1DAT,4);
    
64. 
    
65. 
    
66. }
    
67. ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
    
68. {   
    
69.     wait_event(key_queue,key_num);//进入等待队列，key_num是进入等待队列的条件
    
70.     printk("in kernel :key num is %d\n",key_num);   
    
71.     copy_to_user(buf, &key_num, 4);
    
72.     key_num = 0;
    
73.     return 4;
    
74. }
    
75. int key_open(struct inode *node,struct file *filp)
    
76. {
    
77.     return 0;   
    
78. }
    
79. struct file_operations key_fops =
    
80. {
    
81.     .open = key_open,
    
82.     .read = key_read,   
    
83. };
    
84. struct miscdevice key_miscdev = {
    
85. 
    
86.     .minor = 200,
    
87.     .name = "mykey",
    
88.     .fops = &key_fops,
    
89. };
    
90. static int mykey_init()
    
91. {
    
92. 
    
93.     misc_register(&key_miscdev);
    
94.      keyinit();
    
95. 
    
96.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);
    
97. 
    
98.     request_irq(IRQ_EINT(10),key_int,IRQF_TRIGGER_FALLING,"mykey",0);
    
99. 
    
100.     //创建工作
     
101.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
     
102.     INIT_WORK(work1,work1_fun);
     
103.     //初始化定时器
     
104.     init_timer(&key_timer);
     
105.     //添加超时函数
     
106.     key_timer.function = key_timer_func;
     
107.     //向内核注册
     
108.     add_timer(&key_timer);
     
109.     //初始化等待队列
     
110.     init_waitqueue_head(&key_queue);
     
111.     return 0;
     
112. }
     
113. 
     
114. static void mykey_exit()
     
115. {
     
116.     misc_deregister(&key_miscdev);
     
117.     free_irq(IRQ_EINT(9),0);
     
118.     free_irq(IRQ_EINT(10),0);
     
119. }
     
120. 
     
121. module_init(mykey_init);
     
122. module_exit(mykey_exit);  

复制代码

应用程序调用

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include <errno.h>
   
4. 
   
5. int main(int argc,char **argv)
   
6. {
   
7.     int fd;
   
8.     int key_num;
   
9.     //1.打开设备
   
10.     fd = open("/dev/mykey",0);
    
11.     if(fd<0)
    
12.         printf("open device fail\n");
    
13. 
    
14.     //读取设备
    
15.     read(fd,&key_num,4);
    
16.     printf("key is %d\n",key_num);
    
17. 
    
18. 
    
19.     //关闭设备
    
20.     close(fd);
    
21.     return 0;
    
22. }

复制代码

当应用程序调用驱动程序读取按键值，此时按键没有按下，则测试驱动程序使其应用程序进入等待状态，当有按键按下，则唤醒程序读取键值。