LXR linux/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 */
  22static 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 */
  31unsigned 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}
 104EXPORT_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 */
 118unsigned 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}
 139EXPORT_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 */
 158int 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}
 184EXPORT_SYMBOL(probe_irq_off);
 185
 186