linux驱动移植-中断子系统执行流程

.L__vectors_start:
        W(b)    vector_rst
        W(b)    vector_und
        W(ldr)  pc, .L__vectors_start + 0x1000
        W(b)    vector_pabt
        W(b)    vector_dabt
        W(b)    vector_addrexcptn
        W(b)    vector_irq
        W(b)    vector_fiq

 __vectors_start = .; 
.vectors 0xffff0000 : AT(__vectors_start) { 
    *(.vectors) 
} 
. = __vectors_start + SIZEOF(.vectors);
 __vectors_end = .;
__stubs_start = .; 
.stubs ADDR(.vectors) + 0x1000 : AT(__stubs_start) { 
    *(.stubs) 
} 
. = __stubs_start + SIZEOF(.stubs); 
__stubs_end = .; 

/*
 * Vector stubs.
 *
 * This code is copied to 0xffff1000 so we can use branches in the
 * vectors, rather than ldr's.  Note that this code must not exceed
 * a page size.
 *
 * Common stub entry macro:
 *   Enter in IRQ mode, spsr = SVC/USR CPSR, lr = SVC/USR PC
 *
 * SP points to a minimal amount of processor-private memory, the address
 * of which is copied into r0 for the mode specific abort handler.
 */
        .macro  vector_stub, name, mode, correction=0
        .align  5

