转自：

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/tiantao2012/article/details/78957472[html] view plain copyint setup_irq(unsigned int irq, struct irqaction *act)用于设置irq对应的irqaction.    其使用的例程如下：  struct irq_domain * __init __init_i8259_irqs(struct device_node *node)  {      struct irq_domain *domain;        insert_resource(&ioport_resource, &pic1_io_resource);      insert_resource(&ioport_resource, &pic2_io_resource);        init_8259A(0);        domain = irq_domain_add_legacy(node, 16, I8259A_IRQ_BASE, 0,                         &i8259A_ops, NULL);      if (!domain)          panic("Failed to add i8259 IRQ domain");        setup_irq(I8259A_IRQ_BASE + PIC_CASCADE_IR, &irq2);      return domain;  }  其源码分析如下：    int setup_irq(unsigned int irq, struct irqaction *act)  {      int retval;      struct irq_desc *desc = irq_to_desc(irq);      #中断描述为null，或者设置了_IRQ_PER_CPU_DEVID 标志的话，则直接退出      if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))          return -EINVAL;        retval = irq_chip_pm_get(&desc->irq_data);      if (retval < 0)          return retval;      #核心代码，设置irq对应的irqaction *act      retval = __setup_irq(irq, desc, act);        if (retval)          irq_chip_pm_put(&desc->irq_data);        return retval;  }  static int  __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)  {      struct irqaction *old, **old_ptr;      unsigned long flags, thread_mask = 0;      int ret, nested, shared = 0;      #中断描述符为null，则退出      if (!desc)          return -EINVAL;      #没有设置irq_data.chip，所以irq_data.chip 会等于no_irq_chip。这属于异常case ，退出.      if (desc->irq_data.chip == &no_irq_chip)          return -ENOSYS;      #增加这个模块的引用计数      if (!try_module_get(desc->owner))          return -ENODEV;      #更新struct irqaction *new 中的irq number      new->irq = irq;        /*       * If the trigger type is not specified by the caller,       * then use the default for this interrupt.       */       #没有设置中断触发类型的话，则用默认值.      if (!(new->flags & IRQF_TRIGGER_MASK))          new->flags |= irqd_get_trigger_type(&desc->irq_data);        /*       * Check whether the interrupt nests into another interrupt       * thread.       */      #检查这里是否是中断嵌套，正常情况下irq_chip 基本都不支持中断嵌套      nested = irq_settings_is_nested_thread(desc);      if (nested) {          if (!new->thread_fn) {              ret = -EINVAL;              goto out_mput;          }          /*           * Replace the primary handler which was provided from           * the driver for non nested interrupt handling by the           * dummy function which warns when called.           */          new->handler = irq_nested_primary_handler;      } else {      #这里检查是否为这个中断设置一个thread，也就是说是否支持中断线程化          if (irq_settings_can_thread(desc)) {              ret = irq_setup_forced_threading(new);              if (ret)                  goto out_mput;          }      }        /*       * Create a handler thread when a thread function is supplied       * and the interrupt does not nest into another interrupt       * thread.       */      #在没有支持中断嵌套且用户用设置中断线程的情况下,这里会创建一个中断线程      if (new->thread_fn && !nested) {          ret = setup_irq_thread(new, irq, false);          if (ret)              goto out_mput;          #中断线程化时是否支持第二个线程。如果支持的话，再创建一个中断线程.          if (new->secondary) {              ret = setup_irq_thread(new->secondary, irq, true);              if (ret)                  goto out_thread;          }      }        /*       * Drivers are often written to work w/o knowledge about the       * underlying irq chip implementation, so a request for a       * threaded irq without a primary hard irq context handler       * requires the ONESHOT flag to be set. Some irq chips like       * MSI based interrupts are per se one shot safe. Check the       * chip flags, so we can avoid the unmask dance at the end of       * the threaded handler for those.       */      #有设置oneshot 标志的话，则清掉这个标志.      if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)          new->flags &= ~IRQF_ONESHOT;        /*       * Protects against a concurrent __free_irq() call which might wait       * for synchronize_irq() to complete without holding the optional       * chip bus lock and desc->lock.       */      mutex_lock(&desc->request_mutex);        /*       * Acquire bus lock as the irq_request_resources() callback below       * might rely on the serialization or the magic power management       * functions which are abusing the irq_bus_lock() callback,       */      chip_bus_lock(desc);        /* First installed action requests resources. */      #中断描述符的action为null的话，则通过irq_request_resources 来申请中断资源.      if (!desc->action) {          ret = irq_request_resources(desc);          if (ret) {              pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",                     new->name, irq, desc->irq_data.chip->name);              goto out_bus_unlock;          }      }        /*       * The following block of code has to be executed atomically       * protected against a concurrent interrupt and any of the other       * management calls which are not serialized via       * desc->request_mutex or the optional bus lock.       */      raw_spin_lock_irqsave(&desc->lock, flags);      old_ptr = &desc->action;      old = *old_ptr;      #如果这个中断号对应的中断描述符中的action 不为null，说明这个中断号之前可能已经申请过中断了      #这里同样可以得出结论，同一个中断好，可以重复申请中断，但是可能会继承前一次的中断触发类型.      if (old) {          /*           * Can't share interrupts unless both agree to and are           * the same type (level, edge, polarity). So both flag           * fields must have IRQF_SHARED set and the bits which           * set the trigger type must match. Also all must           * agree on ONESHOT.           */          unsigned int oldtype;            /*           * If nobody did set the configuration before, inherit           * the one provided by the requester.           */          if (irqd_trigger_type_was_set(&desc->irq_data)) {              oldtype = irqd_get_trigger_type(&desc->irq_data);          } else {              oldtype = new->flags & IRQF_TRIGGER_MASK;              irqd_set_trigger_type(&desc->irq_data, oldtype);          }            if (!((old->flags & new->flags) & IRQF_SHARED) ||              (oldtype != (new->flags & IRQF_TRIGGER_MASK)) ||              ((old->flags ^ new->flags) & IRQF_ONESHOT))              goto mismatch;            /* All handlers must agree on per-cpuness */          if ((old->flags & IRQF_PERCPU) !=              (new->flags & IRQF_PERCPU))              goto mismatch;            /* add new interrupt at end of irq queue */          do {              /*               * Or all existing action->thread_mask bits,               * so we can find the next zero bit for this               * new action.               */              thread_mask |= old->thread_mask;              old_ptr = &old->next;              old = *old_ptr;          } while (old);          shared = 1;      }        /*       * Setup the thread mask for this irqaction for ONESHOT. For       * !ONESHOT irqs the thread mask is 0 so we can avoid a       * conditional in irq_wake_thread().       */      if (new->flags & IRQF_ONESHOT) {          /*           * Unlikely to have 32 resp 64 irqs sharing one line,           * but who knows.           */          if (thread_mask == ~0UL) {              ret = -EBUSY;              goto out_unlock;          }          /*           * The thread_mask for the action is or'ed to           * desc->thread_active to indicate that the           * IRQF_ONESHOT thread handler has been woken, but not           * yet finished. The bit is cleared when a thread           * completes. When all threads of a shared interrupt           * line have completed desc->threads_active becomes           * zero and the interrupt line is unmasked. See           * handle.c:irq_wake_thread() for further information.           *           * If no thread is woken by primary (hard irq context)           * interrupt handlers, then desc->threads_active is           * also checked for zero to unmask the irq line in the           * affected hard irq flow handlers           * (handle_[fasteoi|level]_irq).           *           * The new action gets the first zero bit of           * thread_mask assigned. See the loop above which or's           * all existing action->thread_mask bits.           */          new->thread_mask = 1UL << ffz(thread_mask);        } else if (new->handler == irq_default_primary_handler &&             !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {          /*           * The interrupt was requested with handler = NULL, so           * we use the default primary handler for it. But it           * does not have the oneshot flag set. In combination           * with level interrupts this is deadly, because the           * default primary handler just wakes the thread, then           * the irq lines is reenabled, but the device still           * has the level irq asserted. Rinse and repeat....           *           * While this works for edge type interrupts, we play           * it safe and reject unconditionally because we can't           * say for sure which type this interrupt really           * has. The type flags are unreliable as the           * underlying chip implementation can override them.           */          pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",                 irq);          ret = -EINVAL;          goto out_unlock;      }      #非共享中断      if (!shared) {          #初始化一个等待队列，这个等待队列包含在中断描述符中          init_waitqueue_head(&desc->wait_for_threads);            /* Setup the type (level, edge polarity) if configured: */          if (new->flags & IRQF_TRIGGER_MASK) {              ret = __irq_set_trigger(desc,                          new->flags & IRQF_TRIGGER_MASK);                if (ret)                  goto out_unlock;          }            /*           * Activate the interrupt. That activation must happen           * independently of IRQ_NOAUTOEN. request_irq() can fail           * and the callers are supposed to handle           * that. enable_irq() of an interrupt requested with           * IRQ_NOAUTOEN is not supposed to fail. The activation           * keeps it in shutdown mode, it merily associates           * resources if necessary and if that's not possible it           * fails. Interrupts which are in managed shutdown mode           * will simply ignore that activation request.           */           #激活这个中断          ret = irq_activate(desc);          if (ret)              goto out_unlock;            desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \                    IRQS_ONESHOT | IRQS_WAITING);          irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);          #是不是percpu中断          if (new->flags & IRQF_PERCPU) {              irqd_set(&desc->irq_data, IRQD_PER_CPU);              irq_settings_set_per_cpu(desc);          }            if (new->flags & IRQF_ONESHOT)              desc->istate |= IRQS_ONESHOT;            /* Exclude IRQ from balancing if requested */          #不用设置irq balance          if (new->flags & IRQF_NOBALANCING) {              irq_settings_set_no_balancing(desc);              irqd_set(&desc->irq_data, IRQD_NO_BALANCING);          }          #开始中断          if (irq_settings_can_autoenable(desc)) {              irq_startup(desc, IRQ_RESEND, IRQ_START_COND);          } else {              /*               * Shared interrupts do not go well with disabling               * auto enable. The sharing interrupt might request               * it while it's still disabled and then wait for               * interrupts forever.               */              WARN_ON_ONCE(new->flags & IRQF_SHARED);              /* Undo nested disables: */              desc->depth = 1;          }        } else if (new->flags & IRQF_TRIGGER_MASK) {          unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;          unsigned int omsk = irqd_get_trigger_type(&desc->irq_data);            if (nmsk != omsk)              /* hope the handler works with current  trigger mode */              pr_warn("irq %d uses trigger mode %u; requested %u\n",                  irq, omsk, nmsk);      }        *old_ptr = new;      #设置power相关      irq_pm_install_action(desc, new);        /* Reset broken irq detection when installing new handler */      desc->irq_count = 0;      desc->irqs_unhandled = 0;        /*       * Check whether we disabled the irq via the spurious handler       * before. Reenable it and give it another chance.       */      if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {          desc->istate &= ~IRQS_SPURIOUS_DISABLED;          __enable_irq(desc);      }        raw_spin_unlock_irqrestore(&desc->lock, flags);      chip_bus_sync_unlock(desc);      mutex_unlock(&desc->request_mutex);        irq_setup_timings(desc, new);        /*       * Strictly no need to wake it up, but hung_task complains       * when no hard interrupt wakes the thread up.       */      # 如果有中断线程的话，则wakeup线程      if (new->thread)          wake_up_process(new->thread);      if (new->secondary)          wake_up_process(new->secondary->thread);      #注册irq在proc中的接口      register_irq_proc(irq, desc);      new->dir = NULL;      register_handler_proc(irq, new);      return 0;    mismatch:      if (!(new->flags & IRQF_PROBE_SHARED)) {          pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",                 irq, new->flags, new->name, old->flags, old->name);  #ifdef CONFIG_DEBUG_SHIRQ          dump_stack();  #endif      }      ret = -EBUSY;  #一下都是异常case  out_unlock:      raw_spin_unlock_irqrestore(&desc->lock, flags);        if (!desc->action)          irq_release_resources(desc);  out_bus_unlock:      chip_bus_sync_unlock(desc);      mutex_unlock(&desc->request_mutex);    out_thread:      if (new->thread) {          struct task_struct *t = new->thread;            new->thread = NULL;          kthread_stop(t);          put_task_struct(t);      }      if (new->secondary && new->secondary->thread) {          struct task_struct *t = new->secondary->thread;            new->secondary->thread = NULL;          kthread_stop(t);          put_task_struct(t);      }  out_mput:      module_put(desc->owner);      return ret;  }

 

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/tiantao2012/article/details/78957472

int setup_irq(unsigned int irq, struct irqaction *act)用于设置irq对应的irqaction.

其使用的例程如下：
struct irq_domain * __init __init_i8259_irqs(struct device_node *node)
{
    struct irq_domain *domain;

    insert_resource(&ioport_resource, &pic1_io_resource);
    insert_resource(&ioport_resource, &pic2_io_resource);

    init_8259A(0);

    domain = irq_domain_add_legacy(node, 16, I8259A_IRQ_BASE, 0,
                       &i8259A_ops, NULL);
    if (!domain)
        panic("Failed to add i8259 IRQ domain");

    setup_irq(I8259A_IRQ_BASE + PIC_CASCADE_IR, &irq2);
    return domain;
}
其源码分析如下：

int setup_irq(unsigned int irq, struct irqaction *act)
{
    int retval;
    struct irq_desc *desc = irq_to_desc(irq);
    #中断描述为null，或者设置了_IRQ_PER_CPU_DEVID 标志的话，则直接退出
    if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
        return -EINVAL;

    retval = irq_chip_pm_get(&desc->irq_data);
    if (retval < 0)
        return retval;
    #核心代码，设置irq对应的irqaction *act
    retval = __setup_irq(irq, desc, act);

    if (retval)
        irq_chip_pm_put(&desc->irq_data);

    return retval;
}
static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{
    struct irqaction *old, **old_ptr;
    unsigned long flags, thread_mask = 0;
    int ret, nested, shared = 0;
    #中断描述符为null，则退出
    if (!desc)
        return -EINVAL;
    #没有设置irq_data.chip，所以irq_data.chip 会等于no_irq_chip。这属于异常case ，退出.
    if (desc->irq_data.chip == &no_irq_chip)
        return -ENOSYS;
    #增加这个模块的引用计数
    if (!try_module_get(desc->owner))
        return -ENODEV;
    #更新struct irqaction *new 中的irq number
    new->irq = irq;

    /*
     * If the trigger type is not specified by the caller,
     * then use the default for this interrupt.
     */
     #没有设置中断触发类型的话，则用默认值.
    if (!(new->flags & IRQF_TRIGGER_MASK))
        new->flags |= irqd_get_trigger_type(&desc->irq_data);

    /*
     * Check whether the interrupt nests into another interrupt
     * thread.
     */
    #检查这里是否是中断嵌套，正常情况下irq_chip 基本都不支持中断嵌套
    nested = irq_settings_is_nested_thread(desc);
    if (nested) {
        if (!new->thread_fn) {
            ret = -EINVAL;
            goto out_mput;
        }
        /*
         * Replace the primary handler which was provided from
         * the driver for non nested interrupt handling by the
         * dummy function which warns when called.
         */
        new->handler = irq_nested_primary_handler;
    } else {
    #这里检查是否为这个中断设置一个thread，也就是说是否支持中断线程化
        if (irq_settings_can_thread(desc)) {
            ret = irq_setup_forced_threading(new);
            if (ret)
                goto out_mput;
        }
    }

    /*
     * Create a handler thread when a thread function is supplied
     * and the interrupt does not nest into another interrupt
     * thread.
     */
    #在没有支持中断嵌套且用户用设置中断线程的情况下,这里会创建一个中断线程
    if (new->thread_fn && !nested) {
        ret = setup_irq_thread(new, irq, false);
        if (ret)
            goto out_mput;
        #中断线程化时是否支持第二个线程。如果支持的话，再创建一个中断线程.
        if (new->secondary) {
            ret = setup_irq_thread(new->secondary, irq, true);
            if (ret)
                goto out_thread;
        }
    }

    /*
     * Drivers are often written to work w/o knowledge about the
     * underlying irq chip implementation, so a request for a
     * threaded irq without a primary hard irq context handler
     * requires the ONESHOT flag to be set. Some irq chips like
     * MSI based interrupts are per se one shot safe. Check the
     * chip flags, so we can avoid the unmask dance at the end of
     * the threaded handler for those.
     */
    #有设置oneshot 标志的话，则清掉这个标志.
    if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)
        new->flags &= ~IRQF_ONESHOT;

    /*
     * Protects against a concurrent __free_irq() call which might wait
     * for synchronize_irq() to complete without holding the optional
     * chip bus lock and desc->lock.
     */
    mutex_lock(&desc->request_mutex);

    /*
     * Acquire bus lock as the irq_request_resources() callback below
     * might rely on the serialization or the magic power management
     * functions which are abusing the irq_bus_lock() callback,
     */
    chip_bus_lock(desc);

    /* First installed action requests resources. */
    #中断描述符的action为null的话，则通过irq_request_resources 来申请中断资源.
    if (!desc->action) {
        ret = irq_request_resources(desc);
        if (ret) {
            pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
                   new->name, irq, desc->irq_data.chip->name);
            goto out_bus_unlock;
        }
    }

    /*
     * The following block of code has to be executed atomically
     * protected against a concurrent interrupt and any of the other
     * management calls which are not serialized via
     * desc->request_mutex or the optional bus lock.
     */
    raw_spin_lock_irqsave(&desc->lock, flags);
    old_ptr = &desc->action;
    old = *old_ptr;
    #如果这个中断号对应的中断描述符中的action 不为null，说明这个中断号之前可能已经申请过中断了
    #这里同样可以得出结论，同一个中断好，可以重复申请中断，但是可能会继承前一次的中断触发类型.
    if (old) {
        /*
         * Can't share interrupts unless both agree to and are
         * the same type (level, edge, polarity). So both flag
         * fields must have IRQF_SHARED set and the bits which
         * set the trigger type must match. Also all must
         * agree on ONESHOT.
         */
        unsigned int oldtype;

        /*
         * If nobody did set the configuration before, inherit
         * the one provided by the requester.
         */
        if (irqd_trigger_type_was_set(&desc->irq_data)) {
            oldtype = irqd_get_trigger_type(&desc->irq_data);
        } else {
            oldtype = new->flags & IRQF_TRIGGER_MASK;
            irqd_set_trigger_type(&desc->irq_data, oldtype);
        }

        if (!((old->flags & new->flags) & IRQF_SHARED) ||
            (oldtype != (new->flags & IRQF_TRIGGER_MASK)) ||
            ((old->flags ^ new->flags) & IRQF_ONESHOT))
            goto mismatch;

        /* All handlers must agree on per-cpuness */
        if ((old->flags & IRQF_PERCPU) !=
            (new->flags & IRQF_PERCPU))
            goto mismatch;

        /* add new interrupt at end of irq queue */
        do {
            /*
             * Or all existing action->thread_mask bits,
             * so we can find the next zero bit for this
             * new action.
             */
            thread_mask |= old->thread_mask;
            old_ptr = &old->next;
            old = *old_ptr;
        } while (old);
        shared = 1;
    }

    /*
     * Setup the thread mask for this irqaction for ONESHOT. For
     * !ONESHOT irqs the thread mask is 0 so we can avoid a
     * conditional in irq_wake_thread().
     */
    if (new->flags & IRQF_ONESHOT) {
        /*
         * Unlikely to have 32 resp 64 irqs sharing one line,
         * but who knows.
         */
        if (thread_mask == ~0UL) {
            ret = -EBUSY;
            goto out_unlock;
        }
        /*
         * The thread_mask for the action is or'ed to
         * desc->thread_active to indicate that the
         * IRQF_ONESHOT thread handler has been woken, but not
         * yet finished. The bit is cleared when a thread
         * completes. When all threads of a shared interrupt
         * line have completed desc->threads_active becomes
         * zero and the interrupt line is unmasked. See
         * handle.c:irq_wake_thread() for further information.
         *
         * If no thread is woken by primary (hard irq context)
         * interrupt handlers, then desc->threads_active is
         * also checked for zero to unmask the irq line in the
         * affected hard irq flow handlers
         * (handle_[fasteoi|level]_irq).
         *
         * The new action gets the first zero bit of
         * thread_mask assigned. See the loop above which or's
         * all existing action->thread_mask bits.
         */
        new->thread_mask = 1UL << ffz(thread_mask);

    } else if (new->handler == irq_default_primary_handler &&
           !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {
        /*
         * The interrupt was requested with handler = NULL, so
         * we use the default primary handler for it. But it
         * does not have the oneshot flag set. In combination
         * with level interrupts this is deadly, because the
         * default primary handler just wakes the thread, then
         * the irq lines is reenabled, but the device still
         * has the level irq asserted. Rinse and repeat....
         *
         * While this works for edge type interrupts, we play
         * it safe and reject unconditionally because we can't
         * say for sure which type this interrupt really
         * has. The type flags are unreliable as the
         * underlying chip implementation can override them.
         */
        pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
               irq);
        ret = -EINVAL;
        goto out_unlock;
    }
    #非共享中断
    if (!shared) {
        #初始化一个等待队列，这个等待队列包含在中断描述符中
        init_waitqueue_head(&desc->wait_for_threads);

        /* Setup the type (level, edge polarity) if configured: */
        if (new->flags & IRQF_TRIGGER_MASK) {
            ret = __irq_set_trigger(desc,
                        new->flags & IRQF_TRIGGER_MASK);

            if (ret)
                goto out_unlock;
        }

        /*
         * Activate the interrupt. That activation must happen
         * independently of IRQ_NOAUTOEN. request_irq() can fail
         * and the callers are supposed to handle
         * that. enable_irq() of an interrupt requested with
         * IRQ_NOAUTOEN is not supposed to fail. The activation
         * keeps it in shutdown mode, it merily associates
         * resources if necessary and if that's not possible it
         * fails. Interrupts which are in managed shutdown mode
         * will simply ignore that activation request.
         */
         #激活这个中断
        ret = irq_activate(desc);
        if (ret)
            goto out_unlock;

        desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
                  IRQS_ONESHOT | IRQS_WAITING);
        irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
        #是不是percpu中断
        if (new->flags & IRQF_PERCPU) {
            irqd_set(&desc->irq_data, IRQD_PER_CPU);
            irq_settings_set_per_cpu(desc);
        }

        if (new->flags & IRQF_ONESHOT)
            desc->istate |= IRQS_ONESHOT;

        /* Exclude IRQ from balancing if requested */
        #不用设置irq balance
        if (new->flags & IRQF_NOBALANCING) {
            irq_settings_set_no_balancing(desc);
            irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
        }
        #开始中断
        if (irq_settings_can_autoenable(desc)) {
            irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
        } else {
            /*
             * Shared interrupts do not go well with disabling
             * auto enable. The sharing interrupt might request
             * it while it's still disabled and then wait for
             * interrupts forever.
             */
            WARN_ON_ONCE(new->flags & IRQF_SHARED);
            /* Undo nested disables: */
            desc->depth = 1;
        }

    } else if (new->flags & IRQF_TRIGGER_MASK) {
        unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
        unsigned int omsk = irqd_get_trigger_type(&desc->irq_data);

        if (nmsk != omsk)
            /* hope the handler works with current  trigger mode */
            pr_warn("irq %d uses trigger mode %u; requested %u\n",
                irq, omsk, nmsk);
    }

    *old_ptr = new;
    #设置power相关
    irq_pm_install_action(desc, new);

    /* Reset broken irq detection when installing new handler */
    desc->irq_count = 0;
    desc->irqs_unhandled = 0;

    /*
     * Check whether we disabled the irq via the spurious handler
     * before. Reenable it and give it another chance.
     */
    if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
        desc->istate &= ~IRQS_SPURIOUS_DISABLED;
        __enable_irq(desc);
    }

    raw_spin_unlock_irqrestore(&desc->lock, flags);
    chip_bus_sync_unlock(desc);
    mutex_unlock(&desc->request_mutex);

    irq_setup_timings(desc, new);

    /*
     * Strictly no need to wake it up, but hung_task complains
     * when no hard interrupt wakes the thread up.
     */
    # 如果有中断线程的话，则wakeup线程
    if (new->thread)
        wake_up_process(new->thread);
    if (new->secondary)
        wake_up_process(new->secondary->thread);
    #注册irq在proc中的接口
    register_irq_proc(irq, desc);
    new->dir = NULL;
    register_handler_proc(irq, new);
    return 0;

mismatch:
    if (!(new->flags & IRQF_PROBE_SHARED)) {
        pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",
               irq, new->flags, new->name, old->flags, old->name);
#ifdef CONFIG_DEBUG_SHIRQ
        dump_stack();
#endif
    }
    ret = -EBUSY;
#一下都是异常case
out_unlock:
    raw_spin_unlock_irqrestore(&desc->lock, flags);

    if (!desc->action)
        irq_release_resources(desc);
out_bus_unlock:
    chip_bus_sync_unlock(desc);
    mutex_unlock(&desc->request_mutex);

out_thread:
    if (new->thread) {
        struct task_struct *t = new->thread;

        new->thread = NULL;
        kthread_stop(t);
        put_task_struct(t);
    }
    if (new->secondary && new->secondary->thread) {
        struct task_struct *t = new->secondary->thread;

        new->secondary->thread = NULL;
        kthread_stop(t);
        put_task_struct(t);
    }
out_mput:
    module_put(desc->owner);
    return ret;
}