Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Luca Falavigna | 47f176f | 2005-06-28 20:44:42 -0700 | [diff] [blame] | 12 | #include <linux/delay.h> |
Arjan van de Ven | 22a9d64 | 2009-01-07 08:45:46 -0800 | [diff] [blame] | 13 | #include <linux/async.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
Ingo Molnar | 7a55713 | 2006-06-29 02:24:54 -0700 | [diff] [blame] | 15 | #include "internals.h" |
| 16 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | /* |
| 18 | * Autodetection depends on the fact that any interrupt that |
| 19 | * comes in on to an unassigned handler will get stuck with |
| 20 | * "IRQ_WAITING" cleared and the interrupt disabled. |
| 21 | */ |
Ingo Molnar | 74ffd55 | 2006-06-29 02:24:37 -0700 | [diff] [blame] | 22 | static DEFINE_MUTEX(probing_active); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | { |
Ingo Molnar | 34ffdb7 | 2006-06-29 02:24:40 -0700 | [diff] [blame] | 33 | struct irq_desc *desc; |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 34 | unsigned long mask = 0; |
| 35 | unsigned int status; |
| 36 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
Arjan van de Ven | 22a9d64 | 2009-01-07 08:45:46 -0800 | [diff] [blame] | 38 | /* |
| 39 | * quiesce the kernel, or at least the asynchronous portion |
| 40 | */ |
| 41 | async_synchronize_full(); |
Ingo Molnar | 74ffd55 | 2006-06-29 02:24:37 -0700 | [diff] [blame] | 42 | mutex_lock(&probing_active); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | /* |
| 44 | * something may have generated an irq long ago and we want to |
| 45 | * flush such a longstanding irq before considering it as spurious. |
| 46 | */ |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 47 | for_each_irq_desc_reverse(i, desc) { |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 48 | raw_spin_lock_irq(&desc->lock); |
Thomas Gleixner | 6a6de9e | 2006-06-29 02:24:51 -0700 | [diff] [blame] | 49 | if (!desc->action && !(desc->status & IRQ_NOPROBE)) { |
| 50 | /* |
Ingo Molnar | 7a55713 | 2006-06-29 02:24:54 -0700 | [diff] [blame] | 51 | * An old-style architecture might still have |
| 52 | * the handle_bad_irq handler there: |
| 53 | */ |
| 54 | compat_irq_chip_set_default_handler(desc); |
| 55 | |
| 56 | /* |
Thomas Gleixner | 6a6de9e | 2006-06-29 02:24:51 -0700 | [diff] [blame] | 57 | * Some chips need to know about probing in |
| 58 | * progress: |
| 59 | */ |
Thomas Gleixner | b2ba2c3 | 2010-09-27 12:45:47 +0000 | [diff] [blame] | 60 | if (desc->irq_data.chip->irq_set_type) |
| 61 | desc->irq_data.chip->irq_set_type(&desc->irq_data, |
| 62 | IRQ_TYPE_PROBE); |
Thomas Gleixner | 37e12df | 2010-09-27 12:45:38 +0000 | [diff] [blame] | 63 | desc->irq_data.chip->irq_startup(&desc->irq_data); |
Thomas Gleixner | 6a6de9e | 2006-06-29 02:24:51 -0700 | [diff] [blame] | 64 | } |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 65 | raw_spin_unlock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | /* Wait for longstanding interrupts to trigger. */ |
Luca Falavigna | 47f176f | 2005-06-28 20:44:42 -0700 | [diff] [blame] | 69 | msleep(20); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | |
| 71 | /* |
| 72 | * enable any unassigned irqs |
| 73 | * (we must startup again here because if a longstanding irq |
| 74 | * happened in the previous stage, it may have masked itself) |
| 75 | */ |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 76 | for_each_irq_desc_reverse(i, desc) { |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 77 | raw_spin_lock_irq(&desc->lock); |
Thomas Gleixner | 3418d72 | 2006-06-29 02:24:49 -0700 | [diff] [blame] | 78 | if (!desc->action && !(desc->status & IRQ_NOPROBE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | desc->status |= IRQ_AUTODETECT | IRQ_WAITING; |
Thomas Gleixner | 37e12df | 2010-09-27 12:45:38 +0000 | [diff] [blame] | 80 | if (desc->irq_data.chip->irq_startup(&desc->irq_data)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | desc->status |= IRQ_PENDING; |
| 82 | } |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 83 | raw_spin_unlock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | /* |
| 87 | * Wait for spurious interrupts to trigger |
| 88 | */ |
Luca Falavigna | 47f176f | 2005-06-28 20:44:42 -0700 | [diff] [blame] | 89 | msleep(100); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | |
| 91 | /* |
| 92 | * Now filter out any obviously spurious interrupts |
| 93 | */ |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 94 | for_each_irq_desc(i, desc) { |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 95 | raw_spin_lock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | status = desc->status; |
| 97 | |
| 98 | if (status & IRQ_AUTODETECT) { |
| 99 | /* It triggered already - consider it spurious. */ |
| 100 | if (!(status & IRQ_WAITING)) { |
| 101 | desc->status = status & ~IRQ_AUTODETECT; |
Thomas Gleixner | bc310dda | 2010-09-27 12:45:02 +0000 | [diff] [blame] | 102 | desc->irq_data.chip->irq_shutdown(&desc->irq_data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | } else |
| 104 | if (i < 32) |
Ingo Molnar | 06fcb0c | 2006-06-29 02:24:40 -0700 | [diff] [blame] | 105 | mask |= 1 << i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | } |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 107 | raw_spin_unlock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | } |
| 109 | |
Ingo Molnar | 06fcb0c | 2006-06-29 02:24:40 -0700 | [diff] [blame] | 110 | return mask; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | EXPORT_SYMBOL(probe_irq_on); |
| 113 | |
| 114 | /** |
| 115 | * probe_irq_mask - scan a bitmap of interrupt lines |
| 116 | * @val: mask of interrupts to consider |
| 117 | * |
| 118 | * Scan the interrupt lines and return a bitmap of active |
| 119 | * autodetect interrupts. The interrupt probe logic state |
| 120 | * is then returned to its previous value. |
| 121 | * |
| 122 | * Note: we need to scan all the irq's even though we will |
| 123 | * only return autodetect irq numbers - just so that we reset |
| 124 | * them all to a known state. |
| 125 | */ |
| 126 | unsigned int probe_irq_mask(unsigned long val) |
| 127 | { |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 128 | unsigned int status, mask = 0; |
| 129 | struct irq_desc *desc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | int i; |
| 131 | |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 132 | for_each_irq_desc(i, desc) { |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 133 | raw_spin_lock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | status = desc->status; |
| 135 | |
| 136 | if (status & IRQ_AUTODETECT) { |
| 137 | if (i < 16 && !(status & IRQ_WAITING)) |
| 138 | mask |= 1 << i; |
| 139 | |
| 140 | desc->status = status & ~IRQ_AUTODETECT; |
Thomas Gleixner | bc310dda | 2010-09-27 12:45:02 +0000 | [diff] [blame] | 141 | desc->irq_data.chip->irq_shutdown(&desc->irq_data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | } |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 143 | raw_spin_unlock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | } |
Ingo Molnar | 74ffd55 | 2006-06-29 02:24:37 -0700 | [diff] [blame] | 145 | mutex_unlock(&probing_active); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | |
| 147 | return mask & val; |
| 148 | } |
| 149 | EXPORT_SYMBOL(probe_irq_mask); |
| 150 | |
| 151 | /** |
| 152 | * probe_irq_off - end an interrupt autodetect |
| 153 | * @val: mask of potential interrupts (unused) |
| 154 | * |
| 155 | * Scans the unused interrupt lines and returns the line which |
| 156 | * appears to have triggered the interrupt. If no interrupt was |
| 157 | * found then zero is returned. If more than one interrupt is |
| 158 | * found then minus the first candidate is returned to indicate |
| 159 | * their is doubt. |
| 160 | * |
| 161 | * The interrupt probe logic state is returned to its previous |
| 162 | * value. |
| 163 | * |
| 164 | * BUGS: When used in a module (which arguably shouldn't happen) |
| 165 | * nothing prevents two IRQ probe callers from overlapping. The |
| 166 | * results of this are non-optimal. |
| 167 | */ |
| 168 | int probe_irq_off(unsigned long val) |
| 169 | { |
Thomas Gleixner | 63d659d | 2008-10-16 15:33:18 +0200 | [diff] [blame] | 170 | int i, irq_found = 0, nr_of_irqs = 0; |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 171 | struct irq_desc *desc; |
| 172 | unsigned int status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
Thomas Gleixner | 10e5808 | 2008-10-16 14:19:04 +0200 | [diff] [blame] | 174 | for_each_irq_desc(i, desc) { |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 175 | raw_spin_lock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | status = desc->status; |
| 177 | |
| 178 | if (status & IRQ_AUTODETECT) { |
| 179 | if (!(status & IRQ_WAITING)) { |
Thomas Gleixner | 63d659d | 2008-10-16 15:33:18 +0200 | [diff] [blame] | 180 | if (!nr_of_irqs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | irq_found = i; |
Thomas Gleixner | 63d659d | 2008-10-16 15:33:18 +0200 | [diff] [blame] | 182 | nr_of_irqs++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | } |
| 184 | desc->status = status & ~IRQ_AUTODETECT; |
Thomas Gleixner | bc310dda | 2010-09-27 12:45:02 +0000 | [diff] [blame] | 185 | desc->irq_data.chip->irq_shutdown(&desc->irq_data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | } |
Thomas Gleixner | 239007b | 2009-11-17 16:46:45 +0100 | [diff] [blame] | 187 | raw_spin_unlock_irq(&desc->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | } |
Ingo Molnar | 74ffd55 | 2006-06-29 02:24:37 -0700 | [diff] [blame] | 189 | mutex_unlock(&probing_active); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
Thomas Gleixner | 63d659d | 2008-10-16 15:33:18 +0200 | [diff] [blame] | 191 | if (nr_of_irqs > 1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | irq_found = -irq_found; |
Ingo Molnar | 74ffd55 | 2006-06-29 02:24:37 -0700 | [diff] [blame] | 193 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | return irq_found; |
| 195 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | EXPORT_SYMBOL(probe_irq_off); |
| 197 | |