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 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 * "IRQ_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 unsigned int status; 35 int i; 36 37 mutex_lock(&probing_active); 38 /* 39 * something may have generated an irq long ago and we want to 40 * flush such a longstanding irq before considering it as spurious. 41 */ 42 for_each_irq_desc_reverse(i, desc) { 43 spin_lock_irq(&desc->lock); 44 if (!desc->action && !(desc->status & IRQ_NOPROBE)) { 45 /* 46 * An old-style architecture might still have 47 * the handle_bad_irq handler there: 48 */ 49 compat_irq_chip_set_default_handler(desc); 50 51 /* 52 * Some chips need to know about probing in 53 * progress: 54 */ 55 if (desc->chip->set_type) 56 desc->chip->set_type(i, IRQ_TYPE_PROBE); 57 desc->chip->startup(i); 58 } 59 spin_unlock_irq(&desc->lock); 60 } 61 62 /* Wait for longstanding interrupts to trigger. */ 63 msleep(20); 64 65 /* 66 * enable any unassigned irqs 67 * (we must startup again here because if a longstanding irq 68 * happened in the previous stage, it may have masked itself) 69 */ 70 for_each_irq_desc_reverse(i, desc) { 71 spin_lock_irq(&desc->lock); 72 if (!desc->action && !(desc->status & IRQ_NOPROBE)) { 73 desc->status |= IRQ_AUTODETECT | IRQ_WAITING; 74 if (desc->chip->startup(i)) 75 desc->status |= IRQ_PENDING; 76 } 77 spin_unlock_irq(&desc->lock); 78 } 79 80 /* 81 * Wait for spurious interrupts to trigger 82 */ 83 msleep(100); 84 85 /* 86 * Now filter out any obviously spurious interrupts 87 */ 88 for_each_irq_desc(i, desc) { 89 spin_lock_irq(&desc->lock); 90 status = desc->status; 91 92 if (status & IRQ_AUTODETECT) { 93 /* It triggered already - consider it spurious. */ 94 if (!(status & IRQ_WAITING)) { 95 desc->status = status & ~IRQ_AUTODETECT; 96 desc->chip->shutdown(i); 97 } else 98 if (i < 32) 99 mask |= 1 << i; 100 } 101 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 status, mask = 0; 123 struct irq_desc *desc; 124 int i; 125 126 for_each_irq_desc(i, desc) { 127 spin_lock_irq(&desc->lock); 128 status = desc->status; 129 130 if (status & IRQ_AUTODETECT) { 131 if (i < 16 && !(status & IRQ_WAITING)) 132 mask |= 1 << i; 133 134 desc->status = status & ~IRQ_AUTODETECT; 135 desc->chip->shutdown(i); 136 } 137 spin_unlock_irq(&desc->lock); 138 } 139 mutex_unlock(&probing_active); 140 141 return mask & val; 142 } 143 EXPORT_SYMBOL(probe_irq_mask); 144 145 /** 146 * probe_irq_off - end an interrupt autodetect 147 * @val: mask of potential interrupts (unused) 148 * 149 * Scans the unused interrupt lines and returns the line which 150 * appears to have triggered the interrupt. If no interrupt was 151 * found then zero is returned. If more than one interrupt is 152 * found then minus the first candidate is returned to indicate 153 * their is doubt. 154 * 155 * The interrupt probe logic state is returned to its previous 156 * value. 157 * 158 * BUGS: When used in a module (which arguably shouldn't happen) 159 * nothing prevents two IRQ probe callers from overlapping. The 160 * results of this are non-optimal. 161 */ 162 int probe_irq_off(unsigned long val) 163 { 164 int i, irq_found = 0, nr_irqs = 0; 165 struct irq_desc *desc; 166 unsigned int status; 167 168 for_each_irq_desc(i, desc) { 169 spin_lock_irq(&desc->lock); 170 status = desc->status; 171 172 if (status & IRQ_AUTODETECT) { 173 if (!(status & IRQ_WAITING)) { 174 if (!nr_irqs) 175 irq_found = i; 176 nr_irqs++; 177 } 178 desc->status = status & ~IRQ_AUTODETECT; 179 desc->chip->shutdown(i); 180 } 181 spin_unlock_irq(&desc->lock); 182 } 183 mutex_unlock(&probing_active); 184 185 if (nr_irqs > 1) 186 irq_found = -irq_found; 187 188 return irq_found; 189 } 190 EXPORT_SYMBOL(probe_irq_off); 191 192