Linux中断实验

        不管是裸机实验还是Linux下的驱动实验，中断都是频繁使用的功能，关于I.MX6U的中断原理已经在第十七章做了详细的讲解，在裸机中使用中断我们需要做一大堆的工作，比如配置寄存器，使能IRQ等等。Linux内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。本章我们就来学习一下如何在Linux下使用中断。

1 Linux中断简介

1.1 Linux中断API函数

先来回顾一下裸机实验里面中断的处理方法：

①、使能中断，初始化相应的寄存器。

②、注册中断服务函数，也就是向irqTable数组的指定标号处写入中断服务函数

②、中断发生以后进入IRQ中断服务函数，在IRQ中断服务函数在数组irqTable里面查找

具体的中断处理函数，找到以后执行相应的中断处理函数。

在 Linux 内核中也提供了大量的中断相关的 API函数，我们来看一下这些跟中断有关的

API函数：

1、中断号

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

2、request_irq函数

        在Linux内核中要想使用某个中断是需要申请的，request_irq函数用于申请中断，request_irq

函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用request_irq函

数。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：中断标志，可以在文件include/linux/interrupt.h里面查看所有的中断标志，这里我们介绍几个常用的中断标志：

        比如I.MX6U-ALPHA开发板上的KEY0使用GPIO1_IO18，按下KEY0以后为低电平，因此可以设置为下降沿触发，也就是将flags设置为IRQF_TRIGGER_FALLING。表中的这些标志可以通过“|”来实现多种组合。

        name：中断名字，设置以后可以在/proc/interrupts文件中看到对应的中断名字。

        dev：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断，一般情况下将

dev设置为设备结构体，dev会传递给中断处理函数irq_handler_t的第二个参数。

        返回值：0 中断申请成功，其他负值 中断申请失败，如果返回-EBUSY的话表示中断已经

被申请了。

3、free_irq函数

        使用中断的时候需要通过request_irq函数申请，使用完成以后就要通过free_irq函数释放

掉相应的中断。如果中断不是共享的，那么free_irq会删除中断处理函数并且禁止中断。free_irq

函数原型如下所示：

void free_irq(unsigned int irq,void *dev
)

        函数参数和返回值含义如下：

        irq：要释放的中断。

        dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断

只有在释放最后中断处理函数的时候才会被禁止掉。

        返回值：无。

4、中断处理函数

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

irqreturn_t (*irq_handler_t) (int, void *) 

        第一个参数是要中断处理函数要相应的中断号。第二个参数是一个指向void的指针，也就

是个通用指针，需要与request_irq函数的dev参数保持一致。用于区分共享中断的不同设备，

dev也可以指向设备数据结构。中断处理函数的返回值为irqreturn_t类型，irqreturn_t类型定义

如下所示：

10 enum irqreturn {
11     IRQ_NONE        = (0 << 0),
12     IRQ_HANDLED     = (1 << 0),
13     IRQ_WAKE_THREAD = (1 << 1),
14 };
15
16 typedef enum irqreturn irqreturn_t;

        可以看出irqreturn_t是个枚举类型，一共有三种返回值。一般中断服务函数返回值使用如

下形式：

return IRQ_RETVAL(IRQ_HANDLED) 

5、中断使能与禁止函数

void enable_irq(unsigned int irq) 
void disable_irq(unsigned int irq) 

        enable_irq和disable_irq用于使能和禁止指定的中断，irq就是要禁止的中断号。disable_irq

函数要等到当前正在执行的中断处理函数执行完才返回，因此使用者需要保证不会产生新的中

断，并且确保所有已经开始执行的中断处理程序已经全部退出。在这种情况下，可以使用另外

一个中断禁止函数：

void disable_irq_nosync(unsigned int irq) 

        disable_irq_nosync函数调用以后立即返回，不会等待当前中断处理程序执行完毕。上面三

个函数都是使能或者禁止某一个中断，有时候我们需要关闭当前处理器的整个中断系统，也就

是在学习STM32的时候常说的关闭全局中断，这个时候可以使用如下两个函数：

local_irq_enable() 
local_irq_disable() 

        local_irq_enable用于使能当前处理器中断系统，local_irq_disable用于禁止当前处理器中断

