字符设备驱动笔记——中断方式按键驱动之linux中断处理结构（五）

一、单片机下的中断处理
　　1)分辨是哪一个中断
　　2)调用处理函数
　　3)清中断
二、linux下的中断处理

1)/arch/arm/kernel/irq.c
asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
{
    struct pt_regs *old_regs = set_irq_regs(regs);
    struct irq_desc *desc = irq_desc + irq;

    /*
     * Some hardware gives randomly wrong interrupts.  Rather
     * than crashing, do something sensible.
     */
    if (irq >= NR_IRQS)
        desc = &bad_irq_desc;

    irq_enter();

    desc_handle_irq(irq, desc);

    /* AT91 specific workaround */
    irq_finish(irq);

    irq_exit();
    set_irq_regs(old_regs);
}

2)/kernel/irq/handle.c
static inline void desc_handle_irq(unsigned int irq, struct irq_desc *desc)
{
    desc->handle_irq(irq, desc);
}

3)/kernel/irq/chip.c
__set_irq_handler{
    ...
    desc->handle_irq = handle;
    ...
}

4)/include/linux/irq.h
static inline void
set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
{
    __set_irq_handler(irq, handle, 0, NULL);
}

5)/arch/arm/plat-s3c24xx/irq.c
void __init s3c24xx_init_irq(void)

6)/arch/arm/plat-s3c24xx/irq.c
set_irq_handler(irqno, handle_edge_irq);

7)/kernel/irq/chip.c
  调用4)
  调用3)
8)在s3c24xx_init_irq这个函数里面，初始化irq_desc结构体
struct irq_desc {
    irq_flow_handler_t    handle_irq;        //set_irq_handler(irqno, handle_edge_irq);
    struct irq_chip        *chip;               //set_irq_chip(irqno, &s3c_irq_eint0t4);
    struct msi_desc        *msi_desc;
    void            *handler_data;
    void            *chip_data;
    struct irqaction    *action;    /* IRQ action list */
    unsigned int        status;        /* IRQ status */

....
9)/kernel/irq/chip.c
分析handle_edge_irq：
void fastcall
handle_edge_irq(unsigned int irq, struct irq_desc *desc)
{
    const unsigned int cpu = smp_processor_id();

    spin_lock(&desc->lock);

    desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);

    /*
     * If we're currently running this IRQ, or its disabled,
     * we shouldn't process the IRQ. Mark it pending, handle
     * the necessary masking and go out
     */
    if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
            !desc->action)) {
        desc->status |= (IRQ_PENDING | IRQ_MASKED);
        mask_ack_irq(desc, irq);
        goto out_unlock;
    }

    kstat_cpu(cpu).irqs[irq]++;            //发生中断的次数

    /* Start handling the irq */        //开始处理中断
    desc->chip->ack(irq);        //desc->chip chip是之前初始化的s3c_irqext_chip

    /* Mark the IRQ currently in progress.*/
    desc->status |= IRQ_INPROGRESS;

    do {
        struct irqaction *action = desc->action;
        irqreturn_t action_ret;

        if (unlikely(!action)) {    //判断链表是否为空
            desc->chip->mask(irq);
            goto out_unlock;
        }

        /*
         * When another irq arrived while we were handling
         * one, we could have masked the irq.
         * Renable it, if it was not disabled in meantime.
         */
        if (unlikely((desc->status &
                   (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
                  (IRQ_PENDING | IRQ_MASKED))) {
            desc->chip->unmask(irq);
            desc->status &= ~IRQ_MASKED;
        }

        desc->status &= ~IRQ_PENDING;
        spin_unlock(&desc->lock);
        action_ret = handle_IRQ_event(irq, action);//真正的处理过程
        if (!noirqdebug)
            note_interrupt(irq, desc, action_ret);
        ......
}

10)
/arch/arm/plat-s3c24xx/irq.c
s3c_irqext_chip中的.ack
static struct irq_chip s3c_irqext_chip = {
    .name        = "s3c-ext",
    .mask        = s3c_irqext_mask,
    .unmask        = s3c_irqext_unmask,
    .ack        = s3c_irqext_ack,
    .set_type    = s3c_irqext_type,
    .set_wake    = s3c_irqext_wake
};
s3c_irqext_ack分析：
static void
s3c_irqext_ack(unsigned int irqno)
{
    unsigned long req;
    unsigned long bit;
    unsigned long mask;

    bit = 1UL << (irqno - EXTINT_OFF);

    mask = __raw_readl(S3C24XX_EINTMASK);

    __raw_writel(bit, S3C24XX_EINTPEND);

    req = __raw_readl(S3C24XX_EINTPEND);
    req &= ~mask;

    /* not sure if we should be acking the parent irq... */

    if (irqno <= IRQ_EINT7 ) {
        if ((req & 0xf0) == 0)
            s3c_irq_ack(IRQ_EINT4t7);
    } else {
        if ((req >> 8) == 0)
            s3c_irq_ack(IRQ_EINT8t23);
    }
}

static inline void
s3c_irq_ack(unsigned int irqno)
{
    unsigned long bitval = 1UL << (irqno - IRQ_EINT0);

    __raw_writel(bitval, S3C2410_SRCPND);
    __raw_writel(bitval, S3C2410_INTPND);
}

①desc->chip->ack(irq);//上面是清理中断
============================================================
②handle_edge_irq取出action链表中的成员，执行action->handler

irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
    irqreturn_t ret, retval = IRQ_NONE;
    unsigned int status = 0;

    handle_dynamic_tick(action);

    if (!(action->flags & IRQF_DISABLED))
        local_irq_enable_in_hardirq();

    do {
        ret = action->handler(irq, action->dev_id);
        if (ret == IRQ_HANDLED)
            status |= action->flags;
        retval |= ret;
        action = action->next;
    } while (action);

    if (status & IRQF_SAMPLE_RANDOM)
        add_interrupt_randomness(irq);
    local_irq_disable();

    return retval;
}

总结：
按下按键
1>cup进入异常处理模式
    b vector_irq + ...
2>__irq_user
3>asm_do_IRQ
4>irq_des[irq]以中断号为下标取出一项 ->handle_irq
  struct irq_desc {
    irq_flow_handler_t    handle_irq;        //set_irq_handler(irqno, handle_edge_irq);
                                        //handle_edge_irq取出action链表中的成员，
                                        //执行action->handler(自定义实现)
    struct irq_chip        *chip;               //set_irq_chip(irqno, &s3c_irq_eint0t4);
    //芯片相关的一些操作
    ...
    }
5>handle_irq = handle_edge_irq
6>handle_edge_irq的操作：
  (1)desc->chip->ack(irq);
  (2)handle_IRQ_event(irq, action);
  
===========================================================================================
自定义异常处理函数action->handler,注册进内核

request_irq


1./kernel/irq/manage.c
int request_irq(unsigned int irq, irq_handler_t handler,
        unsigned long irqflags, const char *devname, void *dev_id)
{
    //1)分配了一个结构，结构中的成员指向传递进来的参数
    action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
    //2)设置irq
    retval = setup_irq(irq, action);
}

2.setup_irq()函数分析：
  1)irq_des[irq] 已irq为下标找到数组项
  2)在irq_des[irq]链表里面加入传递进来的参数action
  3)desc->chip->settype()设置为中断引脚                        
  4)desc->chip->startup / desc->chip->enable 使能中断
  
free_irq(irq, dev_id)
  1)从链表中除去
  2)禁止中断