projects/linux·blob master · refs

176 lines · 4.4 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
4 *
5 * This file contains the interrupt probing code and driver APIs.
6 */
7
8#include <linux/irq.h>
9#include <linux/module.h>
10#include <linux/interrupt.h>
11#include <linux/delay.h>
12#include <linux/async.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 * "IRQS_WAITING" cleared and the interrupt disabled.
20 */
21static 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 */
30unsigned long probe_irq_on(void)
31{
32 struct irq_desc *desc;
33 unsigned long mask = 0;
34 int i;
35
36 /*
37 * quiesce the kernel, or at least the asynchronous portion
38 */
39 async_synchronize_full();
40 mutex_lock(&probing_active);
41 /*
42 * something may have generated an irq long ago and we want to
43 * flush such a longstanding irq before considering it as spurious.
44 */
45 for_each_irq_desc_reverse(i, desc) {
46 guard(raw_spinlock_irq)(&desc->lock);
47 if (!desc->action && irq_settings_can_probe(desc)) {
48 /*
49 * Some chips need to know about probing in
50 * progress:
51 */
52 if (desc->irq_data.chip->irq_set_type)
53 desc->irq_data.chip->irq_set_type(&desc->irq_data, IRQ_TYPE_PROBE);
54 irq_activate_and_startup(desc, IRQ_NORESEND);
55 }
56 }
57
58 /* Wait for longstanding interrupts to trigger. */
59 msleep(20);
60
61 /*
62 * enable any unassigned irqs
63 * (we must startup again here because if a longstanding irq
64 * happened in the previous stage, it may have masked itself)
65 */
66 for_each_irq_desc_reverse(i, desc) {
67 guard(raw_spinlock_irq)(&desc->lock);
68 if (!desc->action && irq_settings_can_probe(desc)) {
69 desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
70 if (irq_activate_and_startup(desc, IRQ_NORESEND))
71 desc->istate |= IRQS_PENDING;
72 }
73 }
74
75 /*
76 * Wait for spurious interrupts to trigger
77 */
78 msleep(100);
79
80 /*
81 * Now filter out any obviously spurious interrupts
82 */
83 for_each_irq_desc(i, desc) {
84 guard(raw_spinlock_irq)(&desc->lock);
85 if (desc->istate & IRQS_AUTODETECT) {
86 /* It triggered already - consider it spurious. */
87 if (!(desc->istate & IRQS_WAITING)) {
88 desc->istate &= ~IRQS_AUTODETECT;
89 irq_shutdown_and_deactivate(desc);
90 } else if (i < 32) {
91 mask |= 1 << i;
92 }
93 }
94 }
95
96 return mask;
97}
98EXPORT_SYMBOL(probe_irq_on);
99
100/**
101 * probe_irq_mask - scan a bitmap of interrupt lines
102 * @val: mask of interrupts to consider
103 *
104 * Scan the interrupt lines and return a bitmap of active
105 * autodetect interrupts. The interrupt probe logic state
106 * is then returned to its previous value.
107 *
108 * Note: we need to scan all the irq's even though we will
109 * only return autodetect irq numbers - just so that we reset
110 * them all to a known state.
111 */
112unsigned int probe_irq_mask(unsigned long val)
113{
114 unsigned int mask = 0;
115 struct irq_desc *desc;
116 int i;
117
118 for_each_irq_desc(i, desc) {
119 guard(raw_spinlock_irq)(&desc->lock);
120 if (desc->istate & IRQS_AUTODETECT) {
121 if (i < 16 && !(desc->istate & IRQS_WAITING))
122 mask |= 1 << i;
123
124 desc->istate &= ~IRQS_AUTODETECT;
125 irq_shutdown_and_deactivate(desc);
126 }
127 }
128 mutex_unlock(&probing_active);
129
130 return mask & val;
131}
132EXPORT_SYMBOL(probe_irq_mask);
133
134/**
135 * probe_irq_off - end an interrupt autodetect
136 * @val: mask of potential interrupts (unused)
137 *
138 * Scans the unused interrupt lines and returns the line which
139 * appears to have triggered the interrupt. If no interrupt was
140 * found then zero is returned. If more than one interrupt is
141 * found then minus the first candidate is returned to indicate
142 * their is doubt.
143 *
144 * The interrupt probe logic state is returned to its previous
145 * value.
146 *
147 * BUGS: When used in a module (which arguably shouldn't happen)
148 * nothing prevents two IRQ probe callers from overlapping. The
149 * results of this are non-optimal.
150 */
151int probe_irq_off(unsigned long val)
152{
153 int i, irq_found = 0, nr_of_irqs = 0;
154 struct irq_desc *desc;
155
156 for_each_irq_desc(i, desc) {
157 guard(raw_spinlock_irq)(&desc->lock);
158 if (desc->istate & IRQS_AUTODETECT) {
159 if (!(desc->istate & IRQS_WAITING)) {
160 if (!nr_of_irqs)
161 irq_found = i;
162 nr_of_irqs++;
163 }
164 desc->istate &= ~IRQS_AUTODETECT;
165 irq_shutdown_and_deactivate(desc);
166 }
167 }
168 mutex_unlock(&probing_active);
169
170 if (nr_of_irqs > 1)
171 irq_found = -irq_found;
172
173 return irq_found;
174}
175EXPORT_SYMBOL(probe_irq_off);
176