vector_name:                                                   @定义不同的宏 比如vector_irq
        .if correction                                         @判断correction是否为0      
        sub     lr, lr, #correction                            @计算返回地址
        .endif

        @
        @ Save r0, lr_<exception> (parent PC) and spsr_<exception>
        @ (parent CPSR)
        @
        stmia   sp, {r0, lr}            @ save r0, lr
        mrs     lr, spsr
        str     lr, [sp, #8]            @ save spsr

        @
        @ Prepare for SVC32 mode.  IRQs remain disabled.
        @
        mrs     r0, cpsr
        eor     r0, r0, #(mode ^ SVC_MODE | PSR_ISETSTATE)
        msr     spsr_cxsf, r0

        @
        @ the branch table must immediately follow this code
        @
        and     lr, lr, #0x0f
 THUMB( adr     r0, 1f                  )
 THUMB( ldr     lr, [r0, lr, lsl #2]    )
        mov     r0, sp
 ARM(   ldr     lr, [pc, lr, lsl #2]    )
        movs    pc, lr                  @ branch to handler in SVC mode
ENDPROC(vector_name)
        .align 2
        @ handler address follow this label
1:
        .endm

 vector_stub     irq, IRQ_MODE, 4

vector_irq:
        sub     lr, lr, 4                     @计算返回地址  lr=保存的是进入中断前PC的值，就是发生中断所在的指令地址+8  这里减44,也就是正常执行的下一条指令地址

        @
        @ Save r0, lr_<exception> (parent PC) and spsr_<exception>
        @ (parent CPSR)
        @
        stmia   sp, {r0, lr}            @ save r0, lr   @保存r0、lr
        mrs     lr, spsr                @ lr=spsr 这里保存的是上一个模式下的cpsr的值
        @在保存现场时，如果处于svc模式下时，cpsr寄存器是写入irq模式下的spsr_irq寄存器，而不是svc模式下的spsr_svc，这样，在中断模式下恢复的话，
        @将spsr_irq寄存器里的内容写入cpsr，就能恢复到svc模式了，因为，spsr_irq寄存器里的内容就是svc模式下的状态
        str     lr, [sp, #8]            @ save spsr     @保存spsr

        @
        @ Prepare for SVC32 mode.  IRQs remain disabled.
        @
        mrs     r0, cpsr                                 @r0=cpsr
        eor     r0, r0, #(IRQ_MODE ^ SVC_MODE | PSR_ISETSTATE)  
        msr     spsr_cxsf, r0                            @修改当前模式下的spsr 写回

         @
         @ the branch table must immediately follow this code
         @
         and    lr, lr, #0x0f               @lr=lr&0x0f 获取进入irq模式前的cpsr的模式位
         mov  r0, sp
         ldr     lr, [pc, lr, lsl #2]       @如果进入irq前是usr，则lr=*(PC+0<<2)，即__irq_usr， 如果进入irq前是svc，lr=*(PC+3<<2)，即__irq_svc

         movs pc, lr                        @跳转到下面某处,且目标寄存器是pc,指令S结尾,最后会恢复cpsr.
     
         .long __irq_usr                              @  0  (USR_26 / USR_32)
         .long __irq_invalid                          @  1  (FIQ_26 / FIQ_32)

         .long __irq_invalid                          @  2  (IRQ_26 / IRQ_32)
         .long __irq_svc                              @  3  (SVC_26 / SVC_32)
         .long __irq_invalid                          @  4
         .long __irq_invalid                          @  5
         .long __irq_invalid                          @  6
         .long __irq_invalid                          @  7
         .long __irq_invalid                          @  8
         .long __irq_invalid                          @  9
         .long __irq_invalid                          @  a
         .long __irq_invalid                          @  b
         .long __irq_invalid                          @  c
         .long __irq_invalid                          @  d
         .long __irq_invalid                          @  e
         .long __irq_invalid                          @  f

__irq_usr:
        usr_entry        @ 栈中保护中断上下文 r0~r12、sp、lr、pc、cpsr
        kuser_cmpxchg_check
        irq_handler
        get_thread_info tsk
        mov     why, #0
        b       ret_to_user_from_irq

__irq_svc:
        svc_entry
        irq_handler

#ifdef CONFIG_PREEMPT                           @ 配置了抢占 
        ldr     r8, [tsk, #TI_PREEMPT]          @ get preempt count
        ldr     r0, [tsk, #TI_FLAGS]            @ get flags
        teq     r8, #0                          @ if preempt count != 0
        movne   r0, #0                          @ force flags to 0
        tst     r0, #_TIF_NEED_RESCHED
        blne    svc_preempt
#endif

        svc_exit r5, irq = 1                    @ return from exception

        .macro  irq_handler
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
        ldr     r1, =handle_arch_irq
        mov     r0, sp
        badr    lr, 9997f
        ldr     pc, [r1]
#else
        arch_irq_handler_default
#endif
9997:
        .endm

/*
 * Interrupt handling.  Preserves r7, r8, r9
 */
        .macro  arch_irq_handler_default
        get_irqnr_preamble r6, lr
1:      get_irqnr_and_base r0, r2, r6, lr            @获取硬件中断号，r0=硬件中断号
        movne   r1, sp                               #r1=sp (栈中存放的寄存器上下文信息，对应结构体struct pt_regs) 
        @
        @ routine called with r0 = irq number, r1 = struct pt_regs *
        @
        badrne  lr, 1b
        bne     asm_do_IRQ                       

#ifdef CONFIG_SMP                                 @配置了多核
        /*
         * XXX
         *
         * this macro assumes that irqstat (r2) and base (r6) are
         * preserved from get_irqnr_and_base above
         */
        ALT_SMP(test_for_ipi r0, r2, r6, lr)
        ALT_UP_B(9997f)
        movne   r1, sp
        badrne  lr, 1b
        bne     do_IPI
#endif
9997:
        .endm

/*
 * handle_IRQ handles all hardware IRQ's.  Decoded IRQs should
 * not come via this function.  Instead, they should provide their
 * own 'handler'.  Used by platform code implementing C-based 1st
 * level decoding.
 */
void handle_IRQ(unsigned int irq, struct pt_regs *regs)    // 参数1为硬件中断号，参数2寄存器结构指针，保存现场时的寄存器信息
{
        __handle_domain_irq(NULL, irq, false, regs);
}

/*
 * asm_do_IRQ is the interface to be used from assembly code.
 */
asmlinkage void __exception_irq_entry
asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
{
        handle_IRQ(irq, regs);
}

/**
 * __handle_domain_irq - Invoke the handler for a HW irq belonging to a domain
 * @domain:     The domain where to perform the lookup
 * @hwirq:      The HW irq number to convert to a logical one
 * @lookup:     Whether to perform the domain lookup or not
 * @regs:       Register file coming from the low-level handling code
 *
 * Returns:     0 on success, or -EINVAL if conversion has failed
 */
int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
                        bool lookup, struct pt_regs *regs)
{
        struct pt_regs *old_regs = set_irq_regs(regs);
        unsigned int irq = hwirq;
        int ret = 0;

        irq_enter();                  //  更新一些系统统计信息，禁止内核抢占

#ifdef CONFIG_IRQ_DOMAIN
        if (lookup)
                irq = irq_find_mapping(domain, hwirq);  //根据中断域和硬件中断号获取IRQ编号
#endif

        /*
         * Some hardware gives randomly wrong interrupts.  Rather
         * than crashing, do something sensible.
         */
        if (unlikely(!irq || irq >= nr_irqs)) {    // 中断号超出范围
                ack_bad_irq(irq);
                ret = -EINVAL;
        } else {
                generic_handle_irq(irq);       // 重点时这里
        }

        irq_exit();               // 退出的时候会检查是否由软中断，如果有。则调用软中断
        set_irq_regs(old_regs);
        return ret;
}

int generic_handle_irq(unsigned int irq)
{
    struct irq_desc *desc = irq_to_desc(irq);   // 通过IRQ编号获取中断描述符
 
    if (!desc)
        return -EINVAL;
    generic_handle_irq_desc(irq, desc);
    return 0;
}

static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
{
    desc->handle_irq(irq, desc);
}

void __init early_trap_init(void *vectors_base)
{
#ifndef CONFIG_CPU_V7M
        unsigned long vectors = (unsigned long)vectors_base;
        extern char __stubs_start[], __stubs_end[];
        extern char __vectors_start[], __vectors_end[];
        unsigned i;

        vectors_page = vectors_base;

        /*
         * Poison the vectors page with an undefined instruction.  This
         * instruction is chosen to be undefined for both ARM and Thumb
         * ISAs.  The Thumb version is an undefined instruction with a
         * branch back to the undefined instruction.
         */
        for (i = 0; i < PAGE_SIZE / sizeof(u32); i++)
                ((u32 *)vectors_base)[i] = 0xe7fddef1;

        /*
         * Copy the vectors, stubs and kuser helpers (in entry-armv.S)
         * into the vector page, mapped at 0xffff0000, and ensure these
         * are visible to the instruction stream.
         */
        memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);
        memcpy((void *)vectors + 0x1000, __stubs_start, __stubs_end - __stubs_start);

        kuser_init(vectors_base);

        flush_icache_range(vectors, vectors + PAGE_SIZE * 2);
#else /* ifndef CONFIG_CPU_V7M */
        /*
         * on V7-M there is no need to copy the vector table to a dedicated
         * memory area. The address is configurable and so a table in the kernel
         * image can be used.
         */
#endif
}

int __init early_irq_init(void)
{
        int count, i, node = first_online_node;
        struct irq_desc *desc;

        init_irq_default_affinity();

        printk(KERN_INFO "NR_IRQS: %dn", NR_IRQS);   // 输出IRQ数量

        desc = irq_desc;
        count = ARRAY_SIZE(irq_desc);                 // 中断描述符数组大小 

        for (i = 0; i < count; i++) {                 // 遍历每一个中断描述符、初始化一些成员
                desc[i].kstat_irqs = alloc_percpu(unsigned int);  // 分配per-CPU变量
                alloc_masks(&desc[i], node);
                raw_spin_lock_init(&desc[i].lock);                   // 自旋锁初始化
                lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
                mutex_init(&desc[i].request_mutex);                  // 互斥锁初始化
                desc_set_defaults(i, &desc[i], node, NULL, NULL);
        }
        return arch_early_irq_init();   // 抵用arch相关的初始化函数，这里为空
}

struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {  // 分配irq_desc
    [0 ... NR_IRQS-1] = {
        .handle_irq    = handle_bad_irq,
        .depth        = 1,
        .lock        = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
    }
};

NR_IRQS: 111
S3C2440: IRQ Support
irq: clearing pending status 00000002

#define IRQ_S3C2416_I2S1        S3C2416_IRQ(7)        // 7 + 58 + 29 + 16 = 110

#if defined(CONFIG_CPU_S3C2416)     // 24xx系列 定义了这个
#define NR_IRQS (IRQ_S3C2416_I2S1 + 1)     // 111
#else
#define NR_IRQS (IRQ_S3C2443_AC97 + 1)
#endif

int __init arch_probe_nr_irqs(void)
{
    nr_irqs = machine_desc->nr_irqs ? machine_desc->nr_irqs : NR_IRQS;
    return nr_irqs;
}

void __init init_IRQ(void)
{
        int ret;

        if (IS_ENABLED(CONFIG_OF) && !machine_desc->init_irq)
                irqchip_init();
        else
                machine_desc->init_irq();   // 执行

        if (IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_CACHE_L2X0) &&
            (machine_desc->l2c_aux_mask || machine_desc->l2c_aux_val)) {
                if (!outer_cache.write_sec)
                        outer_cache.write_sec = machine_desc->l2c_write_sec;
                ret = l2x0_of_init(machine_desc->l2c_aux_val,
                                   machine_desc->l2c_aux_mask);
                if (ret && ret != -ENODEV)
                        pr_err("L2C: failed to init: %dn", ret);
        }

        uniphier_cache_init();
}

MACHINE_START(S3C2440, "SMDK2440")
        /* Maintainer: Ben Dooks <ben-linux@fluff.org> */
        .atag_offset    = 0x100,

        .init_irq       = s3c2440_init_irq,
        .map_io         = smdk2440_map_io,
        .init_machine   = smdk2440_machine_init,
        .init_time      = smdk2440_init_time,
MACHINE_END

void __init s3c2440_init_irq(void)
{
        pr_info("S3C2440: IRQ Supportn");

#ifdef CONFIG_FIQ
        init_FIQ(FIQ_START);
#endif

        s3c_intc[0] = s3c24xx_init_intc(NULL, &init_s3c2440base[0], NULL,    // 为主中断控制器分配一个s3c_irq_intc
                                        0x4a000000);
        if (IS_ERR(s3c_intc[0])) {
                pr_err("irq: could not create main interrupt controllern");
                return;
        }

        s3c24xx_init_intc(NULL, &init_eint[0], s3c_intc[0], 0x560000a4);      // 为外部子中断控制器分配一个s3c_irq_intc，其父为主中断控制器
        s3c_intc[1] = s3c24xx_init_intc(NULL, &init_s3c2440subint[0],         // 为内部子中断控制器分配一个s3c_irq_intc，其父为主中断控制器
                                        s3c_intc[0], 0x4a000018);
}

     s3c_intc[0] = s3c24xx_init_intc(NULL, &init_s3c2440base[0], NULL,
                                        0x4a000000);                // 源挂起寄存器  SRCPND

struct s3c_irq_data {        // 用于保存中断源信息
        unsigned int type;
        unsigned long offset;
        unsigned long parent_irq;           // 如果是子中断，这里保存子中断对应的主中断硬件编号

        /* data gets filled during init */
        struct s3c_irq_intc *intc;           // 存放中断控制器信息
        unsigned long sub_bits;              // 如果当前是主中断源，并且有多个子中断，那么子中断对应的硬件编号为置 1
        struct s3c_irq_intc *sub_intc;       // 子中断中断控制器信息
};

/*
 * Structure holding the controller data
 * @reg_pending         register holding pending irqs
 * @reg_intpnd          special register intpnd in main intc
 * @reg_mask            mask register
 * @domain              irq_domain of the controller
 * @parent              parent controller for ext and sub irqs
 * @irqs                irq-data, always s3c_irq_data[32]
 */
struct s3c_irq_intc {                                   // 保存中断控制器数据
        void __iomem            *reg_pending;           // 指定源挂起寄存器
        void __iomem            *reg_intpnd;            // 指定中断挂起寄存器
        void __iomem            *reg_mask;              // 指定中断屏蔽寄存器
        struct irq_domain       *domain;
        struct s3c_irq_intc     *parent;
        struct s3c_irq_data     *irqs;
};

/*
 * Array holding pointers to the global controller structs
 * [0] ... main_intc
 * [1] ... sub_intc
 * [2] ... main_intc2 on s3c2416
 */
static struct s3c_irq_intc *s3c_intc[3];

static struct s3c_irq_intc * __init s3c24xx_init_intc(struct device_node *np,
                                       struct s3c_irq_data *irq_data, // 中断源信息数组 
                                       struct s3c_irq_intc *parent,   // 指定父中断控制器
                                       unsigned long address)         // 指定中断控制寄存器基地址
{
        struct s3c_irq_intc *intc;
        void __iomem *base = (void *)0xf6000000; /* static mapping */
        int irq_num;
        int irq_start;
        int ret;

        intc = kzalloc(sizeof(struct s3c_irq_intc), GFP_KERNEL);   // 动态分配src_irq_init结构
        if (!intc)
                return ERR_PTR(-ENOMEM);

        intc->irqs = irq_data;

        if (parent)
                intc->parent = parent;                                 // 设置父中断控制器  

        /* select the correct data for the controller.
         * Need to hard code the irq num start and offset
         * to preserve the static mapping for now    
         * 根据实际物理地址，配置MMU映射后的中断相关寄存器地址
         */
        switch (address) {
        case 0x4a000000:                          // SRCPND 源挂起寄存器
                pr_debug("irq: found main intcn");
                intc->reg_pending = base;           // 指定SRCPND
                intc->reg_mask = base + 0x08;       // 指定INTMASK
                intc->reg_intpnd = base + 0x10;     // 指定INTPND 
                irq_num = 32;                       // 中断源数量 
                irq_start = S3C2410_IRQ(0);         // S3C2410_IRQ定义为((X) + S3C2410_CPUIRQ_OFFSET) 最终等于0+16=16
                break;
        case 0x4a000018:                           //  SUBSRCPND  次级源挂起寄存器
                pr_debug("irq: found subintcn"); 
                intc->reg_pending = base + 0x18;      // 指定SUBSRCPND     
                intc->reg_mask = base + 0x1c;         // 指定INTSUBMSK
                irq_num = 29;                         // 中断源数量  为啥是29？
                irq_start = S3C2410_IRQSUB(0);        // 0+ 16 + 58 = 74  
                break;
        case 0x4a000040:
                pr_debug("irq: found intc2n");
                intc->reg_pending = base + 0x40;
                intc->reg_mask = base + 0x48;
                intc->reg_intpnd = base + 0x50;
                irq_num = 8;
                irq_start = S3C2416_IRQ(0);
                break;
        case 0x560000a4:                        // EINTMASK 外部中断屏蔽寄存器 
                pr_debug("irq: found eintcn");
                base = (void *)0xfd000000;

                intc->reg_mask = base + 0xa4;          // EINTMASK
                intc->reg_pending = base + 0xa8;       // EINTPND 
                irq_num = 24;                          // 中断源数量
                irq_start = S3C2410_IRQ(32);           // 32+16=48
                break;
        default:
                pr_err("irq: unsupported controller addressn");
                ret = -EINVAL;
                goto err;
        }
 /* now that all the data is complete, init the irq-domain */
        s3c24xx_clear_intc(intc);               // 清除中断挂起
        intc->domain = irq_domain_add_legacy(np, irq_num, irq_start,   // 初始化中断域，中断域存储了硬件中断号到IRQ编号的映射    irq_start为当前中断域对应的IRQ起始编号
                                             0, &s3c24xx_irq_ops,
                                             intc);
        if (!intc->domain) {
                pr_err("irq: could not create irq-domainn");
                ret = -EINVAL;
                goto err;
        }

        set_handle_irq(s3c24xx_handle_irq);  // 设置irq总中断入口程序为s3c24xx_handle_irq

        return intc;

err:
        kfree(intc);
        return ERR_PTR(ret);
}

static void s3c24xx_clear_intc(struct s3c_irq_intc *intc)
{
        void __iomem *reg_source;
        unsigned long pend;
        unsigned long last;
        int i;

        /* if intpnd is set, read the next pending irq from there */
        reg_source = intc->reg_intpnd ? intc->reg_intpnd : intc->reg_pending;  // 中断挂起期存器？中断挂起期存器:源挂起寄存器

        last = 0;
        for (i = 0; i < 4; i++) {
                pend = readl_relaxed(reg_source);    // 读取寄存器的值

                if (pend == 0 || pend == last)
                        break;

                writel_relaxed(pend, intc->reg_pending);   // 写1、清除挂起状态
                if (intc->reg_intpnd)
                        writel_relaxed(pend, intc->reg_intpnd);

                pr_info("irq: clearing pending status %08xn", (int)pend);
                last = pend;
        }
}

intc->domain = irq_domain_add_legacy(np, irq_num, irq_start,
                                             0, &s3c24xx_irq_ops,
                                             intc);

static const struct irq_domain_ops s3c24xx_irq_ops = {
        .map = s3c24xx_irq_map,          // 比较重要  s3c24xx_irq_map函数主要工作就是设置每个中断的流控处理函数   单独介绍
        .xlate = irq_domain_xlate_twocell,
};

/**
 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
 * @of_node: pointer to interrupt controller's device tree node.
 * @size: total number of irqs in legacy mapping
 * @first_irq: first number of irq block assigned to the domain
 * @first_hwirq: first hwirq number to use for the translation. Should normally
 *               be '0', but a positive integer can be used if the effective
 *               hwirqs numbering does not begin at zero.
 * @ops: map/unmap domain callbacks
 * @host_data: Controller private data pointer
 *
 * Note: the map() callback will be called before this function returns
 * for all legacy interrupts except 0 (which is always the invalid irq for
 * a legacy controller).
 */
struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
                                         unsigned int size,            //中断数量 以主中断为例 32
                                         unsigned int first_irq,       //起始IRQ编号  16
                                         irq_hw_number_t first_hwirq,  //起始硬件中断号   0
                                         const struct irq_domain_ops *ops,
                                         void *host_data)              // 可以传递与中断域相关的任何主机数据，用于设置中断域的host_data私有字段 
{
        struct irq_domain *domain;

        domain = __irq_domain_add(of_node_to_fwnode(of_node), first_hwirq + size,   // 创建irq_domain
                                  first_hwirq + size, 0, ops, host_data);
        if (domain)
                irq_domain_associate_many(domain, first_irq, first_hwirq, size);    // 创建映射

        return domain;
}

/**
 * __irq_domain_add() - Allocate a new irq_domain data structure
 * @fwnode: firmware node for the interrupt controller
 * @size: Size of linear map; 0 for radix mapping only
 * @hwirq_max: Maximum number of interrupts supported by controller
 * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
 *              direct mapping
 * @ops: domain callbacks
 * @host_data: Controller private data pointer
 *
 * Allocates and initialize and irq_domain structure.
 * Returns pointer to IRQ domain, or NULL on failure.
 */
struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,     // size为线性映射表大小 0+32=32
                                    irq_hw_number_t hwirq_max, int direct_max,  // hwiq_max硬件中断号最大值 0+32=32
                                    const struct irq_domain_ops *ops,           // 该结构存放大量函数指针
                                    void *host_data)                             //中断控制器    
{
        struct device_node *of_node = to_of_node(fwnode);
        struct irqchip_fwid *fwid;
        struct irq_domain *domain;

        static atomic_t unknown_domains;

        domain = kzalloc_node(sizeof(*domain) + (sizeof(unsigned int) * size), // 动态分配struct irq_domain、最后4*size是线性lookup table表大小
                              GFP_KERNEL, of_node_to_nid(of_node));
        if (WARN_ON(!domain))
                return NULL;

        if (fwnode && is_fwnode_irqchip(fwnode)) {
                fwid = container_of(fwnode, struct irqchip_fwid, fwnode);

                switch (fwid->type) {
                case IRQCHIP_FWNODE_NAMED:
                case IRQCHIP_FWNODE_NAMED_ID:
                        domain->name = kstrdup(fwid->name, GFP_KERNEL);
                        if (!domain->name) {
                                kfree(domain);
                                return NULL;
                        }
                        domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
                        break;
                default:
                        domain->fwnode = fwnode;
                        domain->name = fwid->name;
                        break;
                }
        } else if (of_node) {
                char *name;

                /*
                 * DT paths contain '/', which debugfs is legitimately
                 * unhappy about. Replace them with ':', which does
                 * the trick and is not as offensive as ''...
                 */
                name = kasprintf(GFP_KERNEL, "%pOF", of_node);
                if (!name) {
                        kfree(domain);
                        return NULL;
                }

                strreplace(name, '/', ':');

                domain->name = name;
                domain->fwnode = fwnode;
                domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
        }

        if (!domain->name) {
                if (fwnode)
                        pr_err("Invalid fwnode type for irqdomainn");
                domain->name = kasprintf(GFP_KERNEL, "unknown-%d",
                                         atomic_inc_return(&unknown_domains));
                if (!domain->name) {
                        kfree(domain);
                        return NULL;
                }
                domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
        }

        of_node_get(of_node);
        /* Fill structure */
        INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
        mutex_init(&domain->revmap_tree_mutex);
        domain->ops = ops;                     // 设置操作集，用于创建映射、翻译等 
        domain->host_data = host_data;         // 绑定中断控制器
        domain->hwirq_max = hwirq_max;        // 设置硬件中断号最大值
        domain->revmap_size = size;           // 设置查找表lookup table大小 
        domain->revmap_direct_max_irq = direct_max;
        irq_domain_check_hierarchy(domain);   // 检查中断域是否级联

        mutex_lock(&irq_domain_mutex);
        debugfs_add_domain_dir(domain);
        list_add(&domain->link, &irq_domain_list);   // 添加到连表，以便发生中断时能能够找到对应的中断域
        mutex_unlock(&irq_domain_mutex);

        pr_debug("Added domain %sn", domain->name);
        return domain;
}

void irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base,
                               irq_hw_number_t hwirq_base, int count)
{
        struct device_node *of_node;
        int i;

        of_node = irq_domain_get_of_node(domain);
        pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)n", __func__,
                of_node_full_name(of_node), irq_base, (int)hwirq_base, count);

        // 遍历中断，在domain线性表，其实就是lookup table，建立硬件中断号到IRQ编号的映射，硬件中断号作为index，通过查表可以获取对应的IRQ编号。
        for (i = 0; i < count; i++) {
                irq_domain_associate(domain, irq_base + i, hwirq_base + i);
        }
}

int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
                         irq_hw_number_t hwirq)
{
        // 根据IRQ编号获取中断数据
        struct irq_data *irq_data = irq_get_irq_data(virq);
        int ret;

        if (WARN(hwirq >= domain->hwirq_max,
                 "error: hwirq 0x%x is too large for %sn", (int)hwirq, domain->name))
                return -EINVAL;
        if (WARN(!irq_data, "error: virq%i is not allocated", virq))
                return -EINVAL;
        if (WARN(irq_data->domain, "error: virq%i is already associated", virq))
                return -EINVAL;

        mutex_lock(&irq_domain_mutex);
        irq_data->hwirq = hwirq;                     // 设置硬件中断号
        irq_data->domain = domain;                   // 设置中断域  
        if (domain->ops->map) {
                // 调用irq domain的map callback函数，即s3c24xx_irq_map
                ret = domain->ops->map(domain, virq, hwirq);
                if (ret != 0) {
                        /*
                         * If map() returns -EPERM, this interrupt is protected
                         * by the firmware or some other service and shall not
                         * be mapped. Don't bother telling the user about it.
                         */
                        if (ret != -EPERM) {
                                pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)n",
                                       domain->name, hwirq, virq, ret);
                        }
                        irq_data->domain = NULL;
                        irq_data->hwirq = 0;
                        mutex_unlock(&irq_domain_mutex);
                        return ret;
                }

                /* If not already assigned, give the domain the chip's name */
                if (!domain->name && irq_data->chip)
                        domain->name = irq_data->chip->name;
        }

        domain->mapcount++;
        irq_domain_set_mapping(domain, hwirq, irq_data);  // 把硬件中断号到IRQ编号的映射添加到中断域的线性表linear_revmap
        mutex_unlock(&irq_domain_mutex);

        irq_clear_status_flags(virq, IRQ_NOREQUEST);   // 该中断已经可以申请了，因此clear相关flag

        return 0;
}

