~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/irq/autoprobe.c

Version: ~ [ linux-5.2-rc5 ] ~ [ linux-5.1.11 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.52 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.127 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.182 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.182 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/async.h>
 14 
 15 #include "internals.h"
 16 
 17 /*
 18  * Autodetection depends on the fact that any interrupt that
 19  * comes in on to an unassigned handler will get stuck with
 20  * "IRQS_WAITING" cleared and the interrupt disabled.
 21  */
 22 static DEFINE_MUTEX(probing_active);
 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 {
 33         struct irq_desc *desc;
 34         unsigned long mask = 0;
 35         int i;
 36 
 37         /*
 38          * quiesce the kernel, or at least the asynchronous portion
 39          */
 40         async_synchronize_full();
 41         mutex_lock(&probing_active);
 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          */
 46         for_each_irq_desc_reverse(i, desc) {
 47                 raw_spin_lock_irq(&desc->lock);
 48                 if (!desc->action && irq_settings_can_probe(desc)) {
 49                         /*
 50                          * Some chips need to know about probing in
 51                          * progress:
 52                          */
 53                         if (desc->irq_data.chip->irq_set_type)
 54                                 desc->irq_data.chip->irq_set_type(&desc->irq_data,
 55                                                          IRQ_TYPE_PROBE);
 56                         irq_startup(desc, false);
 57                 }
 58                 raw_spin_unlock_irq(&desc->lock);
 59         }
 60 
 61         /* Wait for longstanding interrupts to trigger. */
 62         msleep(20);
 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          */
 69         for_each_irq_desc_reverse(i, desc) {
 70                 raw_spin_lock_irq(&desc->lock);
 71                 if (!desc->action && irq_settings_can_probe(desc)) {
 72                         desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
 73                         if (irq_startup(desc, false))
 74                                 desc->istate |= IRQS_PENDING;
 75                 }
 76                 raw_spin_unlock_irq(&desc->lock);
 77         }
 78 
 79         /*
 80          * Wait for spurious interrupts to trigger
 81          */
 82         msleep(100);
 83 
 84         /*
 85          * Now filter out any obviously spurious interrupts
 86          */
 87         for_each_irq_desc(i, desc) {
 88                 raw_spin_lock_irq(&desc->lock);
 89 
 90                 if (desc->istate & IRQS_AUTODETECT) {
 91                         /* It triggered already - consider it spurious. */
 92                         if (!(desc->istate & IRQS_WAITING)) {
 93                                 desc->istate &= ~IRQS_AUTODETECT;
 94                                 irq_shutdown(desc);
 95                         } else
 96                                 if (i < 32)
 97                                         mask |= 1 << i;
 98                 }
 99                 raw_spin_unlock_irq(&desc->lock);
100         }
101 
102         return mask;
103 }
104 EXPORT_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  */
118 unsigned int probe_irq_mask(unsigned long val)
119 {
120         unsigned int mask = 0;
121         struct irq_desc *desc;
122         int i;
123 
124         for_each_irq_desc(i, desc) {
125                 raw_spin_lock_irq(&desc->lock);
126                 if (desc->istate & IRQS_AUTODETECT) {
127                         if (i < 16 && !(desc->istate & IRQS_WAITING))
128                                 mask |= 1 << i;
129 
130                         desc->istate &= ~IRQS_AUTODETECT;
131                         irq_shutdown(desc);
132                 }
133                 raw_spin_unlock_irq(&desc->lock);
134         }
135         mutex_unlock(&probing_active);
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_of_irqs = 0;
161         struct irq_desc *desc;
162 
163         for_each_irq_desc(i, desc) {
164                 raw_spin_lock_irq(&desc->lock);
165 
166                 if (desc->istate & IRQS_AUTODETECT) {
167                         if (!(desc->istate & IRQS_WAITING)) {
168                                 if (!nr_of_irqs)
169                                         irq_found = i;
170                                 nr_of_irqs++;
171                         }
172                         desc->istate &= ~IRQS_AUTODETECT;
173                         irq_shutdown(desc);
174                 }
175                 raw_spin_unlock_irq(&desc->lock);
176         }
177         mutex_unlock(&probing_active);
178 
179         if (nr_of_irqs > 1)
180                 irq_found = -irq_found;
181 
182         return irq_found;
183 }
184 EXPORT_SYMBOL(probe_irq_off);
185 
186 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp