登录/注册
与非网论坛 »首页 › 厂商小组 › 其他 › 【转】深度解析linux设备驱动中断程序

赞

回答

收藏

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

其他 其他 2485 人阅读 | 0 人回复 | 2017-08-09

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");

  12. #define GPX1CON 0x11000C20
  13. //home按键的物理基地址
  14. unsigned int *gpx1con;
  15. irqreturn_t key_int(int irq,void *dev_id)
  16. {
  17.         //检测是否发生了按键中断



  21.         //清除按键中断


  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 = {

  43.     .minor = 200,
  44.     .name = "mykey",
  45.     .fops = &key_fops,
  46. };
  47. static int key_init()
  48. {

  50.     misc_register(&key_miscdev);//注册杂项设备
  51.     keyinit();按键的硬件初始化
  52.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);//注册中断
  53.     return 0;
  54. }

  56. static void key_exit()
  57. {
  58.     misc_deregister(&key_miscdev);//注销杂项设备
  59.     free_irq(IRQ_EINT(9),0);//释放中断
  60. }

  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. {

  11.     printk("this is work1\n");
  12. }
  13. static void work2_fun(struct work_struct *work)
  14. {
  15.     printk("this is work2\n");

  17. }
  18. MODULE_LICENSE("GPL");

  20. int init_queue(void)
  21. {
  22.     //创建工作队列
  23.     //my_wq = create_workqueue("mywq");

  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. }

  39. void clean_queue(void)
  40. {

  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;

  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;

  18. struct work_struct *work1;

  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");

  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");

  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");

  52.         return 0;
  53. }
  54. void keyinit()
  55. {
  56.     gpx1con = ioremap(GPX1CON,4);

  58.     writel(readl(gpx1con)&~(0xff<<4)|(0xff<<4),gpx1con);
  59.     gpx1dat = ioremap(GPX1DAT,4);


  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);

  68.     return 4;
  69. }
  70. int key_open(struct inode *node,struct file *filp)
  71. {
  72.     return 0;   
  73. }

  75. struct file_operations key_fops =
  76. {
  77.     .open = key_open,
  78.     .read = key_read,   
  79. };
  80. struct miscdevice key_miscdev = {

  82.     .minor = 200,
  83.     .name = "mykey",
  84.     .fops = &key_fops,
  85. };
  86. static int key_init()
  87. {

  89.     misc_register(&key_miscdev);
  90.      keyinit();

  92.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);

  94.     request_irq(IRQ_EINT(10),key_int,IRQF_TRIGGER_FALLING,"mykey",0);

  96.     //创建工作
  97.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
  98.     INIT_WORK(work1,work1_fun);

  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. }

  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. }

  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;

  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.         //检测是否发生了按键中断



  49.         //清除按键中断


  52.         //提交下半部分   
  53.         schedule_work(work1);
  54.         //printk("press the key\n");

  56.         return 0;
  57. }
  58. void keyinit()
  59. {
  60.     gpx1con = ioremap(GPX1CON,4);

  62.     writel(readl(gpx1con)&~(0xff<<4)|(0xff<<4),gpx1con);
  63.     gpx1dat = ioremap(GPX1DAT,4);


  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 = {

  86.     .minor = 200,
  87.     .name = "mykey",
  88.     .fops = &key_fops,
  89. };
  90. static int mykey_init()
  91. {

  93.     misc_register(&key_miscdev);
  94.      keyinit();

  96.     request_irq(IRQ_EINT(9),key_int,IRQF_TRIGGER_FALLING,"mykey",0);

  98.     request_irq(IRQ_EINT(10),key_int,IRQF_TRIGGER_FALLING,"mykey",0);

  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. }

  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. }

  121. module_init(mykey_init);
  122. module_exit(mykey_exit);  
复制代码
应用程序调用
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include <errno.h>

  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");

  14.     //读取设备
  15.     read(fd,&key_num,4);
  16.     printf("key is %d\n",key_num);


  19.     //关闭设备
  20.     close(fd);
  21.     return 0;
  22. }
复制代码
当应用程序调用驱动程序读取按键值，此时按键没有按下，则测试驱动程序使其应用程序进入等待状态，当有按键按下，则唤醒程序读取键值。


关注下面的标签，发现更多相似文章
中断
收藏1 转播 分享 顶 踩
分享到：
回复

使用道具 举报

返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 注册/登录

本版积分规则

相关帖子
avatar
369 积分
28 主题
+ 关注
热门推荐
关闭

站长推荐上一条 /2 下一条

  • 手机版| 小黑屋|

© 2010 - 2025 苏州灵动帧格网络科技有限公司 版权所有 ICP经营许可证 苏B2-20140176 | 苏ICP备14012660号-6 | 苏公网安备 32059002001874号