系统。假如A任务调用local_irq_disable关闭全局中断10S，当关闭了2S的时候B任务开始运行，B任务也调用local_irq_disable关闭全局中断3S，3秒以后B任务调用local_irq_enable函数将全局中断打开了。此时才过去2+3=5秒的时间，然后全局中断就被打开了，此时A任务要关闭10S全局中断的愿望就破灭了，然后A任务就“生气了”，结果很严重，可能系统都要被A任务整崩溃。为了解决这个问题，B任务不能直接简单粗暴的通过local_irq_enable函数来打开全局中断，而是将中断状态恢复到以前的状态，要考虑到别的任务的感受，此时就要用到下面两个函数：

local_irq_save(flags)  local_irq_restore(flags) 

        这两个函数是一对，local_irq_save函数用于禁止中断，并且将中断状态保存在flags中。

local_irq_restore用于恢复中断，将中断到flags状态。

1.2 上半部与下半部

        在有些资料中也将上半部和下半部称为顶半部和底半部，都是一个意思。我们在使用

request_irq申请中断的时候注册的中断服务函数属于中断处理的上半部，只要中断触发，那么

中断处理函数就会执行。我们都知道中断处理函数一定要快点执行完毕，越短越好，但是现实

往往是残酷的，有些中断处理过程就是比较费时间，我们必须要对其进行处理，缩小中断处理

函数的执行时间。比如电容触摸屏通过中断通知SOC有触摸事件发生，SOC响应中断，然后

通过 IIC 接口读取触摸坐标值并将其上报给系统。但是我们都知道 IIC 的速度最高也只有

400Kbit/S，所以在中断中通过IIC读取数据就会浪费时间。我们可以将通过IIC读取触摸数据

的操作暂后执行，中断处理函数仅仅相应中断，然后清除中断标志位即可。这个时候中断处理

过程就分为了两部分：

上半部：上半部就是中断处理函数，那些处理过程比较快，不会占用很长时间的处理就可

以放在上半部完成。

下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部

去执行，这样中断处理函数就会快进快出。

因此，Linux内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快出，那些对时间敏感、执行速度快的操作可以放到中断处理函数中，也就是上半部。剩下的所有工作都可以放到下半部去执行，比如在上半部将数据拷贝到内存中，关于数据的具体处理就可以放到下半部去执行。至于哪些代码属于上半部，哪些代码属于下半部并没有明确的规定，一切根据实际使用情况去判断，这个就很考验驱动编写人员的功底了。这里有一些可以借鉴的参考点：

①、如果要处理的内容不希望被其他中断打断，那么可以放到上半部。

②、如果要处理的任务对时间敏感，可以放到上半部。

③、如果要处理的任务与硬件有关，可以放到上半部

④、除了上述三点以外的其他任务，优先考虑放到下半部。

        上半部处理很简单，直接编写中断处理函数就行了，关键是下半部该怎么做呢？Linux内

核提供了多种下半部机制，接下来我们来学习一下这些下半部机制。

1、软中断

        一开始Linux内核提供了“bottom half”机制来实现下半部，简称“BH”。后面引入了软中

断和tasklet来替代“BH”机制，完全可以使用软中断和tasklet来替代BH，从2.5版本的Linux

内核开始BH已经被抛弃了。Linux内核使用结构体softirq_action表示软中断， softirq_action

结构体定义在文件include/linux/interrupt.h中，内容如下：

433 struct softirq_action 
434 { 
435     void    (*action)(struct softirq_action *); 
436 }; 

        在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 
};

        可以看出，一共有10个软中断，因此NR_SOFTIRQS为10，因此数组softirq_vec有10个

元素。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：要开启的软中断，在示例代码51.1.2.3中选择一个。

        action：软中断对应的处理函数。

        返回值：没有返回值。

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

void raise_softirq(unsigned int nr) 

        函数参数和返回值含义如下：

        nr：要触发的软中断，在示例代码51.1.2.3中选择一个。

        返回值：没有返回值。

        软中断必须在编译的时候静态注册！Linux 内核使用 softirq_init 函数初始化软中断，

softirq_init函数定义在kernel/softirq.c文件里面，函数内容如下：

634 void __init softirq_init(void) 
635 { 
636     int cpu; 
637  
638     for_each_possible_cpu(cpu) { 
639         per_cpu(tasklet_vec, cpu).tail = 
640             &per_cpu(tasklet_vec, cpu).head; 
641         per_cpu(tasklet_hi_vec, cpu).tail = 
642             &per_cpu(tasklet_hi_vec, cpu).head; 
643     } 
644  
645     open_softirq(TASKLET_SOFTIRQ, tasklet_action); 
646     open_softirq(HI_SOFTIRQ, tasklet_hi_action); 
647 } 

        从示例代码 51.1.2.4 可以看出，softirq_init 函数默认会打开 TASKLET_SOFTIRQ 和

