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