【Linux学习笔记】Linux中断

系列文章目录

【Linux学习笔记】开发板挂载根文件系统

【Linux学习笔记】设备树学习

【Linux学习笔记】pinctrl和gpio子系统

【Linux学习笔记】Linux 并发与竞争

【Linux学习笔记】Linux内核定时器

---

本系列使用的开发板为正点原子阿尔法IMX6ULL开发板，及根据正点原子所的提供教程学习同系列笔记已放置链接在上面。

---

---

一、简介

在Linux下使用中断功能不需要像裸机那样配置，只需要申请中断然后注册中断处理函数既可。

在裸机中的中断处理方法：
①、使能中断，初始化相应的寄存器。
②、注册中断服务函数，也就是向 irqTable 数组的指定标号处写入中断服务函数。
③、中断发生以后进入 IRQ 中断服务函数，在 IRQ 中断服务函数在数组 irqTable 里面查找
具体的中断处理函数，找到以后执行相应的中断处理函数。

1.1 Linux中断API函数

1.1.1 中断号

每个中断都有一个中断号，通过中断号即可区分不同的中断，在Linux内核中使用一个int变量表示中断号。

1.1.2 request_irq 函数

在Linux内核中想要使用某个中断是需要申请的，request_irq函数用于申请中断，此函数可能会导致睡眠，因此不能再中断上下文或者其他禁止睡眠的代码段中使用。request_irq函数会使能中断，所以不需要手动使能，其原型如下：

int request_irq(unsigned int 	irq, 
	irq_handler_t 				handler, 
	unsigned long 				flags,
	const char 					*name, 
	void 						*dev)
irq：要申请中断的中断号。
handler：中断处理函数，当中断发生以后就会执行此中断处理函数。
flags：中断标志。
name：中断名字，设置以后可以在/proc/interrupts 文件中看到对应的中断名字。
dev：如果将 flags 设置为 IRQF_SHARED 的话，dev 用来区分不同的中断，一般情况下将dev 设置为设备结构体，dev 会传递给中断处理函数 irq_handler_t 的第二个参数。
返回值：0 中断申请成功，其他负值 中断申请失败，如果返回-EBUSY 的话表示中断已经被申请了。

可以在文件 include/linux/interrupt.h 里面查看所有的中断标志，这些标志可以通过“|”来实现多种组合。

标志	描述
IRQF_SHARED	多个设备共享一个中断线，共享的所有中断都必须指定此标志。如果使用共享中断的话，request_irq 函数的 dev 参数就是唯一区分他们的标志。
IRQF_ONESHOT	单次中断，中断执行一次就结束。
IRQF_TRIGGER_NONE	无触发。
IRQF_TRIGGER_RISING	上升沿触发。
IRQF_TRIGGER_FALLING	下降沿触发。
IRQF_TRIGGER_HIGH	高电平触发。
IRQF_TRIGGER_LOW	低电平触发。

1.1.3 free_irq 函数

使用中断的时候需要通过request_irq函数申请，使用完成以后就要通过free_irq函数释放掉相应的中断。如果中断不是共享的，那么它会删除中断处理函数并且禁止中断，其函数原型如下：

void free_irq(unsigned int irq,void *dev)
irq：要释放的中断。
dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
返回值：无。

1.1.4 中断处理函数

使用request_irq函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下：

irqreturn_t (*irq_handler_t) (int, void *)
int:中断处理函数要响应的中断号
void*:通用指针，需要与request_irq函数的dev参数保持一致，用于区分共享中断的不同设备，dev也可以指向设备数据结构。
返回值：irqreturn_t类型

irqreturn_t类型定义如下：

enum irqreturn {
	IRQ_NONE = (0 << 0),
	IRQ_HANDLED = (1 << 0),
	IRQ_WAKE_THREAD = (1 << 1),
};
typedef enum irqreturn irqreturn_t;

1.1.5 中断使能与禁止函数

void enable_irq(unsigned int irq)//使能中断
void disable_irq(unsigned int irq)//禁止中断，要等到当前正在执行的中断处理函数执行完才返回
void disable_irq_nosync(unsigned int irq)//禁止中断，调用以后立即返回，不会等待当前中断处理程序执行完毕。
irq ：中断号

