disable_irq() might be lazy in Linux kernel

在 Linux kernel 中，如果要 diable 某個 irq，會使用disable_irq(irq) 這個 API ，而這個 API 有一個有趣的實作：它有可能不會"真的"馬上在硬體上關閉該 irq ，而是到了下一次真的有該 irq 觸發時，才在 flow handler 中進行 disable。相關代碼如下：

 void irq_disable(struct irq_desc *desc)
 {
         irq_state_set_disabled(desc); /* set SW status as disabled */
         if (desc->irq_data.chip->irq_disable) {
                 desc->irq_data.chip->irq_disable(&desc->irq_data); /* if registered irq_disable() callback, use it */
                 irq_state_set_masked(desc);
         } else if (irq_settings_disable_unlazy(desc)) {
                 mask_irq(desc); /* if not disable lazy, mask it */
         }
 }

 void handle_fasteoi_irq(struct irq_desc *desc)
 {
         struct irq_chip *chip = desc->irq_data.chip;
 
         raw_spin_lock(&desc->lock);
 
         if (!irq_may_run(desc))
                 goto out;
 
         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 
         /*
          * If its disabled or no action available
          * then mask it and get out of here:
          */
         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
                 desc->istate |= IRQS_PENDING;
                 mask_irq(desc);
                 goto out;
         }
 
         kstat_incr_irqs_this_cpu(desc);
         if (desc->istate & IRQS_ONESHOT)
                 mask_irq(desc);
 
         preflow_handler(desc);
         handle_irq_event(desc);
 
         cond_unmask_eoi_irq(desc, chip);
 
         raw_spin_unlock(&desc->lock);
         return;
 out:
         if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
                 chip->irq_eoi(&desc->irq_data);
         raw_spin_unlock(&desc->lock);
 }
 EXPORT_SYMBOL_GPL(handle_fasteoi_irq);

一般情況下不會有問題，因為 ISR 被沒有被喚起，但是對於 suspend/resume flow就會有了影響。在 suspend flow，kernel 除了已經設定為 wakeup source 的 irq 外，都會透過 disable_irq() 將所有 irq 關閉：

  static bool suspend_device_irq(struct irq_desc *desc)
  {
          if (!desc->action || irq_desc_is_chained(desc) ||
              desc->no_suspend_depth)
                  return false;
  
          if (irqd_is_wakeup_set(&desc->irq_data)) {
                  irqd_set(&desc->irq_data, IRQD_WAKEUP_ARMED);
                  /*
                   * We return true here to force the caller to issue
                   * synchronize_irq(). We need to make sure that the
                   * IRQD_WAKEUP_ARMED is visible before we return from
                   * suspend_device_irqs().
                   */
                  return true;
          }
  
          desc->istate |= IRQS_SUSPENDED;
          __disable_irq(desc);
  
          /*
           * Hardware which has no wakeup source configuration facility
           * requires that the non wakeup interrupts are masked at the
           * chip level. The chip implementation indicates that with
           * IRQCHIP_MASK_ON_SUSPEND.
           */
          if (irq_desc_get_chip(desc)->flags & IRQCHIP_MASK_ON_SUSPEND)
                  mask_irq(desc);
          return true;
 }

然而此時該 irq 沒有並真的 disabled，進而造成系統不斷被喚醒。解決方法倒也不難，就是在 intc driver 補 disable_irq() callback，或者per irq設定UNLAZY即可。這個設計應該是為了節省write intc register的時間，因為通常register access會比memory access多上一個數量級，所以只在真的還有下一次irq發生時再進行 disable 即可。不過我是很好奇到底可以省多少啊... @@