// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
 *
 * This file contains the interrupt probing code and driver APIs.
 */

#include <linux/irq.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/async.h>

#include "internals.h"

/*
 * Autodetection depends on the fact that any interrupt that
 * comes in on to an unassigned handler will get stuck with
 * "IRQS_WAITING" cleared and the interrupt disabled.
 */
static DEFINE_MUTEX(probing_active);

/**
 *      probe_irq_on    - begin an interrupt autodetect
 *
 *      Commence probing for an interrupt. The interrupts are scanned
 *      and a mask of potential interrupt lines is returned.
 *
 */
unsigned long probe_irq_on(void)
{
        struct irq_desc *desc;
        unsigned long mask = 0;
        int i;

        /*
         * quiesce the kernel, or at least the asynchronous portion
         */
        async_synchronize_full();
        mutex_lock(&probing_active);
        /*
         * something may have generated an irq long ago and we want to
         * flush such a longstanding irq before considering it as spurious.
         */
        for_each_irq_desc_reverse(i, desc) {
                guard(raw_spinlock_irq)(&desc->lock);
                if (!desc->action && irq_settings_can_probe(desc)) {
                        /*
                         * Some chips need to know about probing in
                         * progress:
                         */
                        if (desc->irq_data.chip->irq_set_type)
                                desc->irq_data.chip->irq_set_type(&desc->irq_data, IRQ_TYPE_PROBE);
                        irq_activate_and_startup(desc, IRQ_NORESEND);
                }
        }

        /* Wait for longstanding interrupts to trigger. */
        msleep(20);

        /*
         * enable any unassigned irqs
         * (we must startup again here because if a longstanding irq
         * happened in the previous stage, it may have masked itself)
         */
        for_each_irq_desc_reverse(i, desc) {
                guard(raw_spinlock_irq)(&desc->lock);
                if (!desc->action && irq_settings_can_probe(desc)) {
                        desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
                        if (irq_activate_and_startup(desc, IRQ_NORESEND))
                                desc->istate |= IRQS_PENDING;
                }
        }

        /*
         * Wait for spurious interrupts to trigger
         */
        msleep(100);

        /*
         * Now filter out any obviously spurious interrupts
         */
        for_each_irq_desc(i, desc) {
                guard(raw_spinlock_irq)(&desc->lock);
                if (desc->istate & IRQS_AUTODETECT) {
                        /* It triggered already - consider it spurious. */
                        if (!(desc->istate & IRQS_WAITING)) {
                                desc->istate &= ~IRQS_AUTODETECT;
                                irq_shutdown_and_deactivate(desc);
                        } else if (i < 32) {
                                mask |= 1 << i;
                        }
                }
        }

        return mask;
}
EXPORT_SYMBOL(probe_irq_on);

/**
 *      probe_irq_mask - scan a bitmap of interrupt lines
 *      @val:   mask of interrupts to consider
 *
 *      Scan the interrupt lines and return a bitmap of active
 *      autodetect interrupts. The interrupt probe logic state
 *      is then returned to its previous value.
 *
 *      Note: we need to scan all the irq's even though we will
 *      only return autodetect irq numbers - just so that we reset
 *      them all to a known state.
 */
unsigned int probe_irq_mask(unsigned long val)
{
        unsigned int mask = 0;
        struct irq_desc *desc;
        int i;

        for_each_irq_desc(i, desc) {
                guard(raw_spinlock_irq)(&desc->lock);
                if (desc->istate & IRQS_AUTODETECT) {
                        if (i < 16 && !(desc->istate & IRQS_WAITING))
                                mask |= 1 << i;

                        desc->istate &= ~IRQS_AUTODETECT;
                        irq_shutdown_and_deactivate(desc);
                }
        }
        mutex_unlock(&probing_active);

        return mask & val;
}
EXPORT_SYMBOL(probe_irq_mask);

/**
 *      probe_irq_off   - end an interrupt autodetect
 *      @val: mask of potential interrupts (unused)
 *
 *      Scans the unused interrupt lines and returns the line which
 *      appears to have triggered the interrupt. If no interrupt was
 *      found then zero is returned. If more than one interrupt is
 *      found then minus the first candidate is returned to indicate
 *      their is doubt.
 *
 *      The interrupt probe logic state is returned to its previous
 *      value.
 *
 *      BUGS: When used in a module (which arguably shouldn't happen)
 *      nothing prevents two IRQ probe callers from overlapping. The
 *      results of this are non-optimal.
 */
int probe_irq_off(unsigned long val)
{
        int i, irq_found = 0, nr_of_irqs = 0;
        struct irq_desc *desc;

        for_each_irq_desc(i, desc) {
                guard(raw_spinlock_irq)(&desc->lock);
                if (desc->istate & IRQS_AUTODETECT) {
                        if (!(desc->istate & IRQS_WAITING)) {
                                if (!nr_of_irqs)
                                        irq_found = i;
                                nr_of_irqs++;
                        }
                        desc->istate &= ~IRQS_AUTODETECT;
                        irq_shutdown_and_deactivate(desc);
                }
        }
        mutex_unlock(&probing_active);

        if (nr_of_irqs > 1)
                irq_found = -irq_found;

        return irq_found;
}
EXPORT_SYMBOL(probe_irq_off);