首页 / LINUX / Linux中断子系统分析之（4）：驱动程序申请中断

Linux中断子系统分析之（4）：驱动程序申请中断

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Linux中断子系统分析之（4）：驱动程序申请中断，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9868字，纯文字阅读大概需要15分钟。

内容图文

Linux中断子系统分析之（1）：整体框架
 Linux中断子系统分析之（2）：通用的中断处理
 Linux中断子系统分析之（3）：irq domain

中断子系统中有一个重要的设计机制，那就是Top-half和Bottom-half，将紧急的工作放置在Top-half中来处理，而将耗时的工作放置在Bottom-half中来处理。

如果中断不分上下半部处理，那么意味着只有等上一个中断完成处理后才会打开中断，下一个中断才能得到响应。当某个中断处理处理时间较长时，很有可能就会造成其他中断丢失而无法响应，影响系统性能。

中断分成上下半部处理可以提高中断的响应能力，在上半部处理完成后便将中断打开，这样就可以响应其他中断了，等到中断退出的时候再进行下半部的处理。为了进一步提高的实时性，linux内核还提供了中断线程化的机制。

熟悉设备驱动的应该都清楚，经常会在驱动程序中调用request_irq接口或者request_threaded_irq接口来注册设备的中断处理函数。

在讲具体的注册流程前，先看一下主要的中断标志位：

//中断触发类型
#define IRQF_TRIGGER_RISING	0x00000001     //上升沿触发     
#define IRQF_TRIGGER_FALLING	0x00000002 //下降沿触发
#define IRQF_TRIGGER_HIGH	0x00000004     //高电平触发
#define IRQF_TRIGGER_LOW	0x00000008     //低电平


#define IRQF_ONESHOT		  0x00002000      //一次性触发的中断，不能嵌套
/* 为了确保：
	1. 在硬件中断处理完成后才能打开中断，中断上半部肯定是这样的，除非在上半部开中断
	2. 在中断线程化中保持关闭状态，直到该中断源上的所有thread_fn函数都执行完

   驱动程序可以设置IRQF_ONESHOT标志
*/
#define IRQF_SHARED		    0x00000080      //多个设备共享一个中断号，需要外设硬件支持
#define IRQF_PERCPU		    0x00000400      //属于特定CPU的中断
#define IRQF_NOBALANCING	0x00000800      //禁止在CPU之间进行中断均衡处理
#define IRQF_NO_THREAD		0x00010000      //禁止中断线程化

request_irq是老旧的接口了，这里就分析request_threaded_irq这个函数：

/* irq，软件中断号
   handler，primary handler，处理一些紧急的事情，上半部              
	 flags，一些标志位
	 thread_fn，threaded interrupt handler，系统会创建线程执行该函数
	 devname，设备的名字
	 dev_id，对于共享中断，需要传入dev_id，标识自己
  
 */
int request_threaded_irq(unsigned int irq, irq_handler_t handler,
			 irq_handler_t thread_fn, unsigned long irqflags,
			 const char *devname, void *dev_id)
{
	struct irqaction *action;
	struct irq_desc *desc;
	int retval;

	if (irq == IRQ_NOTCONNECTED)
		return -ENOTCONN;

	//对于共享中断，要传入dev_id
	if (((irqflags & IRQF_SHARED) && !dev_id) ||
	    (!(irqflags & IRQF_SHARED) && (irqflags & IRQF_COND_SUSPEND)) ||
	    ((irqflags & IRQF_NO_SUSPEND) && (irqflags & IRQF_COND_SUSPEND)))
		return -EINVAL;

	//通过软件中断号获取irq_desc 
	desc = irq_to_desc(irq);
	if (!desc)
		return -EINVAL;

	......

	//handler、thread_fn不能同时为空
	if (!handler) {
		if (!thread_fn)
			return -EINVAL;
		handler = irq_default_primary_handler; 
	}

	//分配一个irqaction 
	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
	if (!action)
		return -ENOMEM;

	//根据传入的参数初始化irqaction 
	action->handler = handler;
	action->thread_fn = thread_fn;
	action->flags = irqflags;
	action->name = devname;
	action->dev_id = dev_id;

	......

	chip_bus_lock(desc);
	//设置
	retval = __setup_irq(irq, desc, action);
	chip_bus_sync_unlock(desc);

	......

	return retval;
}

传入request_threaded_irq的primary handler和threaded handler参数有下面四种组合：
Linux中断子系统分析之（4）：驱动程序申请中断 - 文章图片
__setup_irq:

