1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar 4 * 5 * This file contains the interrupt probing code and driver APIs. 6 */ 7 8 #include <linux/irq.h> 9 #include <linux/module.h> 10 #include <linux/interrupt.h> 11 #include <linux/delay.h> 12 #include <linux/async.h> 13 14 #include "internals.h" 15 16 /* 17 * Autodetection depends on the fact that any interrupt that 18 * comes in on to an unassigned handler will get stuck with 19 * "IRQS_WAITING" cleared and the interrupt disabled. 20 */ 21 static DEFINE_MUTEX(probing_active); 22 23 /** 24 * probe_irq_on - begin an interrupt autodetect 25 * 26 * Commence probing for an interrupt. The interrupts are scanned 27 * and a mask of potential interrupt lines is returned. 28 * 29 */ 30 unsigned long probe_irq_on(void) 31 { 32 struct irq_desc *desc; 33 unsigned long mask = 0; 34 int i; 35 36 /* 37 * quiesce the kernel, or at least the asynchronous portion 38 */ 39 async_synchronize_full(); 40 mutex_lock(&probing_active); 41 /* 42 * something may have generated an irq long ago and we want to 43 * flush such a longstanding irq before considering it as spurious. 44 */ 45 for_each_irq_desc_reverse(i, desc) { 46 raw_spin_lock_irq(&desc->lock); 47 if (!desc->action && irq_settings_can_probe(desc)) { 48 /* 49 * Some chips need to know about probing in 50 * progress: 51 */ 52 if (desc->irq_data.chip->irq_set_type) 53 desc->irq_data.chip->irq_set_type(&desc->irq_data, 54 IRQ_TYPE_PROBE); 55 irq_activate_and_startup(desc, IRQ_NORESEND); 56 } 57 raw_spin_unlock_irq(&desc->lock); 58 } 59 60 /* Wait for longstanding interrupts to trigger. */ 61 msleep(20); 62 63 /* 64 * enable any unassigned irqs 65 * (we must startup again here because if a longstanding irq 66 * happened in the previous stage, it may have masked itself) 67 */ 68 for_each_irq_desc_reverse(i, desc) { 69 raw_spin_lock_irq(&desc->lock); 70 if (!desc->action && irq_settings_can_probe(desc)) { 71 desc->istate |= IRQS_AUTODETECT | IRQS_WAITING; 72 if (irq_activate_and_startup(desc, IRQ_NORESEND)) 73 desc->istate |= IRQS_PENDING; 74 } 75 raw_spin_unlock_irq(&desc->lock); 76 } 77 78 /* 79 * Wait for spurious interrupts to trigger 80 */ 81 msleep(100); 82 83 /* 84 * Now filter out any obviously spurious interrupts 85 */ 86 for_each_irq_desc(i, desc) { 87 raw_spin_lock_irq(&desc->lock); 88 89 if (desc->istate & IRQS_AUTODETECT) { 90 /* It triggered already - consider it spurious. */ 91 if (!(desc->istate & IRQS_WAITING)) { 92 desc->istate &= ~IRQS_AUTODETECT; 93 irq_shutdown_and_deactivate(desc); 94 } else 95 if (i < 32) 96 mask |= 1 << i; 97 } 98 raw_spin_unlock_irq(&desc->lock); 99 } 100 101 return mask; 102 } 103 EXPORT_SYMBOL(probe_irq_on); 104 105 /** 106 * probe_irq_mask - scan a bitmap of interrupt lines 107 * @val: mask of interrupts to consider 108 * 109 * Scan the interrupt lines and return a bitmap of active 110 * autodetect interrupts. The interrupt probe logic state 111 * is then returned to its previous value. 112 * 113 * Note: we need to scan all the irq's even though we will 114 * only return autodetect irq numbers - just so that we reset 115 * them all to a known state. 116 */ 117 unsigned int probe_irq_mask(unsigned long val) 118 { 119 unsigned int mask = 0; 120 struct irq_desc *desc; 121 int i; 122 123 for_each_irq_desc(i, desc) { 124 raw_spin_lock_irq(&desc->lock); 125 if (desc->istate & IRQS_AUTODETECT) { 126 if (i < 16 && !(desc->istate & IRQS_WAITING)) 127 mask |= 1 << i; 128 129 desc->istate &= ~IRQS_AUTODETECT; 130 irq_shutdown_and_deactivate(desc); 131 } 132 raw_spin_unlock_irq(&desc->lock); 133 } 134 mutex_unlock(&probing_active); 135 136 return mask & val; 137 } 138 EXPORT_SYMBOL(probe_irq_mask); 139 140 /** 141 * probe_irq_off - end an interrupt autodetect 142 * @val: mask of potential interrupts (unused) 143 * 144 * Scans the unused interrupt lines and returns the line which 145 * appears to have triggered the interrupt. If no interrupt was 146 * found then zero is returned. If more than one interrupt is 147 * found then minus the first candidate is returned to indicate 148 * their is doubt. 149 * 150 * The interrupt probe logic state is returned to its previous 151 * value. 152 * 153 * BUGS: When used in a module (which arguably shouldn't happen) 154 * nothing prevents two IRQ probe callers from overlapping. The 155 * results of this are non-optimal. 156 */ 157 int probe_irq_off(unsigned long val) 158 { 159 int i, irq_found = 0, nr_of_irqs = 0; 160 struct irq_desc *desc; 161 162 for_each_irq_desc(i, desc) { 163 raw_spin_lock_irq(&desc->lock); 164 165 if (desc->istate & IRQS_AUTODETECT) { 166 if (!(desc->istate & IRQS_WAITING)) { 167 if (!nr_of_irqs) 168 irq_found = i; 169 nr_of_irqs++; 170 } 171 desc->istate &= ~IRQS_AUTODETECT; 172 irq_shutdown_and_deactivate(desc); 173 } 174 raw_spin_unlock_irq(&desc->lock); 175 } 176 mutex_unlock(&probing_active); 177 178 if (nr_of_irqs > 1) 179 irq_found = -irq_found; 180 181 return irq_found; 182 } 183 EXPORT_SYMBOL(probe_irq_off); 184 185