autoprobe.c

Go to the documentation of this file.

/*
 * linux/kernel/irq/autoprobe.c
 *
 * 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);

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) {
        raw_spin_lock_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_startup(desc, false);
        }
        raw_spin_unlock_irq(&desc->lock);
    }

    /* 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) {
        raw_spin_lock_irq(&desc->lock);
        if (!desc->action && irq_settings_can_probe(desc)) {
            desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
            if (irq_startup(desc, false))
                desc->istate |= IRQS_PENDING;
        }
        raw_spin_unlock_irq(&desc->lock);
    }

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

    /*
     * Now filter out any obviously spurious interrupts
     */
    for_each_irq_desc(i, desc) {
        raw_spin_lock_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(desc);
            } else
                if (i < 32)
                    mask |= 1 << i;
        }
        raw_spin_unlock_irq(&desc->lock);
    }

    return mask;
}
EXPORT_SYMBOL(probe_irq_on);

unsigned int probe_irq_mask(unsigned long val)
{
    unsigned int mask = 0;
    struct irq_desc *desc;
    int i;

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

            desc->istate &= ~IRQS_AUTODETECT;
            irq_shutdown(desc);
        }
        raw_spin_unlock_irq(&desc->lock);
    }
    mutex_unlock(&probing_active);

    return mask & val;
}
EXPORT_SYMBOL(probe_irq_mask);

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) {
        raw_spin_lock_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(desc);
        }
        raw_spin_unlock_irq(&desc->lock);
    }
    mutex_unlock(&probing_active);

    if (nr_of_irqs > 1)
        irq_found = -irq_found;

    return irq_found;
}
EXPORT_SYMBOL(probe_irq_off);