上面三个都是对单一中断操作，接下来是关闭整个中断系统，也就是全局中断的使能和关闭

local_irq_enable()//使能当前处理器中断系统
local_irq_disable()//禁止当前处理器中断系统

这两个函数在使用时如果处理不当可能会造成系统崩溃，但两个任务都拥有使能和关闭策略的时候，两个任务互相干涉可能会造成逻辑混乱，考虑到这种情况就可以使用下面这两个函数：

local_irq_save(flags)//禁止
local_irq_restore(flags)//恢复

这两个功能和上面一样，多的是会将中断恢复到之前的状态。

1.2 上半部与下半部

上半部：上半部就是中断处理函数，哪些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。
下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出。
Linux内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快出，哪些对时间敏感、执行速度快的操作可以放在中断处理函数中，也就是上半部。剩下的工作都可以放在下半部去执行。至于谁在哪个地方就自行判断。给出参考：
①、如果要处理的内容不希望被其他中断打断，那么可以放到上半部。
②、如果要处理的任务对时间敏感，可以放到上半部。
③、如果要处理的任务与硬件有关，可以放到上半部
④、除了上述三点以外的其他任务，优先考虑放到下半部。

上半部直接编写中断处理函数即可，如request_irq 申请中断的时候注册的中断服务函数属于中断处理的上半部。
下半部具有多种机制，如下：

1.2.1 软中断

Linux内核使用结构体softirq_action 表示软中断，定义在文件 include/linux/interrupt.h 中，内容如下：

struct softirq_action
{
	void (*action)(struct softirq_action *);
};

在 kernel/softirq.c 文件中一共定义了 10 个软中断，如下所示：

static struct softirq_action softirq_vec[NR_SOFTIRQS];

NR_SOFTIRQS 是枚举类型，定义在文件 include/linux/interrupt.h 中，定义如下：

enum
{
	 HI_SOFTIRQ=0, 				/* 高优先级软中断 */
	 TIMER_SOFTIRQ, 			/* 定时器软中断 */
	 NET_TX_SOFTIRQ, 			/* 网络数据发送软中断 */
	 NET_RX_SOFTIRQ, 			/* 网络数据接收软中断 */
	 BLOCK_SOFTIRQ, 
	 BLOCK_IOPOLL_SOFTIRQ, 
	 TASKLET_SOFTIRQ, 			/* tasklet 软中断 */
	 SCHED_SOFTIRQ, 			/* 调度软中断 */
	 HRTIMER_SOFTIRQ, 			/* 高精度定时器软中断 */
	 RCU_SOFTIRQ, 				/* RCU 软中断 */
	 NR_SOFTIRQS
};

softirq_action 结构体中的 action 成员变量就是软中断的服务函数，数组 softirq_vec 是个全局数组，因此所有的 CPU(对于 SMP 系统而言)都可以访问到，每个 CPU 都有自己的触发和控制机制，并且只执行自己所触发的软中断。但是各个 CPU 所执行的软中断服务函数确是相同的，都是数组 softirq_vec 中定义的 action 函数。要使用软中断，必须先使用 open_softirq 函数注册对应的软中断处理函数，open_softirq 函数原型如下：

void open_softirq(int nr, void (*action)(struct softirq_action *))
nr：要开启的软中断，在NR_SOFTIRQS中选择一个。
action：软中断对应的处理函数。
返回值：没有返回值。

注册好软中断以后需要通过 raise_softirq 函数触发，raise_softirq 函数原型如下：

void raise_softirq(unsigned int nr)
nr：要触发的软中断，在NR_SOFTIRQS中选择一个。
返回值：没有返回值。

软中断必须在编译的时候静态注册！Linux 内核使用 softirq_init 函数初始化软中断，softirq_init 函数定义在 kernel/softirq.c 文件里面，函数内容如下：