static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{
	struct irqaction *old, **old_ptr;
	unsigned long flags, thread_mask = 0;
	int ret, nested, shared = 0;
	cpumask_var_t mask;

	......

	new->irq = irq;

	
	if (!(new->flags & IRQF_TRIGGER_MASK))
		new->flags |= irqd_get_trigger_type(&desc->irq_data);

	/* nested类型的中断，parent IRQ的threaded handler通过handle_nested_irq函数
     调用该中断的threaded interrupt handler */
	nested = irq_settings_is_nested_thread(desc);
	if (nested) {
		if (!new->thread_fn) {  //nested类型的中断只需提供thread_fn
			ret = -EINVAL;    
			goto out_mput;
		}
	
		new->handler = irq_nested_primary_handler;
	} else {
		if (irq_settings_can_thread(desc)) {
			ret = irq_setup_forced_threading(new);  //强制中断线程化
			if (ret)
				goto out_mput;
		}
	}

	
	//创建线程
	if (new->thread_fn && !nested) {
		ret = setup_irq_thread(new, irq, false);
		if (ret)
			goto out_mput;
		if (new->secondary) {
			ret = setup_irq_thread(new->secondary, irq, true);
			if (ret)
				goto out_thread;
		}
	}

	......

	raw_spin_lock_irqsave(&desc->lock, flags);
	old_ptr = &desc->action;
	old = *old_ptr;
	if (old) {   
	//old不为NULL，表示为共享中断，则每一个irqaction的触发方式要相同，相同的类型中断
		if (!((old->flags & new->flags) & IRQF_SHARED) ||
		    ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK) ||
		    ((old->flags ^ new->flags) & IRQF_ONESHOT))
			goto mismatch;

		/* All handlers must agree on per-cpuness */
		if ((old->flags & IRQF_PERCPU) !=
		    (new->flags & IRQF_PERCPU))
			goto mismatch;


		do {

			thread_mask |= old->thread_mask;
			old_ptr = &old->next;
			old = *old_ptr;  
		} while (old);
		shared = 1;  //shared为1，标志为共享中断
	}


	......

	if (!shared) { //非共享中断 
		
		......

		/* 设置中断触发类型 */
		if (new->flags & IRQF_TRIGGER_MASK) {
			ret = __irq_set_trigger(desc,
						new->flags & IRQF_TRIGGER_MASK);

			......

		}

		......

		//启动中断
		if (irq_settings_can_autoenable(desc))
			irq_startup(desc, true);
		else
			/* Undo nested disables: */
			desc->depth = 1;

		......

	} else if (new->flags & IRQF_TRIGGER_MASK) { 
		......

	}

	*old_ptr = new;  //把new的irqaction挂在irq_desc的action链表

	......

	if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
		desc->istate &= ~IRQS_SPURIOUS_DISABLED;
		__enable_irq(desc);    //使能中断
	}

	raw_spin_unlock_irqrestore(&desc->lock, flags);


	//唤醒中断线程
	if (new->thread)
		wake_up_process(new->thread); 
	if (new->secondary)
		wake_up_process(new->secondary->thread);


	......

}

强制中断线程化：

static int irq_setup_forced_threading(struct irqaction *new)
{
	//如果打开了CONFIG_IRQ_FORCED_THREADING配置项，force_irqthreads总是为1
	if (!force_irqthreads)
		return 0;
	
	if (new->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT))
		return 0;      //IRQF_NO_THREAD即不想中断线程化

	new->flags |= IRQF_ONESHOT;

	/* 如果调用request_threaded_irq都传入了primary handler和threaded handler参数
     则primary handler和threaded handler都会在进程上下文里执行
   */
	if (new->handler != irq_default_primary_handler && new->thread_fn) {
		new->secondary = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
		if (!new->secondary)
			return -ENOMEM;
		new->secondary->handler = irq_forced_secondary_handler;
		new->secondary->thread_fn = new->thread_fn;
		new->secondary->dev_id = new->dev_id;
		new->secondary->irq = new->irq;
		new->secondary->name = new->name;
	}

	set_bit(IRQTF_FORCED_THREAD, &new->thread_flags);
	new->thread_fn = new->handler;
	new->handler = irq_default_primary_handler; 
	return 0;
}

创建中断线程：

