Subversion Repositories test_project

/*

 * 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 "internals.h"

/*

 * Autodetection depends on the fact that any interrupt that

 * comes in on to an unassigned handler will get stuck with

 * "IRQ_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;

        unsigned int i;

        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 (i = NR_IRQS-1; i > 0; i--) {

                desc = irq_desc + i;

                spin_lock_irq(&desc->lock);

                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {

                        /*

                         * An old-style architecture might still have

                         * the handle_bad_irq handler there:

                         */

                        compat_irq_chip_set_default_handler(desc);

                        /*

                         * Some chips need to know about probing in

                         * progress:

                         */

                        if (desc->chip->set_type)

                                desc->chip->set_type(i, IRQ_TYPE_PROBE);

                        desc->chip->startup(i);

                }

                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 (i = NR_IRQS-1; i > 0; i--) {

                desc = irq_desc + i;

                spin_lock_irq(&desc->lock);

                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {

                        desc->status |= IRQ_AUTODETECT | IRQ_WAITING;

                        if (desc->chip->startup(i))

                                desc->status |= IRQ_PENDING;

                }

                spin_unlock_irq(&desc->lock);

        }

        /*

         * Wait for spurious interrupts to trigger

         */

        msleep(100);

        /*

         * Now filter out any obviously spurious interrupts

         */

        mask = 0;

        for (i = 0; i < NR_IRQS; i++) {

                unsigned int status;

                desc = irq_desc + i;

                spin_lock_irq(&desc->lock);

                status = desc->status;

                if (status & IRQ_AUTODETECT) {

                        /* It triggered already - consider it spurious. */

                        if (!(status & IRQ_WAITING)) {

                                desc->status = status & ~IRQ_AUTODETECT;

                                desc->chip->shutdown(i);

                        } else

                                if (i < 32)

                                        mask |= 1 << i;

                }

                spin_unlock_irq(&desc->lock);

        }

        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;

        int i;

        mask = 0;

        for (i = 0; i < NR_IRQS; i++) {

                struct irq_desc *desc = irq_desc + i;

                unsigned int status;

                spin_lock_irq(&desc->lock);

                status = desc->status;

                if (status & IRQ_AUTODETECT) {

                        if (i < 16 && !(status & IRQ_WAITING))

                                mask |= 1 << i;

                        desc->status = status & ~IRQ_AUTODETECT;

                        desc->chip->shutdown(i);

                }

                spin_unlock_irq(&desc->lock);

        }

        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_irqs = 0;

        for (i = 0; i < NR_IRQS; i++) {

                struct irq_desc *desc = irq_desc + i;

                unsigned int status;

                spin_lock_irq(&desc->lock);

                status = desc->status;

                if (status & IRQ_AUTODETECT) {

                        if (!(status & IRQ_WAITING)) {

                                if (!nr_irqs)

                                        irq_found = i;

                                nr_irqs++;

                        }

                        desc->status = status & ~IRQ_AUTODETECT;

                        desc->chip->shutdown(i);

                }

                spin_unlock_irq(&desc->lock);

        }

        mutex_unlock(&probing_active);

        if (nr_irqs > 1)

                irq_found = -irq_found;

        return irq_found;

}

EXPORT_SYMBOL(probe_irq_off);