static void irq_domain_set_mapping(struct irq_domain *domain,
                                   irq_hw_number_t hwirq,
                                   struct irq_data *irq_data)
{
        if (hwirq < domain->revmap_size) {     // 硬件中断号 < 线性lookup table的大小
                domain->linear_revmap[hwirq] = irq_data->irq;     // 填写线性映射lookup table的数据
        } else {
                mutex_lock(&domain->revmap_tree_mutex);
                radix_tree_insert(&domain->revmap_tree, hwirq, irq_data);   // 向radix tree插入一个node
                mutex_unlock(&domain->revmap_tree_mutex);
        }
}

unsigned int irq_create_mapping(struct irq_domain *domain, irq_hw_number_t hwirq);

irq_create_mapping(domain, hwirq) 
     virq  = irq_find_mapping(domain, hwirq)    // 判断hwirq映射是否存在，如果存在，直接返回
     irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node), NULL) // 为硬件中断动态申请中断描述符
     irq_domain_associate(domain, virq, hwirq)   // 为中断域添加hwirq到virq的映射
         domain->ops->map(domain, virq, hwirq)   // 回调domain操作集map函数  
         irq_domain_set_mapping(domain, hwirq, irq_data); // 把硬件中断号到IRQ编号的映射添加到中断域的线性表linear_revmap  

