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