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