kernel/irq/autoprobe.c

   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);
  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)) {
  74                                 irq_compat_set_pending(desc);
  75                                 desc->istate |= IRQS_PENDING;
  76                         }
  77                 }
  78                 raw_spin_unlock_irq(&desc->lock);
  79         }
  80
  81         /*
  82          * Wait for spurious interrupts to trigger
  83          */
  84         msleep(100);
  85
  86         /*
  87          * Now filter out any obviously spurious interrupts
  88          */
  89         for_each_irq_desc(i, desc) {
  90                 raw_spin_lock_irq(&desc->lock);
  91
  92                 if (desc->istate & IRQS_AUTODETECT) {
  93                         /* It triggered already - consider it spurious. */
  94                         if (!(desc->istate & IRQS_WAITING)) {
  95                                 desc->istate &= ~IRQS_AUTODETECT;
  96                                 irq_shutdown(desc);
  97                         } else
  98                                 if (i < 32)
  99                                         mask |= 1 << i;
 100                 }
 101                 raw_spin_unlock_irq(&desc->lock);
 102         }
 103
 104         return mask;
 105 }
 106 EXPORT_SYMBOL(probe_irq_on);
 107
 108 /**
 109  *      probe_irq_mask - scan a bitmap of interrupt lines
 110  *      @val:   mask of interrupts to consider
 111  *
 112  *      Scan the interrupt lines and return a bitmap of active
 113  *      autodetect interrupts. The interrupt probe logic state
 114  *      is then returned to its previous value.
 115  *
 116  *      Note: we need to scan all the irq's even though we will
 117  *      only return autodetect irq numbers - just so that we reset
 118  *      them all to a known state.
 119  */
 120 unsigned int probe_irq_mask(unsigned long val)
 121 {
 122         unsigned int mask = 0;
 123         struct irq_desc *desc;
 124         int i;
 125
 126         for_each_irq_desc(i, desc) {
 127                 raw_spin_lock_irq(&desc->lock);
 128                 if (desc->istate & IRQS_AUTODETECT) {
 129                         if (i < 16 && !(desc->istate & IRQS_WAITING))
 130                                 mask |= 1 << i;
 131
 132                         desc->istate &= ~IRQS_AUTODETECT;
 133                         irq_shutdown(desc);
 134                 }
 135                 raw_spin_unlock_irq(&desc->lock);
 136         }
 137         mutex_unlock(&probing_active);
 138
 139         return mask & val;
 140 }
 141 EXPORT_SYMBOL(probe_irq_mask);
 142
 143 /**
 144  *      probe_irq_off   - end an interrupt autodetect
 145  *      @val: mask of potential interrupts (unused)
 146  *
 147  *      Scans the unused interrupt lines and returns the line which
 148  *      appears to have triggered the interrupt. If no interrupt was
 149  *      found then zero is returned. If more than one interrupt is
 150  *      found then minus the first candidate is returned to indicate
 151  *      their is doubt.
 152  *
 153  *      The interrupt probe logic state is returned to its previous
 154  *      value.
 155  *
 156  *      BUGS: When used in a module (which arguably shouldn't happen)
 157  *      nothing prevents two IRQ probe callers from overlapping. The
 158  *      results of this are non-optimal.
 159  */
 160 int probe_irq_off(unsigned long val)
 161 {
 162         int i, irq_found = 0, nr_of_irqs = 0;
 163         struct irq_desc *desc;
 164
 165         for_each_irq_desc(i, desc) {
 166                 raw_spin_lock_irq(&desc->lock);
 167
 168                 if (desc->istate & IRQS_AUTODETECT) {
 169                         if (!(desc->istate & IRQS_WAITING)) {
 170                                 if (!nr_of_irqs)
 171                                         irq_found = i;
 172                                 nr_of_irqs++;
 173                         }
 174                         desc->istate &= ~IRQS_AUTODETECT;
 175                         irq_shutdown(desc);
 176                 }
 177                 raw_spin_unlock_irq(&desc->lock);
 178         }
 179         mutex_unlock(&probing_active);
 180
 181         if (nr_of_irqs > 1)
 182                 irq_found = -irq_found;
 183
 184         return irq_found;
 185 }
 186 EXPORT_SYMBOL(probe_irq_off);
 187