Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : 
       3             : #include <linux/irq.h>
       4             : #include <linux/interrupt.h>
       5             : 
       6             : #include "internals.h"
       7             : 
       8             : /**
       9             :  * irq_fixup_move_pending - Cleanup irq move pending from a dying CPU
      10             :  * @desc:               Interrupt descpriptor to clean up
      11             :  * @force_clear:        If set clear the move pending bit unconditionally.
      12             :  *                      If not set, clear it only when the dying CPU is the
      13             :  *                      last one in the pending mask.
      14             :  *
      15             :  * Returns true if the pending bit was set and the pending mask contains an
      16             :  * online CPU other than the dying CPU.
      17             :  */
      18           0 : bool irq_fixup_move_pending(struct irq_desc *desc, bool force_clear)
      19             : {
      20           0 :         struct irq_data *data = irq_desc_get_irq_data(desc);
      21             : 
      22           0 :         if (!irqd_is_setaffinity_pending(data))
      23             :                 return false;
      24             : 
      25             :         /*
      26             :          * The outgoing CPU might be the last online target in a pending
      27             :          * interrupt move. If that's the case clear the pending move bit.
      28             :          */
      29           0 :         if (cpumask_any_and(desc->pending_mask, cpu_online_mask) >= nr_cpu_ids) {
      30           0 :                 irqd_clr_move_pending(data);
      31           0 :                 return false;
      32             :         }
      33           0 :         if (force_clear)
      34           0 :                 irqd_clr_move_pending(data);
      35             :         return true;
      36             : }
      37             : 
      38           0 : void irq_move_masked_irq(struct irq_data *idata)
      39             : {
      40           0 :         struct irq_desc *desc = irq_data_to_desc(idata);
      41           0 :         struct irq_data *data = &desc->irq_data;
      42           0 :         struct irq_chip *chip = data->chip;
      43             : 
      44           0 :         if (likely(!irqd_is_setaffinity_pending(data)))
      45             :                 return;
      46             : 
      47           0 :         irqd_clr_move_pending(data);
      48             : 
      49             :         /*
      50             :          * Paranoia: cpu-local interrupts shouldn't be calling in here anyway.
      51             :          */
      52           0 :         if (irqd_is_per_cpu(data)) {
      53           0 :                 WARN_ON(1);
      54           0 :                 return;
      55             :         }
      56             : 
      57           0 :         if (unlikely(cpumask_empty(desc->pending_mask)))
      58             :                 return;
      59             : 
      60           0 :         if (!chip->irq_set_affinity)
      61             :                 return;
      62             : 
      63           0 :         assert_raw_spin_locked(&desc->lock);
      64             : 
      65             :         /*
      66             :          * If there was a valid mask to work with, please
      67             :          * do the disable, re-program, enable sequence.
      68             :          * This is *not* particularly important for level triggered
      69             :          * but in a edge trigger case, we might be setting rte
      70             :          * when an active trigger is coming in. This could
      71             :          * cause some ioapics to mal-function.
      72             :          * Being paranoid i guess!
      73             :          *
      74             :          * For correct operation this depends on the caller
      75             :          * masking the irqs.
      76             :          */
      77           0 :         if (cpumask_any_and(desc->pending_mask, cpu_online_mask) < nr_cpu_ids) {
      78           0 :                 int ret;
      79             : 
      80           0 :                 ret = irq_do_set_affinity(data, desc->pending_mask, false);
      81             :                 /*
      82             :                  * If the there is a cleanup pending in the underlying
      83             :                  * vector management, reschedule the move for the next
      84             :                  * interrupt. Leave desc->pending_mask intact.
      85             :                  */
      86           0 :                 if (ret == -EBUSY) {
      87           0 :                         irqd_set_move_pending(data);
      88           0 :                         return;
      89             :                 }
      90             :         }
      91           0 :         cpumask_clear(desc->pending_mask);
      92             : }
      93             : 
      94           0 : void __irq_move_irq(struct irq_data *idata)
      95             : {
      96           0 :         bool masked;
      97             : 
      98             :         /*
      99             :          * Get top level irq_data when CONFIG_IRQ_DOMAIN_HIERARCHY is enabled,
     100             :          * and it should be optimized away when CONFIG_IRQ_DOMAIN_HIERARCHY is
     101             :          * disabled. So we avoid an "#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY" here.
     102             :          */
     103           0 :         idata = irq_desc_get_irq_data(irq_data_to_desc(idata));
     104             : 
     105           0 :         if (unlikely(irqd_irq_disabled(idata)))
     106             :                 return;
     107             : 
     108             :         /*
     109             :          * Be careful vs. already masked interrupts. If this is a
     110             :          * threaded interrupt with ONESHOT set, we can end up with an
     111             :          * interrupt storm.
     112             :          */
     113           0 :         masked = irqd_irq_masked(idata);
     114           0 :         if (!masked)
     115           0 :                 idata->chip->irq_mask(idata);
     116           0 :         irq_move_masked_irq(idata);
     117           0 :         if (!masked)
     118           0 :                 idata->chip->irq_unmask(idata);
     119             : }