LXR linux/kernel/irq/autoprobe.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
   4 *
   5 * This file contains the interrupt probing code and driver APIs.
   6 */
   7
   8#include <linux/irq.h>
   9#include <linux/module.h>
  10#include <linux/interrupt.h>
  11#include <linux/delay.h>
  12#include <linux/async.h>
  13
  14#include "internals.h"
  15
  16/*
  17 * Autodetection depends on the fact that any interrupt that
  18 * comes in on to an unassigned handler will get stuck with
  19 * "IRQS_WAITING" cleared and the interrupt disabled.
  20 */
  21static DEFINE_MUTEX(probing_active);
  22
  23/**
  24 *      probe_irq_on    - begin an interrupt autodetect
  25 *
  26 *      Commence probing for an interrupt. The interrupts are scanned
  27 *      and a mask of potential interrupt lines is returned.
  28 *
  29 */
  30unsigned long probe_irq_on(void)
  31{
  32        struct irq_desc *desc;
  33        unsigned long mask = 0;
  34        int i;
  35
  36        /*
  37         * quiesce the kernel, or at least the asynchronous portion
  38         */
  39        async_synchronize_full();
  40        mutex_lock(&probing_active);
  41        /*
  42         * something may have generated an irq long ago and we want to
  43         * flush such a longstanding irq before considering it as spurious.
  44         */
  45        for_each_irq_desc_reverse(i, desc) {
  46                raw_spin_lock_irq(&desc->lock);
  47                if (!desc->action && irq_settings_can_probe(desc)) {
  48                        /*
  49                         * Some chips need to know about probing in
  50                         * progress:
  51                         */
  52                        if (desc->irq_data.chip->irq_set_type)
  53                                desc->irq_data.chip->irq_set_type(&desc->irq_data,
  54                                                         IRQ_TYPE_PROBE);
  55                        irq_activate_and_startup(desc, IRQ_NORESEND);
  56                }
  57                raw_spin_unlock_irq(&desc->lock);
  58        }
  59
  60        /* Wait for longstanding interrupts to trigger. */
  61        msleep(20);
  62
  63        /*
  64         * enable any unassigned irqs
  65         * (we must startup again here because if a longstanding irq
  66         * happened in the previous stage, it may have masked itself)
  67         */
  68        for_each_irq_desc_reverse(i, desc) {
  69                raw_spin_lock_irq(&desc->lock);
  70                if (!desc->action && irq_settings_can_probe(desc)) {
  71                        desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
  72                        if (irq_activate_and_startup(desc, IRQ_NORESEND))
  73                                desc->istate |= IRQS_PENDING;
  74                }
  75                raw_spin_unlock_irq(&desc->lock);
  76        }
  77
  78        /*
  79         * Wait for spurious interrupts to trigger
  80         */
  81        msleep(100);
  82
  83        /*
  84         * Now filter out any obviously spurious interrupts
  85         */
  86        for_each_irq_desc(i, desc) {
  87                raw_spin_lock_irq(&desc->lock);
  88
  89                if (desc->istate & IRQS_AUTODETECT) {
  90                        /* It triggered already - consider it spurious. */
  91                        if (!(desc->istate & IRQS_WAITING)) {
  92                                desc->istate &= ~IRQS_AUTODETECT;
  93                                irq_shutdown_and_deactivate(desc);
  94                        } else
  95                                if (i < 32)
  96                                        mask |= 1 << i;
  97                }
  98                raw_spin_unlock_irq(&desc->lock);
  99        }
 100
 101        return mask;
 102}
 103EXPORT_SYMBOL(probe_irq_on);
 104
 105/**
 106 *      probe_irq_mask - scan a bitmap of interrupt lines
 107 *      @val:   mask of interrupts to consider
 108 *
 109 *      Scan the interrupt lines and return a bitmap of active
 110 *      autodetect interrupts. The interrupt probe logic state
 111 *      is then returned to its previous value.
 112 *
 113 *      Note: we need to scan all the irq's even though we will
 114 *      only return autodetect irq numbers - just so that we reset
 115 *      them all to a known state.
 116 */
 117unsigned int probe_irq_mask(unsigned long val)
 118{
 119        unsigned int mask = 0;
 120        struct irq_desc *desc;
 121        int i;
 122
 123        for_each_irq_desc(i, desc) {
 124                raw_spin_lock_irq(&desc->lock);
 125                if (desc->istate & IRQS_AUTODETECT) {
 126                        if (i < 16 && !(desc->istate & IRQS_WAITING))
 127                                mask |= 1 << i;
 128
 129                        desc->istate &= ~IRQS_AUTODETECT;
 130                        irq_shutdown_and_deactivate(desc);
 131                }
 132                raw_spin_unlock_irq(&desc->lock);
 133        }
 134        mutex_unlock(&probing_active);
 135
 136        return mask & val;
 137}
 138EXPORT_SYMBOL(probe_irq_mask);
 139
 140/**
 141 *      probe_irq_off   - end an interrupt autodetect
 142 *      @val: mask of potential interrupts (unused)
 143 *
 144 *      Scans the unused interrupt lines and returns the line which
 145 *      appears to have triggered the interrupt. If no interrupt was
 146 *      found then zero is returned. If more than one interrupt is
 147 *      found then minus the first candidate is returned to indicate
 148 *      their is doubt.
 149 *
 150 *      The interrupt probe logic state is returned to its previous
 151 *      value.
 152 *
 153 *      BUGS: When used in a module (which arguably shouldn't happen)
 154 *      nothing prevents two IRQ probe callers from overlapping. The
 155 *      results of this are non-optimal.
 156 */
 157int probe_irq_off(unsigned long val)
 158{
 159        int i, irq_found = 0, nr_of_irqs = 0;
 160        struct irq_desc *desc;
 161
 162        for_each_irq_desc(i, desc) {
 163                raw_spin_lock_irq(&desc->lock);
 164
 165                if (desc->istate & IRQS_AUTODETECT) {
 166                        if (!(desc->istate & IRQS_WAITING)) {
 167                                if (!nr_of_irqs)
 168                                        irq_found = i;
 169                                nr_of_irqs++;
 170                        }
 171                        desc->istate &= ~IRQS_AUTODETECT;
 172                        irq_shutdown_and_deactivate(desc);
 173                }
 174                raw_spin_unlock_irq(&desc->lock);
 175        }
 176        mutex_unlock(&probing_active);
 177
 178        if (nr_of_irqs > 1)
 179                irq_found = -irq_found;
 180
 181        return irq_found;
 182}
 183EXPORT_SYMBOL(probe_irq_off);
 184
 185