/**
 * irq_find_mapping() - Find a linux irq from a hw irq number.
 * @domain: domain owning this hardware interrupt
 * @hwirq: hardware irq number in that domain space
 */
unsigned int irq_find_mapping(struct irq_domain *domain,
                              irq_hw_number_t hwirq)
{
        struct irq_data *data;

        /* Look for default domain if nececssary */
        if (domain == NULL)
                domain = irq_default_domain;
        if (domain == NULL)
                return 0;

        if (hwirq < domain->revmap_direct_max_irq) {
                data = irq_domain_get_irq_data(domain, hwirq);  
                if (data && data->hwirq == hwirq)
                        return hwirq;
        }

        /* Check if the hwirq is in the linear revmap. */
        if (hwirq < domain->revmap_size)
                return domain->linear_revmap[hwirq];  // 线性映射表 数组索引为硬件中断号

        rcu_read_lock();
        data = radix_tree_lookup(&domain->revmap_tree, hwirq);
        rcu_read_unlock();
        return data ? data->irq : 0;
}

static int s3c24xx_irq_map(struct irq_domain *h, unsigned int virq,    
                                                        irq_hw_number_t hw)  
{
        struct s3c_irq_intc *intc = h->host_data;         // 获取中断域绑定的中断控制器
        struct s3c_irq_data *irq_data = &intc->irqs[hw];  // 根据硬件中断号获取中断源信息
        struct s3c_irq_intc *parent_intc;
        struct s3c_irq_data *parent_irq_data;
        unsigned int irqno;

        /* attach controller pointer to irq_data */
        irq_data->intc = intc;
        irq_data->offset = hw;                   // 硬件中断在中断相关寄存器的偏移位

        parent_intc = intc->parent;              // 如果有父中断控制器

        /* set handler and flags */
        switch (irq_data->type) {    // 根据中断源类型设置中断处理函数
        case S3C_IRQTYPE_NONE:
                return 0;
        case S3C_IRQTYPE_EINT:                // 外部中断
                /* On the S3C2412, the EINT0to3 have a parent irq
                 * but need the s3c_irq_eint0t4 chip
                 */
                if (parent_intc && (!soc_is_s3c2412() || hw >= 4))             // 对于子中断控制器，走这里
                        irq_set_chip_and_handler(virq, &s3c_irqext_chip,
                                                 handle_edge_irq);
                else                                          
                        irq_set_chip_and_handler(virq, &s3c_irq_eint0t4,
                                                 handle_edge_irq);
                break;
        case S3C_IRQTYPE_EDGE:            // 双边沿触发中断 
                if (parent_intc || intc->reg_pending == S3C2416_SRCPND2)   // 对于子中断控制器，走这里
                        irq_set_chip_and_handler(virq, &s3c_irq_level_chip,
                                                 handle_edge_irq);
                else
                        irq_set_chip_and_handler(virq, &s3c_irq_chip,
                                                 handle_edge_irq);
                break;
        case S3C_IRQTYPE_LEVEL:            // 电平触发  
                if (parent_intc)                    // 对于子中断控制器走这里
                        irq_set_chip_and_handler(virq, &s3c_irq_level_chip,
                                                 handle_level_irq);
                else
                        irq_set_chip_and_handler(virq, &s3c_irq_chip,
                                                 handle_level_irq);
                break;
        default:
                pr_err("irq-s3c24xx: unsupported irqtype %dn", irq_data->type);
                return -EINVAL;
        }
        irq_set_chip_data(virq, irq_data);

        if (parent_intc && irq_data->type != S3C_IRQTYPE_NONE) {  // 有父级中断控制器，即子中断控制器，需要修改主中断源的中断处理函数为s3c_irq_demux
                if (irq_data->parent_irq > 31) {
                        pr_err("irq-s3c24xx: parent irq %lu is out of rangen",
                               irq_data->parent_irq);
                        return -EINVAL;
                }

                parent_irq_data = &parent_intc->irqs[irq_data->parent_irq];  // 获取子中断对应的主中断源数据
                parent_irq_data->sub_intc = intc;                  // 设置子中断中断控制器
                parent_irq_data->sub_bits |= (1UL << hw);

                /* attach the demuxer to the parent irq */
                irqno = irq_find_mapping(parent_intc->domain,   // 根据主中断硬件中断号和中断域获取主中断编号
                                         irq_data->parent_irq);
                if (!irqno) {
                        pr_err("irq-s3c24xx: could not find mapping for parent irq %lun",
                               irq_data->parent_irq);
                        return -EINVAL;
                }
                irq_set_chained_handler(irqno, s3c_irq_demux);   // 设置子中断的主中断源的中断处理函数
        }

        return 0;
}