void __init softirq_init(void)
{
	int cpu;

	for_each_possible_cpu(cpu) {
	per_cpu(tasklet_vec, cpu).tail =&per_cpu(tasklet_vec, cpu).head;
	per_cpu(tasklet_hi_vec, cpu).tail =&per_cpu(tasklet_hi_vec, cpu).head;
	}

	open_softirq(TASKLET_SOFTIRQ, tasklet_action);
	open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

softirq_init 函数默认会打开 TASKLET_SOFTIRQ 和HI_SOFTIRQ。

1.2.1 tasklet

tasklet是利用软中断来实现的另一种下半部机制，在软中断和tasklet之间建议使用tasklet，Linux 内核使用 tasklet_struct 结构体来表示 tasklet：

struct tasklet_struct
{
	struct tasklet_struct *next; 	/* 下一个 tasklet */
	unsigned long state; 			/* tasklet 状态 */
	atomic_t count; 				/* 计数器，记录对 tasklet 的引用数 */
	void (*func)(unsigned long); 	/* tasklet 执行的函数 ，即中断处理函数*/
	unsigned long data; 			/* 函数 func 的参数 */
};

要使用tasklet必须先定义一个tasklet，然后使用tasklet_init函数初始化tasklet，其原型如下：

void tasklet_init(struct tasklet_struct *t,
					void tasklet_init(struct tasklet_struct *t,
					unsigned long data);
t：要初始化的 tasklet
func：tasklet 的处理函数。
data：要传递给 func 函数的参数
返回值：没有返回值。

也 可 以 使 用 宏 DECLARE_TASKLET 来 一 次 性 完 成 tasklet 的 定 义 和 初 始 化 ，DECLARE_TASKLET 定义在 include/linux/interrupt.h 文件中，定义如下:

DECLARE_TASKLET(name, func, data)
name：要定义的tasklet名字
func：tasklet的处理函数
data：传递给func函数的参数

在上半部，也就是中断处理函数中调用 tasklet_schedule 函数就能使 tasklet 在合适的时间运行，tasklet_schedule 函数原型如下：

void tasklet_schedule(struct tasklet_struct *t)
t：要调度的 tasklet，也就是 DECLARE_TASKLET 宏里面的 name。
返回值：没有返回值。

tasklet 的参考使用示例如下所示：

/* 定义 taselet */
struct tasklet_struct testtasklet;
/* tasklet 处理函数 */
void testtasklet_func(unsigned long data)
{
	/* tasklet 具体处理内容 */
}
/* 中断处理函数 */
irqreturn_t test_handler(int irq, void *dev_id)
{
	......
	/* 调度 tasklet */
	tasklet_schedule(&testtasklet);
......
}
/* 驱动入口函数 */
static int __init xxxx_init(void)
{
	......
	/* 初始化 tasklet */
	tasklet_init(&testtasklet, testtasklet_func, data);
	/* 注册中断处理函数 */
	request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
	 ......
}

1.2.1 工作队列

工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。因此要推迟的工作可以睡眠就可以选择工作队列，否则就只能选择软中断或者tasklet。
Linux 内核使用 work_struct 结构体表示一个工作，内容如下：

struct work_struct {
	atomic_long_t data; 
	struct list_head entry;
	work_func_t func; /* 工作队列处理函数 */
};

一堆工作，组成工作队列使用workqueue_struct 结构体表示，内容如下：

struct workqueue_struct {
	 struct list_head pwqs; 
	 struct list_head list; 
	 struct mutex mutex; 
	 int work_color;
	 int flush_color; 
	 atomic_t nr_pwqs_to_flush;
	 struct wq_flusher *first_flusher;
	 struct list_head flusher_queue; 
	 struct list_head flusher_overflow;
	 struct list_head maydays; 
	 struct worker *rescuer; 
	 int nr_drainers; 
	 int saved_max_active;
	 struct workqueue_attrs *unbound_attrs;
	 struct pool_workqueue *dfl_pwq; 
	 char name[WQ_NAME_LEN];
	 struct rcu_head rcu;
	 unsigned int flags ____cacheline_aligned;
	 struct pool_workqueue __percpu *cpu_pwqs;
	 struct pool_workqueue __rcu *numa_pwq_tbl[];
};

在内核中使用工作者线程（worker thread）来处理工作队列中的各个工作，使用worker结构体表示工作者线程，内容如下：

struct worker {
	 union {
	 struct list_head entry; 
	 struct hlist_node hentry;
	 };
	 struct work_struct *current_work; 
	 work_func_t current_func; 
	 struct pool_workqueue *current_pwq;
	 bool desc_valid;
	 struct list_head scheduled; 
	 struct task_struct *task; 
	 struct worker_pool *pool; 
	 struct list_head node; 
	 unsigned long last_active; 
	 unsigned int flags; 
	 int id; 
	 char desc[WORKER_DESC_LEN];
	 struct workqueue_struct *rescue_wq;
};

每个worker都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作（work_struct）即可。
创建工作，直接定义一个work_struct结构体变量，然后使用INIT_WORK宏来初始化工作，INIT_WORK宏定义如下：

#define INIT_WORK(_work,_func)
_work：表示要初始化的工作
_func：是工作对应的处理函数

也可以使用DECLARE_WORK 宏一次性完成工作的创建和初始化，宏定义如下：

#define DECLARE_WORK(n, f)
n ：要定义的工作(work_struct)
f ：工作对应的处理函数

和tasklet一样，工作也是需要调度才能运行的，工作的调度函数为schedule_work，函数原型如下：

bool schedule_work(struct work_struct *work)
work：要调度的工作。
返回值：0 成功，其他值 失败。

工作队列的参考示例：

/* 定义工作(work) */
struct work_struct testwork;
/* work 处理函数 */
void testwork_func_t(struct work_struct *work);
{
	/* work 具体处理内容 */
}
/* 中断处理函数 */
irqreturn_t test_handler(int irq, void *dev_id)
{
	......
	/* 调度 work */
	schedule_work(&testwork);
	......
}
/* 驱动入口函数 */
static int __init xxxx_init(void)
{
	......
	/* 初始化 work */
	INIT_WORK(&testwork, testwork_func_t);
	/* 注册中断处理函数 */
	request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
	......
}

1.3 设备树中断信息节点

如果使用设备树的话就需要在设备树中设置好中断属性信息，内核通过读取设备树的中断属性信息来配置中断。imx6ull.dtsi文件中的intc节点就是I.MX6ULL的中断控制器节点，节点内容如下：

intc: interrupt-controller@00a01000 {
	compatible = "arm,cortex-a7-gic";
	#interrupt-cells = <3>;
	interrupt-controller;
	reg = <0x00a01000 0x1000>,
		<0x00a02000 0x100>;
};

#interrupt-cells 和#address-cells、#size-cells 一样。表示此中断控制器下设备的 cells大小，对于设备而言，会使用 interrupts 属性描述中断信息，#interrupt-cells 描述了 interrupts 属性的 cells 大小，也就是一条信息有几个 cells。每个 cells 都是 32 位整形值，对于 ARM 处理的GIC 来说，一共有 3 个 cells，这三个 cells 的含义如下：
第一个 cells：中断类型，0 表示 SPI 中断，1 表示 PPI 中断。
第二个 cells：中断号，对于 SPI 中断来说中断号的范围为 0 ~ 987，对于 PPI 中断来说中断号的范围是0 ~ 15。
第三个 cells：标志，bit[3:0]表示中断触发类型，为 1 的时候表示上升沿触发，为 2 的时候表示下降沿触发，为 4 的时候表示高电平触发，为 8 的时候表示低电平触发。bit[15:8]为 PPI 中断的 CPU 掩码。

interrupt-controller 节点为空，表示当前节点是中断控制器。

简单总结一下与中断有关的设备树属性信息：
①、#interrupt-cells，指定中断源的信息 cells 个数。
②、interrupt-controller，表示当前节点为中断控制器。
③、interrupts，指定中断号，触发方式等。
④、interrupt-parent，指定父中断，也就是中断控制器。

获取中断号
编写驱动的时候需要用到中断号，我们用到中断号，中断信息已经写到了设备树里面，因此可以通过 irq_of_parse_and_map 函数从 interupts 属性中提取到对应的设备号，函数原型如下：

unsigned int irq_of_parse_and_map(struct device_node *dev,int index)
dev：设备节点。
index：索引号，interrupts 属性可能包含多条中断信息，通过 index 指定要获取的信息。
返回值：中断号。

如果使用 GPIO 的话，可以使用 gpio_to_irq 函数来获取 gpio 对应的中断号，函数原型如下：

int gpio_to_irq(unsigned int gpio)
gpio：要获取的 GPIO 编号。
返回值：GPIO 对应的中断号。