static int
setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
{
	struct task_struct *t;
	struct sched_param param = {
		.sched_priority = MAX_USER_RT_PRIO/2,
	};

	//创建线程，执行函数为irq_thread
	if (!secondary) {
		t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
				   new->name);
	} else {
		t = kthread_create(irq_thread, new, "irq/%d-s-%s", irq,
				   new->name); 
		param.sched_priority -= 1;
	}

	......
	
	sched_setscheduler_nocheck(t, SCHED_FIFO, &param);


	get_task_struct(t);
	new->thread = t;

	set_bit(IRQTF_AFFINITY, &new->thread_flags);
	return 0;
}

来张图：
Linux中断子系统分析之（4）：驱动程序申请中断 - 文章图片

下面讲讲中断线程的唤醒流程，举个例子，如下场景：
某irq的irq_desc里的handle_irq设置为handle_simple_irq，用于简易流控处理(当然具体设置成什么函数，取决于中断控制器驱动程序，在映射阶段设置的)，调用request_threaded_irq注册该irq的中断服务例程时，未设置primary handler，设置了threaded handler(xxx_threaded_handler)，那么创建的irqaction里的primary handler会设置为irq_default_primary_handler，并会创建一个线程，执行函数为irq_thead。
Linux中断子系统分析之（4）：驱动程序申请中断 - 文章图片
看看irq_default_primary_handler：

static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
{
	return IRQ_WAKE_THREAD;
}

该irq到来时，会调用根据irq找到对应的irq_desc执行里面的handle_irq，即handle_simple_irq：
Linux中断子系统分析之（4）：驱动程序申请中断 - 文章图片
执行到__handle_irq_event_percpu函数：

irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{
	irqreturn_t retval = IRQ_NONE;
	unsigned int irq = desc->irq_data.irq;
	struct irqaction *action;

	//遍历irq_desc的action链表
	for_each_action_of_desc(desc, action) {
		irqreturn_t res;

		......
		//执行irqaction里的handler，即irq_default_primary_handler，该函数直接返回IRQ_WAKE_THREAD
		res = action->handler(irq, action->dev_id); 
		
		......

		switch (res) {
		case IRQ_WAKE_THREAD:
			......
			__irq_wake_thread(desc, action); //handler函数返回IRQ_WAKE_THREAD，则唤醒进程

		case IRQ_HANDLED:
			*flags |= action->flags;
			break;

		default:
			break;
		}

		retval |= res;
	}

	return retval;
}

__irq_wake_thread：

void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
{
	......
	//设置thread_flags的IRQTF_RUNTHREAD位
	if (test_and_set_bit(IRQTF_RUNTHREAD, &action->thread_flags))
		return;


	desc->threads_oneshot |= action->thread_mask;


	atomic_inc(&desc->threads_active);
	
	//唤醒中断线程
	wake_up_process(action->thread);
}

中断线程的执行函数为irq_thread：
Linux中断子系统分析之（4）：驱动程序申请中断 - 文章图片

static int irq_thread(void *data)
{
	struct callback_head on_exit_work;
	struct irqaction *action = data;
	struct irq_desc *desc = irq_to_desc(action->irq);
	irqreturn_t (*handler_fn)(struct irq_desc *desc,
			struct irqaction *action);

	if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,
					&action->thread_flags))
		handler_fn = irq_forced_thread_fn;
	else
		handler_fn = irq_thread_fn;

	......

	//等待中断来临
	while (!irq_wait_for_interrupt(action)) {
		irqreturn_t action_ret;

		......
		
		action_ret = handler_fn(desc, action);
		if (action_ret == IRQ_HANDLED)
			atomic_inc(&desc->threads_handled);
		if (action_ret == IRQ_WAKE_THREAD)
			irq_wake_secondary(desc, action);

		wake_threads_waitq(desc);
	}

	......
}

等待中断来临：

static int irq_wait_for_interrupt(struct irqaction *action)
{
	set_current_state(TASK_INTERRUPTIBLE);

	while (!kthread_should_stop()) {

		//如果thread_flags的IRQTF_RUNTHREAD位置1表示中断来了
		if (test_and_clear_bit(IRQTF_RUNTHREAD,
				       &action->thread_flags)) {
			__set_current_state(TASK_RUNNING);
			return 0;
		}
		//中断没来则进程睡眠
		schedule();
		set_current_state(TASK_INTERRUPTIBLE);
	}
	__set_current_state(TASK_RUNNING);
	return -1;
}

中断来临执行irq_forced_thread_fn或irq_thread_fn函数，取决于是否开启强制中断线程化，以irq_thread_fn为例：

