Linux设备驱动基础02之中断处理

一、基础概念

中断系统是一个处理器的重要且基本的组成部分，可以极大提高CPU的执行效率，一般中断系统框架组成如下图：

1、中断控制器

中断控制器是整个中断系统的管理机构。Cortex-A中断控制器叫GIC(Gerneral Interrupt controller)。目前GIC有4个版本：V1~V4，版本V1已经废弃，版本V2是给ARMv7-A架构使用，比如Cortex-A7、Cortex-A9、Cortex-A15等，版本V3和V4是给ARMv8-A/R架构使用。当GIC接收到众多外部中断，然后对其进行处理，最终只提供四个信号给ARM内核汇报中断情况：

VFIQ：虚拟快速FIQ

VIRQ：虚拟快速IRQ

FIQ：快速中断IRQ

IRQ：外部中断IRQ

这里只用IRQ，相当于GIC最终向ARM内核只上报一个IRQ的信号。中断源有很多，每个中断源有一个唯一的ID，叫做中断ID。每个CPU最多支持1020个中断ID，中断ID号为ID0~ID1019，这1020个ID分属以下三类：

SPI(Shared Peripheral Interrupt)：共享中断，即所有Core共享的中断。所有外部中断都属于SPI中断，比如按键、串口中断等，这些中断所有的Core都可处理。中断ID32~1019分配给SPI。

PPI(Private Peripheral Interrupt)：私有中断，因为GIC支持多核，每个核均有自己独有的中断，这些独有的中断肯定是要指定的核心处理。中断ID16~31分配给PPI。

SGI(Software Generated Interrupt)：软中断，由软件触发引起的中断，通过向寄存器GICD_SGIR写入数据触发，系统会使用SGI中断来完成多核之间的通信。中断ID0~15分配给SGI。

GIC逻辑架构分为成两个逻辑块：Distributor和CPU Interface，也就是分发器端和CPU接口端。这两个逻辑块的含义如下：

Distributor(分发器端)：负责处理各个中断事件的分发问题，也就是中断事件应该发送到哪个CPU Interface上去。分发器收集所有的中断源，可以控制每个中断的优先级，它总是将优先级最高的中断事件发送到CPU接口端。分发器端要做的主要工作如下：

①、全局中断使能控制。

②、控制每一个中断的使能或者关闭。

③、设置每个中断的优先级。

④、设置每个中断的目标处理器列表。

⑤、设置每个外部中断的触发模式：电平触发或边沿触发。

⑥、设置每个中断属于组0还是组1。

CPU Interface(CPU接口端)：每个CPU Core都可以在GIC中找到一个与之对应的CPU Interface。CPU接口端就是分发器和CPU Core之间的桥梁，CPU接口端主要工作如下：

①、使能或者关闭发送到CPU Core的中断请求信号。

②、应答中断。

③、通知中断处理完成。

④、设置优先级掩码，通过掩码来设置哪些中断不需要上报给CPU Core。

⑤、定义抢占策略。

⑥、当多个中断到来的时候，选择优先级最高的中断通知给CPU Core。

2、中断向量表

中断向量表是一个表，这个表里面存放的是中断向量，中断向量表是由一系列中断服务函数入口地址组成的表。这些中断服务函数在中断向量表中的位置是由半导体厂家决定，当某个中断被触发后，就会自动跳转到中断向量表中对应的中断服务函数入口地址处，中断向量表在整个程序的最前面，需要链接到代码的最前面，一般ARM处理器是从地址0X00000000开始执行指令，那么中断向量表就是从0X00000000开始存放；比如Cortex-A7有8个异常中断，这8个异常中断的中断向量表如下所示。

对于Cortex-A所有的外部中断都属于IRQ中断，比如I2C、SPI、定时器等。任意一个外部中断发生后都会触发IRQ中断，在IRQ的中断服务函数中可以读取指定的寄存器来判断具体是什么中断，进而根据具体中断做出相应处理。

3、中断服务函数

中断发生以后，中断服务函数就会被调用，需要处理的工作就可以放到中断服务函数中去完成。