static void s3c_irq_demux(struct irq_desc *desc)
{
        // 根据中断描述符获取中断控制器irq_chip 这个是主中断源对应的中断控制器
        struct irq_chip *chip = irq_desc_get_chip(desc);     // desc->irq_data.chip
        struct s3c_irq_data *irq_data = irq_desc_get_chip_data(desc);
        // 获取中断控制器s3c_irq_intc
        struct s3c_irq_intc *intc = irq_data->intc;
        // 获取子中断控制器
        struct s3c_irq_intc *sub_intc = irq_data->sub_intc;
        unsigned int n, offset, irq;
        unsigned long src, msk;

        /* we're using individual domains for the non-dt case
         * and one big domain for the dt case where the subintc
         * starts at hwirq number 32.
         */
        offset = irq_domain_get_of_node(intc->domain) ? 32 : 0;

        chained_irq_enter(chip, desc);
 
        src = readl_relaxed(sub_intc->reg_pending);   // 读取中断挂起寄存器
        msk = readl_relaxed(sub_intc->reg_mask);      // 读取中断屏蔽寄存器

        src &= ~msk;
        src &= irq_data->sub_bits;

        while (src) {
                n = __ffs(src);
                src &= ~(1 << n);
                // 获取子中断控制器sub_intc硬件中断offset + n对应的IRQ编号
                irq = irq_find_mapping(sub_intc->domain, offset + n);
                // 执行子中断中断处理函数
                generic_handle_irq(irq);
        }

        chained_irq_exit(chip, desc);
}

