]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - kernel/irq/autoprobe.c
Merge branch 'irq-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / kernel / irq / autoprobe.c
CommitLineData
1da177e4
LT
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>
47f176fd 12#include <linux/delay.h>
22a9d645 13#include <linux/async.h>
1da177e4 14
7a55713a
IM
15#include "internals.h"
16
1da177e4
LT
17/*
18 * Autodetection depends on the fact that any interrupt that
19 * comes in on to an unassigned handler will get stuck with
163ef309 20 * "IRQS_WAITING" cleared and the interrupt disabled.
1da177e4 21 */
74ffd553 22static DEFINE_MUTEX(probing_active);
1da177e4
LT
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 */
31unsigned long probe_irq_on(void)
32{
34ffdb72 33 struct irq_desc *desc;
10e58084 34 unsigned long mask = 0;
10e58084 35 int i;
1da177e4 36
22a9d645
AV
37 /*
38 * quiesce the kernel, or at least the asynchronous portion
39 */
40 async_synchronize_full();
74ffd553 41 mutex_lock(&probing_active);
1da177e4
LT
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 */
10e58084 46 for_each_irq_desc_reverse(i, desc) {
239007b8 47 raw_spin_lock_irq(&desc->lock);
1ccb4e61 48 if (!desc->action && irq_settings_can_probe(desc)) {
6a6de9ef
TG
49 /*
50 * Some chips need to know about probing in
51 * progress:
52 */
b2ba2c30
TG
53 if (desc->irq_data.chip->irq_set_type)
54 desc->irq_data.chip->irq_set_type(&desc->irq_data,
55 IRQ_TYPE_PROBE);
b4bc724e 56 irq_startup(desc, false);
6a6de9ef 57 }
239007b8 58 raw_spin_unlock_irq(&desc->lock);
1da177e4
LT
59 }
60
61 /* Wait for longstanding interrupts to trigger. */
47f176fd 62 msleep(20);
1da177e4
LT
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 */
10e58084 69 for_each_irq_desc_reverse(i, desc) {
239007b8 70 raw_spin_lock_irq(&desc->lock);
1ccb4e61 71 if (!desc->action && irq_settings_can_probe(desc)) {
163ef309 72 desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
b4bc724e 73 if (irq_startup(desc, false))
2a0d6fb3 74 desc->istate |= IRQS_PENDING;
1da177e4 75 }
239007b8 76 raw_spin_unlock_irq(&desc->lock);
1da177e4
LT
77 }
78
79 /*
80 * Wait for spurious interrupts to trigger
81 */
47f176fd 82 msleep(100);
1da177e4
LT
83
84 /*
85 * Now filter out any obviously spurious interrupts
86 */
10e58084 87 for_each_irq_desc(i, desc) {
239007b8 88 raw_spin_lock_irq(&desc->lock);
1da177e4 89
bd062e76 90 if (desc->istate & IRQS_AUTODETECT) {
1da177e4 91 /* It triggered already - consider it spurious. */
163ef309 92 if (!(desc->istate & IRQS_WAITING)) {
bd062e76 93 desc->istate &= ~IRQS_AUTODETECT;
46999238 94 irq_shutdown(desc);
1da177e4
LT
95 } else
96 if (i < 32)
06fcb0c6 97 mask |= 1 << i;
1da177e4 98 }
239007b8 99 raw_spin_unlock_irq(&desc->lock);
1da177e4
LT
100 }
101
06fcb0c6 102 return mask;
1da177e4 103}
1da177e4
LT
104EXPORT_SYMBOL(probe_irq_on);
105
106/**
107 * probe_irq_mask - scan a bitmap of interrupt lines
108 * @val: mask of interrupts to consider
109 *
110 * Scan the interrupt lines and return a bitmap of active
111 * autodetect interrupts. The interrupt probe logic state
112 * is then returned to its previous value.
113 *
114 * Note: we need to scan all the irq's even though we will
115 * only return autodetect irq numbers - just so that we reset
116 * them all to a known state.
117 */
118unsigned int probe_irq_mask(unsigned long val)
119{
bd062e76 120 unsigned int mask = 0;
10e58084 121 struct irq_desc *desc;
1da177e4
LT
122 int i;
123
10e58084 124 for_each_irq_desc(i, desc) {
239007b8 125 raw_spin_lock_irq(&desc->lock);
bd062e76 126 if (desc->istate & IRQS_AUTODETECT) {
163ef309 127 if (i < 16 && !(desc->istate & IRQS_WAITING))
1da177e4
LT
128 mask |= 1 << i;
129
bd062e76 130 desc->istate &= ~IRQS_AUTODETECT;
46999238 131 irq_shutdown(desc);
1da177e4 132 }
239007b8 133 raw_spin_unlock_irq(&desc->lock);
1da177e4 134 }
74ffd553 135 mutex_unlock(&probing_active);
1da177e4
LT
136
137 return mask & val;
138}
139EXPORT_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 */
158int probe_irq_off(unsigned long val)
159{
63d659d5 160 int i, irq_found = 0, nr_of_irqs = 0;
10e58084 161 struct irq_desc *desc;
1da177e4 162
10e58084 163 for_each_irq_desc(i, desc) {
239007b8 164 raw_spin_lock_irq(&desc->lock);
1da177e4 165
bd062e76 166 if (desc->istate & IRQS_AUTODETECT) {
163ef309 167 if (!(desc->istate & IRQS_WAITING)) {
63d659d5 168 if (!nr_of_irqs)
1da177e4 169 irq_found = i;
63d659d5 170 nr_of_irqs++;
1da177e4 171 }
bd062e76 172 desc->istate &= ~IRQS_AUTODETECT;
46999238 173 irq_shutdown(desc);
1da177e4 174 }
239007b8 175 raw_spin_unlock_irq(&desc->lock);
1da177e4 176 }
74ffd553 177 mutex_unlock(&probing_active);
1da177e4 178
63d659d5 179 if (nr_of_irqs > 1)
1da177e4 180 irq_found = -irq_found;
74ffd553 181
1da177e4
LT
182 return irq_found;
183}
1da177e4
LT
184EXPORT_SYMBOL(probe_irq_off);
185