4、中断使能

中断使能包括两部分，一个是IRQ或FIQ总中断使能，另一个就是ID0~ID1019中断源的使能。

二、中断处理相关API

Linux内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可。每个中断都有一个中断号，通过中断号即可区分不同的中断，中断号也叫中断线。Linux内核中使用一个int变量表示中断号。

(1)、int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev);

request_irq函数用于申请中断， 该函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用request_irq函数。 request_irq 函数会激活(使能)中断，所以不需要我们手动去使能中断。

irq：要申请中断的中断号。

handler：中断处理函数，当中断发生以后就会执行此中断处理函数。

flags：中断标志，可以在文件include/linux/interrupt.h里面查看所有的中断标志，常用的中断标志如下表。

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

dev：如果将flags设置为IRQF_SHARED，dev用来区分不同的中断，一般将dev设置为设备结构体，将其传递给中断处理函数irq_handler_t的第二个参数。

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

(2)、irqreturn_t (*irq_handler_t) (int, void *);

是一个函数指针，表示使用 request_irq 函数申请中断的时候设置的中断处理函数。第一个参数是中断处理函数相应的中断号。第二个参数是一个指向void的通用指针，需要与request_irq函数的dev参数保持一致，用于区分共享中断的不同设备。

(3)、void free_irq(unsigned int irq, void *dev);

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

irq：要释放的中断。 dev：如果中断设置为共享(IRQF_SHARED)，用来区分具体的中断。共享中断只有在释放最后中断处理函数时才会被禁止掉。

(4)、void enable_irq(unsigned int irq);

使能指定的中断。

(5)、void disable_irq(unsigned int irq);

禁止指定的中断，要等到当前正在执行的中断处理函数执行完才返回，因此使用者需要保证不会产生新的中断，并且确保所有已经开始执行的中断处理程序已经全部退出。

(6)、void disable_irq_nosync(unsigned int irq);

禁止指定的中断，调用以后立即返回，不会等待当前中断处理程序执行完毕。

(7)、local_irq_enable();

使能当前处理器中断系统。

(8)、local_irq_disable();

禁止当前处理器中断系统。

(9)、local_irq_save(flags) 与 local_irq_restore(flags); 这两个函数是一对，local_irq_save函数用于禁止中断，并且将中断状态保存在flags中。local_irq_restore用于恢复中断，将中断到flags状态。

三、上半部和下半部

也将上半部和下半部称为顶半部和底半部。使用request_irq函数申请中断的时候注册的中断服务函数属于中断处理的上半部，只要中断触发，那么中断处理函数就会执行。

中断处理函数一定要快点执行完毕，越短越好，但是有些中断处理过程比较费时间，我们必须要对其进行处理，缩小中断处理函数的执行时间。所以可以在中断处理函数中仅仅响应中断，然后清除中断标志即可，这时中断处理过程分为两部分：

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

下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出。

上半部和下半部工作分配的参考建议：

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

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

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

(4)、除了上述三点以外的其他任务，优先考虑放到下半部。 中断处理中上半部很简单，直接编写中断处理函数就行，关键是下半部。

Linux内核提供了多种下半部机制：软中断、tasklet和工作队列。

四、下半部实现机制

1、软中断

刚开始Linux内核提供“bottom half”机制来实现下半部，简称“BH”。后面引入软中断和tasklet来替代“BH”机制，从 2.5 版本Linux内核开始，BH机制已经被抛弃。 Linux 内核使用结构体 softirq_action 表示软中断， softirq_action结构体定义在文件include/linux/interrupt.h中，成员action就是软中断的服务函数，结构体内容如下：

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

在kernel/softirq.c文件中共定义10个软中断，为一个静态结构体数组变量： static struct softirq_action softirq_vec[NR_SOFTIRQS]; 在include/linux/interrupt.h文件中定义了枚举类型NR_SOFTIRQS：
 

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_vec有10个元素，并且为一个全局数组，每个CPU都可以访问到，但是每个CPU都有自己触发和控制机制，只执行自己所触发的软中断。每个CPU执行的软中断服务函数都是相同的。与软中断相关的API如下：