static struct irq_chip s3c_irq_chip = {
        .name           = "s3c",
        .irq_ack        = s3c_irq_ack,
        .irq_mask       = s3c_irq_mask,
        .irq_unmask     = s3c_irq_unmask,
        .irq_set_type   = s3c_irq_type,
        .irq_set_wake   = s3c_irq_wake
};

static struct irq_chip s3c_irq_level_chip = {
        .name           = "s3c-level",
        .irq_mask       = s3c_irq_mask,
        .irq_unmask     = s3c_irq_unmask,
        .irq_ack        = s3c_irq_ack,
        .irq_set_type   = s3c_irq_type,
};

static struct irq_chip s3c_irqext_chip = {
        .name           = "s3c-ext",
        .irq_mask       = s3c_irq_mask,
        .irq_unmask     = s3c_irq_unmask,
        .irq_ack        = s3c_irq_ack,
        .irq_set_type   = s3c_irqext_type,
        .irq_set_wake   = s3c_irqext_wake
};

static struct irq_chip s3c_irq_eint0t4 = {
        .name           = "s3c-ext0",
        .irq_ack        = s3c_irq_ack,
        .irq_mask       = s3c_irq_mask,
        .irq_unmask     = s3c_irq_unmask,
        .irq_set_wake   = s3c_irq_wake,
        .irq_set_type   = s3c_irqext0_type,
};

