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
  14 /*
  15  * Autodetection depends on the fact that any interrupt that
  16  * comes in on to an unassigned handler will get stuck with
  17  * "IRQ_WAITING" cleared and the interrupt disabled.
  18  */
  19 static DECLARE_MUTEX(probe_sem);
  20
  21 /**
  22  *      probe_irq_on    - begin an interrupt autodetect
  23  *
  24  *      Commence probing for an interrupt. The interrupts are scanned
  25  *      and a mask of potential interrupt lines is returned.
  26  *
  27  */
  28 unsigned long probe_irq_on(void)
  29 {
  30         unsigned long val;
  31         irq_desc_t *desc;
  32         unsigned int i;
  33
  34         down(&probe_sem);
  35         /*
  36          * something may have generated an irq long ago and we want to
  37          * flush such a longstanding irq before considering it as spurious.
  38          */
  39         for (i = NR_IRQS-1; i > 0; i--) {
  40                 desc = irq_desc + i;
  41
  42                 spin_lock_irq(&desc->lock);
  43                 if (!irq_desc[i].action)
  44                         irq_desc[i].handler->startup(i);
  45                 spin_unlock_irq(&desc->lock);
  46         }
  47
  48         /* Wait for longstanding interrupts to trigger. */
  49         msleep(20);
  50
  51         /*
  52          * enable any unassigned irqs
  53          * (we must startup again here because if a longstanding irq
  54          * happened in the previous stage, it may have masked itself)
  55          */
  56         for (i = NR_IRQS-1; i > 0; i--) {
  57                 desc = irq_desc + i;
  58
  59                 spin_lock_irq(&desc->lock);
  60                 if (!desc->action) {
  61                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
  62                         if (desc->handler->startup(i))
  63                                 desc->status |= IRQ_PENDING;
  64                 }
  65                 spin_unlock_irq(&desc->lock);
  66         }
  67
  68         /*
  69          * Wait for spurious interrupts to trigger
  70          */
  71         msleep(100);
  72
  73         /*
  74          * Now filter out any obviously spurious interrupts
  75          */
  76         val = 0;
  77         for (i = 0; i < NR_IRQS; i++) {
  78                 irq_desc_t *desc = irq_desc + i;
  79                 unsigned int status;
  80
  81                 spin_lock_irq(&desc->lock);
  82                 status = desc->status;
  83
  84                 if (status & IRQ_AUTODETECT) {
  85                         /* It triggered already - consider it spurious. */
  86                         if (!(status & IRQ_WAITING)) {
  87                                 desc->status = status & ~IRQ_AUTODETECT;
  88                                 desc->handler->shutdown(i);
  89                         } else
  90                                 if (i < 32)
  91                                         val |= 1 << i;
  92                 }
  93                 spin_unlock_irq(&desc->lock);
  94         }
  95
  96         return val;
  97 }
  98
  99 EXPORT_SYMBOL(probe_irq_on);
 100
 101 /**
 102  *      probe_irq_mask - scan a bitmap of interrupt lines
 103  *      @val:   mask of interrupts to consider
 104  *
 105  *      Scan the interrupt lines and return a bitmap of active
 106  *      autodetect interrupts. The interrupt probe logic state
 107  *      is then returned to its previous value.
 108  *
 109  *      Note: we need to scan all the irq's even though we will
 110  *      only return autodetect irq numbers - just so that we reset
 111  *      them all to a known state.
 112  */
 113 unsigned int probe_irq_mask(unsigned long val)
 114 {
 115         unsigned int mask;
 116         int i;
 117
 118         mask = 0;
 119         for (i = 0; i < NR_IRQS; i++) {
 120                 irq_desc_t *desc = irq_desc + i;
 121                 unsigned int status;
 122
 123                 spin_lock_irq(&desc->lock);
 124                 status = desc->status;
 125
 126                 if (status & IRQ_AUTODETECT) {
 127                         if (i < 16 && !(status & IRQ_WAITING))
 128                                 mask |= 1 << i;
 129
 130                         desc->status = status & ~IRQ_AUTODETECT;
 131                         desc->handler->shutdown(i);
 132                 }
 133                 spin_unlock_irq(&desc->lock);
 134         }
 135         up(&probe_sem);
 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_irqs = 0;
 161
 162         for (i = 0; i < NR_IRQS; i++) {
 163                 irq_desc_t *desc = irq_desc + i;
 164                 unsigned int status;
 165
 166                 spin_lock_irq(&desc->lock);
 167                 status = desc->status;
 168
 169                 if (status & IRQ_AUTODETECT) {
 170                         if (!(status & IRQ_WAITING)) {
 171                                 if (!nr_irqs)
 172                                         irq_found = i;
 173                                 nr_irqs++;
 174                         }
 175                         desc->status = status & ~IRQ_AUTODETECT;
 176                         desc->handler->shutdown(i);
 177                 }
 178                 spin_unlock_irq(&desc->lock);
 179         }
 180         up(&probe_sem);
 181
 182         if (nr_irqs > 1)
 183                 irq_found = -irq_found;
 184         return irq_found;
 185 }
 186
 187 EXPORT_SYMBOL(probe_irq_off);
 188