(1)、void open_softirq(int nr,  void (*action)(struct softirq_action *));

open_softirq函数注册对应的软中断处理函数。

nr：要开启的软中断，为上面所示的枚举变量，如NET_RX_SOFTIRQ等。

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

(2)、void raise_softirq(unsigned int nr);

raise_softirq函数触发注册好的软中断。

nr：要触发的软中断，为上面所示的枚举变量，如NET_RX_SOFTIRQ等。

(3)、void __init softirq_init(void)；

软中断必须在编译的时候静态注册，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); 
}

2、tasklet

利用软中断来实现的另一种下半部机制，在软中断和tasklet之间，建议使用tasklet。结构体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的参数 */
};

Linux提供tasklet相关API如下：

(1) 、void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data);

tasklet_init函数初始化tasklet。

t：要初始化的 tasklet

func： tasklet 的处理函数。

data： 要传递给 func 函数的参数。

(2)、DECLARE_TASKLET(name, func, data)

这是一个宏，可以一次性完成tasklet的定义和初始化，其中name为要定义的tasklet名字，即tasklet_struct类型的变量，func就是tasklet的处理函数，data是传递给func函数的参数。

(3)、void tasklet_schedule(struct tasklet_struct *t);

tasklet_schedule函数使tasklet在合适的时间运行，这个函数需要在上半部，即中断处理函数中显式调用。

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

(4)、tasklet使用示例：

struct tasklet_struct tasklet; /* 定义 tasklet */

/* 定义 tasklet 处理函数 */
void tasklet_func(unsigned long data)
{
    /* tasklet具体处理内容 */
}

/* 中断处理函数 */
irqreturn_t irq_handler(int irq, void *dev_id)
{
    tasklet_schedule(&tasklet); /* 调度tasklet */
}

/* 驱动入口函数 */
static int __init xxx_init(void)
{
    tasklet_init(&tasklet, tasklet_func, data); /* 初始化tasklet */
    request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev); /* 注册中断处理函数 */
}

3、工作队列

工作队列是另一种下半部处理方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。如果要推后的工作可以睡眠，那么就可以选择工作队列，否则只能选择软中断或tasklet。

结构体work_struct表示一个工作，许多工作组织成工作队列，工作队列使用workqueue_struct结构体表示。工作者线程(worker thread)处理工作队列中的各个工作，worker结构体表示工作者线程。每个工作者线程都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作(work_struct)即可，关于工作队列和工作者线程我们基本不用去管。

(1)、结构体work_struct定义如下：

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

(2)、结构体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[];
};

(3)、结构体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;
};

(4)、定义一个work_struct结构体变量，然后使用INIT_WORK宏来初始化工作，INIT_WORK宏定义如下：

#define INIT_WORK(_work, _func)

其中_work表示要初始化的工作，_func是工作对应的处理函数。也可使用DECLARE_WORK宏一次性完成工作的创建和初始化，宏定义如下：

#define DECLARE_WORK(n, f) 其中n表示定义的工作，f表示工作对应的处理函数。

(5)、调度工作，和tasklet类似，工作也是需要调度才能运行，需要在中断处理函数中调用调度函数schedule_work，函数原型如下所示：

bool schedule_work(struct work_struct *work);

参数work：要调度的工作。返回值： 0成功，其他值失败。

(6)、工作队列使用示例

struct work_struct work; /* 定义work */

/* work 处理函数 */
void work_func(struct work_struct *work);
{
    /* work 具体处理内容 */
}

/* 中断处理函数 */
irqreturn_t irq_handler(int irq, void *dev_id)
{
    schedule_work(&work); /* 调度work */
}

/* 驱动入口函数 */
static int __init xxx_init(void)
{
    INIT_WORK(&work, work_func); /* 初始化work */
    request_irq(xxx_irq, irq_handler, 0, "xxx", &xxx_dev); /* 注册中断处理函数 */
}