static void s3c_irq_mask(struct irq_data *data)  // data为当前中断的数据
{
        struct s3c_irq_data *irq_data = irq_data_get_irq_chip_data(data);
        struct s3c_irq_intc *intc = irq_data->intc;
        struct s3c_irq_intc *parent_intc = intc->parent;  // 父中断控制器
        struct s3c_irq_data *parent_data;
        unsigned long mask;
        unsigned int irqno;

        mask = readl_relaxed(intc->reg_mask);
        mask |= (1UL << irq_data->offset);
        writel_relaxed(mask, intc->reg_mask);

        if (parent_intc) {   // 如果是子中断，判断该子中断所属的主中断是不是还有其它子中断在使用，如果没有的话，也会把该主中断也给屏蔽了
                parent_data = &parent_intc->irqs[irq_data->parent_irq];

                /* check to see if we need to mask the parent IRQ
                 * The parent_irq is always in main_intc, so the hwirq
                 * for find_mapping does not need an offset in any case.
                 */
                if ((mask & parent_data->sub_bits) == parent_data->sub_bits) {
                        irqno = irq_find_mapping(parent_intc->domain,
                                         irq_data->parent_irq);
                        s3c_irq_mask(irq_get_irq_data(irqno));
                }
        }
}

static inline void irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip,
                                            irq_flow_handler_t handle)
{
        irq_set_chip_and_handler_name(irq, chip, handle, NULL);
}

void irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
                              irq_flow_handler_t handle, const char *name)
{
        irq_set_chip(irq, chip);
        __irq_set_handler(irq, handle, 0, name);
}

void
__irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                  const char *name)
{
        unsigned long flags;
        struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, 0);

        if (!desc)
                return;

        __irq_do_set_handler(desc, handle, is_chained, name);
        irq_put_desc_busunlock(desc, flags);
}

#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
int __init set_handle_irq(void (*handle_irq)(struct pt_regs *))
{
        if (handle_arch_irq)
                return -EBUSY;

        handle_arch_irq = handle_irq;
        return 0;
}

.macro  irq_handler
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
        ldr     r1, =handle_arch_irq
        mov     r0, sp
        badr    lr, 9997f
        ldr     pc, [r1]
#else
        arch_irq_handler_default
#endif
9997:
        .endm

asmlinkage void __exception_irq_entry s3c24xx_handle_irq(struct pt_regs *regs)
{
        do {
                if (likely(s3c_intc[0]))
                        if (s3c24xx_handle_intc(s3c_intc[0], regs, 0))   // 执行这里
                                continue;

                if (s3c_intc[2])
                        if (s3c24xx_handle_intc(s3c_intc[2], regs, 64))
                                continue;

                break;
        } while (1);
}

static inline int s3c24xx_handle_intc(struct s3c_irq_intc *intc,              
                                      struct pt_regs *regs, int intc_offset)   // 硬件中断号起始偏移
{
        int pnd;
        int offset;

        pnd = readl_relaxed(intc->reg_intpnd);  // 读取中断挂起寄存器，从而知道触发了哪些中断源
        if (!pnd)
                return false;

        /* non-dt machines use individual domains */
        if (!irq_domain_get_of_node(intc->domain))
                intc_offset = 0;

        /* We have a problem that the INTOFFSET register does not always
         * show one interrupt. Occasionally we get two interrupts through
         * the prioritiser, and this causes the INTOFFSET register to show
         * what looks like the logical-or of the two interrupt numbers.
         *
         * Thanks to Klaus, Shannon, et al for helping to debug this problem
         */
        offset = readl_relaxed(intc->reg_intpnd + 4);    // 读取中断偏移寄存器 获取硬件中断号

        /* Find the bit manually, when the offset is wrong.
         * The pending register only ever contains the one bit of the next
         * interrupt to handle.
         */
        if (!(pnd & (1 << offset)))                    // 再次校验发生了中断
                offset =  __ffs(pnd);

        handle_domain_irq(intc->domain, intc_offset + offset, regs);
        return true;
}

static inline int handle_domain_irq(struct irq_domain *domain,
                                    unsigned int hwirq, struct pt_regs *regs)
{
        return __handle_domain_irq(domain, hwirq, true, regs);
}

typedef void (*irq_flow_handler_t)(struct irq_desc *desc);

/**
 *      handle_simple_irq - Simple and software-decoded IRQs.
 *      @desc:  the interrupt description structure for this irq
 *
 *      Simple interrupts are either sent from a demultiplexing interrupt
 *      handler or come from hardware, where no interrupt hardware control
 *      is necessary.
 *
 *      Note: The caller is expected to handle the ack, clear, mask and
 *      unmask issues if necessary.
 */
void handle_simple_irq(struct irq_desc *desc)
{
        raw_spin_lock(&desc->lock);  // 首先获取自旋锁

        if (!irq_may_run(desc))
                goto out_unlock;

        desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);

        if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {  // 没有指定中断处理函数、或者中断禁止
                desc->istate |= IRQS_PENDING;   // 挂起标志位置1
                goto out_unlock;
        }

        kstat_incr_irqs_this_cpu(desc);
        handle_irq_event(desc);

out_unlock:
        raw_spin_unlock(&desc->lock);  // 释放锁
}