static irqreturn_t irq_thread_fn(struct irq_desc *desc,
		struct irqaction *action)
{
	irqreturn_t ret;

	//执行irqaction里的thread_fn函数，即xxx_threaded_handler
	ret = action->thread_fn(action->irq, action->dev_id);
	......
	return ret;
}

内容总结

以上是互联网集市为您收集整理的Linux中断子系统分析之（4）：驱动程序申请中断全部内容，希望文章能够帮你解决Linux中断子系统分析之（4）：驱动程序申请中断所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/925889.html

来源：【匿名】

【上一篇】Linux的高级存储管理【下一篇】Linux下安装GD

更多 ►

【Linux中断子系统分析之（4）：驱动程序申请中断】教程文章相关的互联网学习教程文章

Linux设备驱动程序之后备高速缓存【代码】

设备驱动程序常常会反复的分配很多相同大小的内存块；内核实现了后备高速缓存来对此进行支持，以反复的使用这些相同的内存块；创建Linux内核的高速缓存管理有时被称为“slab分配器”；因此，相关函数和类型在<linux/slab.h>中声明；slab分配器实现的告诉缓存具有kmem_cache类型；通过调用kmem_cache_create创建；1struct kmem_cache * 2 kmem_cache_create(constchar *name, size_t size, size_t offset, 3 unsigned long flag...

linux 驱动程序 HelloWorld

Linux驱动可以直接编译进内核，也可以以模块的形式进行加载，前者比较复杂，本文就以模块的形式加载！vi helloi_driver.c #include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> static int __init hello_init(void) { printk(KERN_ALERT "hello driver init!\n"); return 0; } static void __exit hello_exit(void) ...

Linux设备驱动程序之 tasklet【代码】

多数情况下，为了控制一个寻常的硬件设备，tasklet机制都是实现自己下半部的最佳选择；tasklet可以动态创建，使用方便，执行起来还算快；声明tasklettasklet既可以静态的创建，也可以动态的创建；如果准备静态的创建一个tasklet，可以使用下面的两个宏之一：1#define DECLARE_TASKLET(name, func, data) 2struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data } 34#define DECLARE_TASKLET_DISABLED(name, func, d...

嵌入式系统最小驱动框架(类似linux驱动程序架构)【代码】

2010年就打算把linux里的驱动框架核心代码抠出来的，但是由于懒而且linux代码量大，一直下不了手。最近调试的intel curie里驱动架构也类似linux，代码就少多了，由于工作需要不得不梳理一下这一堆代码，今天花了一下午，把整个BSP部分的驱动核心抽离出来了，并且做了几个小sample。最小驱动框架核心代码1、设备管理device.c#include <stdio.h> #include <stddef.h> #include <stdlib.h> #include <stdint.h> #include <errno.h> #i...

第六章第一个Linux驱动程序：统计单词个数

一、Linux驱动到底是个什么东西：1、实际上Linux驱动和普通的Linux API没有本质的区别，只是使用Linux驱动的方式与使用Linux API的方式不同而已；2、 Linux系统将每一个驱动都映射成一个文件。这些文件称为设备文件或驱动文件，都保存在/dev目录中。这种设计理念使得与Linux驱动进行交互就像与普通文件进行交互一样容易，比访问Linux API也容易。由于大多数Linux驱动都有与其对应的设备文件，因此与Linux驱动交换数据就变成了与...

《Linux Device Drivers》第十二章 PCI驱动程序——note

简介本章给出一个高层总线架构的综述讨论重点是用于访问Peripheral Component Interconnect（PCI，外围设备互联）外设的内核函数PCI总线是内核中得到最好支持的总线本章主要介绍PCI驱动程序如果寻找其硬件和获得对它的访问本章也会介绍ISA总线PCI接口 PCI是一组完整的规范，定义了计算机的各个不同部分之间应该如何交互PCI规范涵盖了与计算机接口相关的大部分问题PCI架构被设计为ISA标准的替代品，有三个主要目标获得在计算机和外...

[arm驱动]linux驱动程序基础篇目录

《[arm驱动]busybox根文件系统mdev的详解》知道设备文件/dev是如何挂载，内核中文件系统类型proc的挂载。/etc启动脚本过程。《[arm驱动]注册函数相关内容》如何注册自己编写的驱动程序。《[arm驱动]globalmem虚拟设备实例描述》共享虚拟内存《[arm驱动概念篇]Linux内存管理(上)》、《 [arm驱动概念篇]Linux内存管理(下)》强烈推荐要看，新手可以对后面的学习做基础，对于老手-----这确实是一篇很的文章《 [arm驱动]linux内核链表》...

Linux设备驱动程序之软中断【代码】

软中断保留给系统中对时间要求严格以及最重要的下半部使用；目前，只有两个子系统（网络和SCSI）直接使用软中断；此外，内核定时器和tasklet都是建立在软中断上的；在使用软中断之前，要先确定为什么不能使用tasklet，tasklet可以动态生成，并且对加锁的要求不高，使用起来也很方便，性能也不错；当然，对于时间要求严格并能自己高效完成加锁的工作，软中断是正确的选择；分配索引在编译期间，通过在<linux/interrupt.h>中定义一个...

Linux驱动程序：统计单词个数

统计单词个数的功能是封装在Linux驱动中的。Linux系统将每一个驱动都映射成一个文件。这些文件称之为设备文件或驱动文件，都保存在/dev目录中。编写Linux驱动程序的步骤如下：1、建立Linux驱动骨架（装载和卸载Linux驱动）；2、注册和注销设备文件；3、指定与驱动相关的信息；4、指定回掉函数；5、编写业务逻辑；6、编写Makefile文件；7、编译Linux驱动程序；8、安装和卸载Linux驱动；　　统计单词个数这个驱动程序没有访问...

第六章第一个Linux驱动程序：统计单词个数心得笔记

一、Linux系统将每个驱动都映射成一个文件。这些文件称为设备文件或驱动文件，都保存在/dev目录中。这使得与Linux驱动进行交互就向与普通文件进行交互一样容易。大多数Linux驱动都有与其对应的设备文件，因此与Linux驱动交换数据变成与驱动设备交换数据。二、编写Linux驱动程序 1.建立Linux驱动骨架　 Linux内核在使用驱动时需要装载与卸载驱动　　装载驱动：建立设备文件、分配内存地址空间等...

sql-server – Linux与FreeTDS的Microsoft ODBC驱动程序？

我正在研究从RHEL6应用程序服务器连接到MSSQL数据库的可能性.我找到了两种方法： > FreeTDS> Microsoft SQL Server ODBC Driver for Linux unixODBC 有没有人有使用这些设置的经验？ (我对后者特别好奇,因为MS正式支持).性能？稳定性？我可能会遗失任何其他选择？解决方法:为了记录,我现在使用FreeTDS.我评估了unixODBC和FreeTDS,发现FreeTDS目前更容易使用.

Linux设备驱动程序学习笔记——第八章分配内存【代码】

Linux设备驱动程序学习笔记第八章分配内存一、kmalloc函数的内幕（1）flags参数 //kmalloc原型 #include<linux/slab.h> void *kmalloc(size_t size, int flags);//flags分配标志，最常用的是GFP_FERNEL分配标志： GFP_ATOMIC用于在中断处理例程或其他运行于进程上下文以外的代码中分配内存如tasklet以及内核定时器调用，不会休眠GFP_KERNEL内核内存的通常分配方法，可能引起休眠GFP_USER用于为用户空间页分配内存，可能会休眠GF...

首页 / LINUX / Linux中断子系统分析之（4）：驱动程序申请中断

Linux中断子系统分析之（4）：驱动程序申请中断

内容导读

内容图文

内容总结

内容备注

内容手机端

【Linux中断子系统分析之（4）：驱动程序申请中断】教程文章相关的互联网学习教程文章

Linux设备驱动程序之后备高速缓存【代码】

linux 驱动程序 HelloWorld

Linux设备驱动程序之 tasklet【代码】

嵌入式系统最小驱动框架(类似linux驱动程序架构)【代码】

第六章第一个Linux驱动程序：统计单词个数

《Linux Device Drivers》第十二章 PCI驱动程序——note

[arm驱动]linux驱动程序基础篇目录

Linux设备驱动程序之软中断【代码】

Linux驱动程序：统计单词个数

第六章第一个Linux驱动程序：统计单词个数心得笔记

sql-server – Linux与FreeTDS的Microsoft ODBC驱动程序？

Linux设备驱动程序学习笔记——第八章分配内存【代码】

linux设备驱动程序中的阻塞机制【代码】【图】

linux驱动程序中的并发控制【代码】【图】

linux设备驱动程序之简单字符设备驱动【代码】【图】

LINUX - 相关标签

系统分析 - 相关标签

子系统 - 相关标签

LINUX - 最新教程

LINUX - 最热教程