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  * "IRQ_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         unsigned int status;
  36         int i;
  37
  38         /*
  39          * quiesce the kernel, or at least the asynchronous portion
  40          */
  41         async_synchronize_full();
  42         mutex_lock(&probing_active);
  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          */
  47         for_each_irq_desc_reverse(i, desc) {
  48                 raw_spin_lock_irq(&desc->lock);
  49                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
  50                         /*
  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                         /*
  57                          * Some chips need to know about probing in
  58                          * progress:
  59                          */
  60                         if (desc->irq_data.chip->irq_set_type)
  61                                 desc->irq_data.chip->irq_set_type(&desc->irq_data,
  62                                                          IRQ_TYPE_PROBE);
  63                         desc->irq_data.chip->irq_startup(&desc->irq_data);
  64                 }
  65                 raw_spin_unlock_irq(&desc->lock);
  66         }
  67
  68         /* Wait for longstanding interrupts to trigger. */
  69         msleep(20);
  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          */
  76         for_each_irq_desc_reverse(i, desc) {
  77                 raw_spin_lock_irq(&desc->lock);
  78                 if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
  79                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
  80                         if (desc->irq_data.chip->irq_startup(&desc->irq_data))
  81                                 desc->status |= IRQ_PENDING;
  82                 }
  83                 raw_spin_unlock_irq(&desc->lock);
  84         }
  85
  86         /*
  87          * Wait for spurious interrupts to trigger
  88          */
  89         msleep(100);
  90
  91         /*
  92          * Now filter out any obviously spurious interrupts
  93          */
  94         for_each_irq_desc(i, desc) {
  95                 raw_spin_lock_irq(&desc->lock);
  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;
 102                                 desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 103                         } else
 104                                 if (i < 32)
 105                                         mask |= 1 << i;
 106                 }
 107                 raw_spin_unlock_irq(&desc->lock);
 108         }
 109
 110         return mask;
 111 }
 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 {
 128         unsigned int status, mask = 0;
 129         struct irq_desc *desc;
 130         int i;
 131
 132         for_each_irq_desc(i, desc) {
 133                 raw_spin_lock_irq(&desc->lock);
 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;
 141                         desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 142                 }
 143                 raw_spin_unlock_irq(&desc->lock);
 144         }
 145         mutex_unlock(&probing_active);
 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 {
 170         int i, irq_found = 0, nr_of_irqs = 0;
 171         struct irq_desc *desc;
 172         unsigned int status;
 173
 174         for_each_irq_desc(i, desc) {
 175                 raw_spin_lock_irq(&desc->lock);
 176                 status = desc->status;
 177
 178                 if (status & IRQ_AUTODETECT) {
 179                         if (!(status & IRQ_WAITING)) {
 180                                 if (!nr_of_irqs)
 181                                         irq_found = i;
 182                                 nr_of_irqs++;
 183                         }
 184                         desc->status = status & ~IRQ_AUTODETECT;
 185                         desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 186                 }
 187                 raw_spin_unlock_irq(&desc->lock);
 188         }
 189         mutex_unlock(&probing_active);
 190
 191         if (nr_of_irqs > 1)
 192                 irq_found = -irq_found;
 193
 194         return irq_found;
 195 }
 196 EXPORT_SYMBOL(probe_irq_off);
 197