static bool irq_may_run(struct irq_desc *desc)
{
        unsigned int mask = IRQD_IRQ_INPROGRESS | IRQD_WAKEUP_ARMED;

        /*
         * If the interrupt is not in progress and is not an armed
         * wakeup interrupt, proceed.
         */
        if (!irqd_has_set(&desc->irq_data, mask))
                return true;

        /*
         * If the interrupt is an armed wakeup source, mark it pending
         * and suspended, disable it and notify the pm core about the
         * event.
         */
        if (irq_pm_check_wakeup(desc))
                return false;

        /*
         * Handle a potential concurrent poll on a different core.
         */
        return irq_check_poll(desc);
}

/**
 *      handle_level_irq - Level type irq handler
 *      @desc:  the interrupt description structure for this irq
 *
 *      Level type interrupts are active as long as the hardware line has
 *      the active level. This may require to mask the interrupt and unmask
 *      it after the associated handler has acknowledged the device, so the
 *      interrupt line is back to inactive.
 */
void handle_level_irq(struct irq_desc *desc)
{
        raw_spin_lock(&desc->lock);
        mask_ack_irq(desc);

        if (!irq_may_run(desc))  
                goto out_unlock;

        desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);

        /*
         * If its disabled or no action available
         * keep it masked and get out of here
         */
        if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {   // 没有设置处理程序，或者中断禁止
                desc->istate |= IRQS_PENDING;         
                goto out_unlock;
        }

        kstat_incr_irqs_this_cpu(desc);
        handle_irq_event(desc);

        cond_unmask_irq(desc);

out_unlock:
        raw_spin_unlock(&desc->lock);
}

irqreturn_t handle_irq_event(struct irq_desc *desc)
{
        irqreturn_t ret;

        desc->istate &= ~IRQS_PENDING;                      // 清除挂起标志位
        irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);     // 设置中断处理标志位
        raw_spin_unlock(&desc->lock);                       // 释放锁

        ret = handle_irq_event_percpu(desc);                // 中断处理

        raw_spin_lock(&desc->lock);                         // 获取锁
        irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);   // 清除中断处理标志位
        return ret;
}

irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
{
        irqreturn_t retval;
        unsigned int flags = 0;

        retval = __handle_irq_event_percpu(desc, &flags);

        add_interrupt_randomness(desc->irq_data.irq, flags);

        if (!noirqdebug)
                note_interrupt(desc, retval);
        return retval;
}

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;

        record_irq_time(desc);

        for_each_action_of_desc(desc, action) {
                irqreturn_t res;

                trace_irq_handler_entry(irq, action);
                res = action->handler(irq, action->dev_id);  // 调用action->handler、即request_threaded_irq时注册的primary handler
                trace_irq_handler_exit(irq, action, res);

                if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pS enabled interruptsn",  // 如果当前CPU总中断被禁止，返回非0，否则返回0
                              irq, action->handler))
                        local_irq_disable();       // 关闭当前CPU所有中断

                switch (res) {
                case IRQ_WAKE_THREAD:      // 唤醒中断线程
                        /*
                         * Catch drivers which return WAKE_THREAD but
                         * did not set up a thread function
                         */
                        if (unlikely(!action->thread_fn)) {
                                warn_no_thread(irq, action);
                                break;
                        }

                        __irq_wake_thread(desc, action);   // 唤醒中断线程

                        /* Fall through - to add to randomness */
                case IRQ_HANDLED:
                        *flags |= action->flags;
                        break;

                default:
                        break;
                }

                retval |= res;
        }

        return retval;
}

void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
{
        /*
         * In case the thread crashed and was killed we just pretend that
         * we handled the interrupt. The hardirq handler has disabled the
         * device interrupt, so no irq storm is lurking.
         */
        if (action->thread->flags & PF_EXITING)  // 设置了PF_EXITING标志 退出
                return;

        /*
         * Wake up the handler thread for this action. If the
         * RUNTHREAD bit is already set, nothing to do.
         */
        if (test_and_set_bit(IRQTF_RUNTHREAD, &action->thread_flags)) // 已经在执行
                return;

        /*
         * It's safe to OR the mask lockless here. We have only two
         * places which write to threads_oneshot: This code and the
         * irq thread.
         *
         * This code is the hard irq context and can never run on two
         * cpus in parallel. If it ever does we have more serious
         * problems than this bitmask.
         *
         * The irq threads of this irq which clear their "running" bit
         * in threads_oneshot are serialized via desc->lock against
         * each other and they are serialized against this code by
         * IRQS_INPROGRESS.
         *
         * Hard irq handler:
         *
         *      spin_lock(desc->lock);
         *      desc->state |= IRQS_INPROGRESS;
         *      spin_unlock(desc->lock);
         *      set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
         *      desc->threads_oneshot |= mask;
         *      spin_lock(desc->lock);
         *      desc->state &= ~IRQS_INPROGRESS;
         *      spin_unlock(desc->lock);
         *
         * irq thread:
         *
         * again:
         *      spin_lock(desc->lock);
         *      if (desc->state & IRQS_INPROGRESS) {
         *              spin_unlock(desc->lock);
         *              while(desc->state & IRQS_INPROGRESS)
         *                      cpu_relax();
         *              goto again;
         *      }
         *      if (!test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
         *              desc->threads_oneshot &= ~mask;
         *      spin_unlock(desc->lock);
         *
         * So either the thread waits for us to clear IRQS_INPROGRESS
         * or we are waiting in the flow handler for desc->lock to be
         * released before we reach this point. The thread also checks
         * IRQTF_RUNTHREAD under desc->lock. If set it leaves
         * threads_oneshot untouched and runs the thread another time.
         */
        desc->threads_oneshot |= action->thread_mask;

        /*
         * We increment the threads_active counter in case we wake up
         * the irq thread. The irq thread decrements the counter when
         * it returns from the handler or in the exit path and wakes
         * up waiters which are stuck in synchronize_irq() when the
         * active count becomes zero. synchronize_irq() is serialized
         * against this code (hard irq handler) via IRQS_INPROGRESS
         * like the finalize_oneshot() code. See comment above.
         */
        atomic_inc(&desc->threads_active);    // 线程唤醒次数

        wake_up_process(action->thread);   // 唤醒线程
}