HI_SOFTIRQ。

2、tasklet

        tasklet是利用软中断来实现的另外一种下半部机制，在软中断和tasklet之间，建议大家使

用tasklet。Linux内核使用结构体

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的参数 */
};

        第489行的func函数就是tasklet要执行的处理函数，用户定义函数内容，相当于中断处理

函数。如果要使用tasklet，必须先定义一个tasklet，然后使用tasklet_init函数初始化tasklet，

taskled_init函数原型如下：

void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long),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名字，这个名字就是一个tasklet_struct类型的时候变量，func

就是tasklet的处理函数，data是传递给func函数的参数。

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

行，tasklet_schedule函数原型如下：

void tasklet_schedule(struct tasklet_struct *t) 

函数参数和返回值含义如下：

t：要调度的tasklet，也就是DECLARE_TASKLET宏里面的name。

返回值：没有返回值。

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

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

2、工作队列

        工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的

工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重

新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列，否则的话就只能选择软

中断或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[];  
}; 

        Linux内核使用工作者线程(worker thread)来处理工作队列中的各个工作，Linux内核使用

worker结构体表示工作者线程，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 设备树中断信息节点

        如果使用设备树的话就需要在设备树中设置好中断属性信息，Linux内核通过读取设备树

中的中断属性信息来配置中断。对于中断控制器而言，设备树绑定信息参考文档

Documentation/devicetree/bindings/arm/gic.txt。打开 imx6ull.dtsi 文件，其中的 intc 节点就是

I.MX6ULL的中断控制器节点，节点内容如下所示：

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

        第2行，compatible属性值为“arm,cortex-a7-gic”在Linux内核源码中搜索“arm,cortex-a7-

gic”即可找到GIC中断控制器驱动文件。

        第3行，#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掩码。

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

对于gpio来说，gpio节点也可以作为中断控制器，比如imx6ull.dtsi文件中的gpio5节点内容如下所示：

1  gpio5: gpio@020ac000 { 
2      compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio"; 
3      reg = <0x020ac000 0x4000>; 
4      interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>, 
5               <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>; 
6      gpio-controller; 
7      #gpio-cells = <2>; 
8      interrupt-controller; 
9      #interrupt-cells = <2>; 
10 }; 

        第4行，interrupts描述中断源信息，对于gpio5来说一共有两条信息，中断类型都是SPI，

触发电平都是IRQ_TYPE_LEVEL_HIGH。不同之处在于中断源，一个是74，一个是75，打开

可以打开《IMX6ULL参考手册》的“Chapter 3 Interrupts and DMA Events”章节，找到表3-1，

有如图所示的内容：

        从图可以看出，GPIO5一共用了2个中断号，一个是74，一个是75。其中74对应GPIO5_IO00~GPIO5_IO15这低16个IO，75对应GPIO5_IO16~GPIOI5_IO31这高16位IO。

        第8行，interrupt-controller表明了gpio5节点也是个中断控制器，用于控制gpio5所有IO

的中断。

        第9行，将#interrupt-cells修改为2。

        打开imx6ull-alientek-emmc.dts文件，找到如下所示内容：

1 fxls8471@1e { 
2     compatible = "fsl,fxls8471"; 
3     reg = <0x1e>; 
4     position = <0>; 
5     interrupt-parent = <&gpio5>; 
6     interrupts = <0 8>; 
7 }; 

        fxls8471是NXP官方的6ULL开发板上的一个磁力计芯片，fxls8471有一个中断引脚链接

到了I.MX6ULL的SNVS_TAMPER0因脚上，这个引脚可以复用为GPIO5_IO00。

        第5行，interrupt-parent属性设置中断控制器，这里使用gpio5作为中断控制器。

        第6行，interrupts设置中断信息，0表示GPIO5_IO00，8表示低电平触发。

        简单总结一下与中断有关的设备树属性信息：

        ①、#interrupt-cells，指定中断源的信息cells个数。

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

        ③、interrupts，指定中断号，触发方式等。

        ④、interrupt-parent，指定父中断，也就是中断控制器。

1.4 获取中断号

        编写驱动的时候需要用到中断号，我们用到中断号，中断信息已经写到了设备树里面，因

此可以通过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对应的中断号。