Subversion Repositories openrisc

/* ----------------------------------------------------------------------------

 *         ATMEL Microcontroller Software Support

 * ----------------------------------------------------------------------------

 * Copyright (c) 2008, Atmel Corporation

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * - Redistributions of source code must retain the above copyright notice,

 * this list of conditions and the disclaimer below.

 *

 * Atmel's name may not be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE

 * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,

 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 * ----------------------------------------------------------------------------

 */

/// Disable traces for this file

#ifndef NOTRACE

    #define NOTRACE

#endif

//------------------------------------------------------------------------------

//         Headers

//------------------------------------------------------------------------------

#include "pio_it.h"

#include "pio.h"

#include <aic/aic.h>

#include <board.h>

#include <utility/assert.h>

#include <utility/trace.h>

//------------------------------------------------------------------------------

//         Local definitions

//------------------------------------------------------------------------------

/// Returns the current value of a register.

#define READ(peripheral, register)          (peripheral->register)

/// Modifies the current value of a register.

#define WRITE(peripheral, register, value)  (peripheral->register = value)

/// Maximum number of interrupt sources that can be defined.

#define MAX_INTERRUPT_SOURCES       7

//------------------------------------------------------------------------------

//         Local types

//------------------------------------------------------------------------------

/// Describes a PIO interrupt source, including the PIO instance triggering the

/// interrupt and the associated interrupt handler.

typedef struct _InterruptSource {

    /// Interrupt source pin.

    const Pin *pPin;

    /// Interrupt handler.

    void (*handler)(const Pin *);

} InterruptSource;

//------------------------------------------------------------------------------

//         Local variables

//------------------------------------------------------------------------------

/// List of interrupt sources.

static InterruptSource pSources[MAX_INTERRUPT_SOURCES];

/// Number of currently defined interrupt sources.

static unsigned int numSources;

//------------------------------------------------------------------------------

//         Local functions

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

/// Handles all interrupts on the given PIO controller.

/// \param id  PIO controller ID.

/// \param pBase  PIO controller base address.

//------------------------------------------------------------------------------

void PioInterruptHandler(unsigned int id, AT91S_PIO *pBase)

{

    unsigned int status;

    unsigned int i;

    // Check PIO controller status

    status = pBase->PIO_ISR;

    status &= pBase->PIO_IMR;

    if (status != 0) {

        trace_LOG(trace_DEBUG, "-D- PIO interrupt on PIO controller #%d\n\r", id);

        // Check all sources

        i = 0;

        while (status != 0) {

            // There cannot be an unconfigured source enabled.

            SANITY_CHECK(i < numSources);

            // Source if configured on PIOA

            if (pSources[i].pPin->id == id) {

                // Source has PIOs which have changed

                if ((status & pSources[i].pPin->mask) != 0) {

                    trace_LOG(trace_DEBUG, "-D- Interrupt source #%d triggered\n\r", i);

                    pSources[i].handler(pSources[i].pPin);

                    status &= ~(pSources[i].pPin->mask);

                }

            }

            i++;

        }

    }

}

//------------------------------------------------------------------------------

/// Generic PIO interrupt handler. Single entry point for interrupts coming

/// from any PIO controller (PIO A, B, C ...). Dispatches the interrupt to

/// the user-configured handlers.

//------------------------------------------------------------------------------

void InterruptHandler()

{

#if defined(AT91C_ID_PIOA)

    // Treat PIOA interrupts

    PioInterruptHandler(AT91C_ID_PIOA, AT91C_BASE_PIOA);

#endif

#if defined(AT91C_ID_PIOB)

    // Treat PIOB interrupts

    PioInterruptHandler(AT91C_ID_PIOB, AT91C_BASE_PIOB);

#endif

#if defined(AT91C_ID_PIOC)

    // Treat PIOC interrupts

    PioInterruptHandler(AT91C_ID_PIOC, AT91C_BASE_PIOC);

#endif

#if defined(AT91C_ID_PIOD)

    // Treat PIOD interrupts

    PioInterruptHandler(AT91C_ID_PIOD, AT91C_BASE_PIOD);

#endif

#if defined(AT91C_ID_PIOE)

    // Treat PIOE interrupts

    PioInterruptHandler(AT91C_ID_PIOE, AT91C_BASE_PIOE);

#endif

#if defined(AT91C_ID_PIOABCD)

    // Treat PIOABCD interrupts

    #if !defined(AT91C_ID_PIOA)

        PioInterruptHandler(AT91C_ID_PIOABCD, AT91C_BASE_PIOA);

    #endif

    #if !defined(AT91C_ID_PIOB)

        PioInterruptHandler(AT91C_ID_PIOABCD, AT91C_BASE_PIOB);

    #endif

    #if !defined(AT91C_ID_PIOC)

        PioInterruptHandler(AT91C_ID_PIOABCD, AT91C_BASE_PIOC);

    #endif

    #if !defined(AT91C_ID_PIOD)

        PioInterruptHandler(AT91C_ID_PIOABCD, AT91C_BASE_PIOD);

    #endif

#endif

#if defined(AT91C_ID_PIOABCDE)

    // Treat PIOABCDE interrupts

    #if !defined(AT91C_ID_PIOA)

        PioInterruptHandler(AT91C_ID_PIOABCDE, AT91C_BASE_PIOA);

    #endif

    #if !defined(AT91C_ID_PIOB)

        PioInterruptHandler(AT91C_ID_PIOABCDE, AT91C_BASE_PIOB);

    #endif

    #if !defined(AT91C_ID_PIOC)

        PioInterruptHandler(AT91C_ID_PIOABCDE, AT91C_BASE_PIOC);

    #endif

    #if !defined(AT91C_ID_PIOD)

        PioInterruptHandler(AT91C_ID_PIOABCDE, AT91C_BASE_PIOD);

    #endif

    #if !defined(AT91C_ID_PIOE)

        PioInterruptHandler(AT91C_ID_PIOABCDE, AT91C_BASE_PIOE);

    #endif

#endif

#if defined(AT91C_ID_PIOCDE)

    // Treat PIOCDE interrupts

    #if !defined(AT91C_ID_PIOC)

        PioInterruptHandler(AT91C_ID_PIOCDE, AT91C_BASE_PIOC);

    #endif

    #if !defined(AT91C_ID_PIOD)

        PioInterruptHandler(AT91C_ID_PIOCDE, AT91C_BASE_PIOD);

    #endif

    #if !defined(AT91C_ID_PIOE)

        PioInterruptHandler(AT91C_ID_PIOCDE, AT91C_BASE_PIOE);

    #endif

#endif

}

//------------------------------------------------------------------------------

//         Global functions

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

/// Initializes the PIO interrupt management logic.

/// \param priority  PIO controller interrupts priority.

//------------------------------------------------------------------------------

void PIO_InitializeInterrupts(unsigned int priority)

{

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize()\n\r");

    SANITY_CHECK((priority & ~AT91C_AIC_PRIOR) == 0);

    // Reset sources

    numSources = 0;

#ifdef AT91C_ID_PIOA

    // Configure PIO interrupt sources

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOA\n\r");

    AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOA;

    AT91C_BASE_PIOA->PIO_ISR;

    AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF;

    AIC_ConfigureIT(AT91C_ID_PIOA, priority, InterruptHandler);

    AIC_EnableIT(AT91C_ID_PIOA);

#endif

#ifdef AT91C_ID_PIOB

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOB\n\r");

    AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOB;

    AT91C_BASE_PIOB->PIO_ISR;

    AT91C_BASE_PIOB->PIO_IDR = 0xFFFFFFFF;

    AIC_ConfigureIT(AT91C_ID_PIOB, priority, InterruptHandler);

    AIC_EnableIT(AT91C_ID_PIOB);

#endif

#ifdef AT91C_ID_PIOC

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOC\n\r");

    AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOC;

    AT91C_BASE_PIOC->PIO_ISR;

    AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF;

    AIC_ConfigureIT(AT91C_ID_PIOC, priority, InterruptHandler);

    AIC_EnableIT(AT91C_ID_PIOC);

#endif

#ifdef AT91C_ID_PIOD

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOD\n\r");

    AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOD;

    AT91C_BASE_PIOC->PIO_ISR;

    AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF;

    AIC_ConfigureIT(AT91C_ID_PIOD, priority, InterruptHandler);

    AIC_EnableIT(AT91C_ID_PIOD);

#endif

#ifdef AT91C_ID_PIOE

    trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOE\n\r");

    AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOE;

    AT91C_BASE_PIOC->PIO_ISR;

    AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF;

    AIC_ConfigureIT(AT91C_ID_PIOE, priority, InterruptHandler);

    AIC_EnableIT(AT91C_ID_PIOE);

#endif

#if defined(AT91C_ID_PIOABCD)

    // Treat PIOABCD interrupts

    #if !defined(AT91C_ID_PIOA) \

     && !defined(AT91C_ID_PIOB) \

     && !defined(AT91C_ID_PIOC) \

     && !defined(AT91C_ID_PIOD)

        trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOABCD\n\r");

        AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOABCD;

        AT91C_BASE_PIOA->PIO_ISR;

        AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF;

        AIC_ConfigureIT(AT91C_ID_PIOABCD, priority, InterruptHandler);

        AIC_EnableIT(AT91C_ID_PIOABCD);

    #endif

#endif

#if defined(AT91C_ID_PIOABCDE)

    // Treat PIOABCDE interrupts

    #if !defined(AT91C_ID_PIOA) \

     && !defined(AT91C_ID_PIOB) \

     && !defined(AT91C_ID_PIOC) \

     && !defined(AT91C_ID_PIOD) \

     && !defined(AT91C_ID_PIOE)

        trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOABCDE\n\r");

        AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOABCDE;

        AT91C_BASE_PIOA->PIO_ISR;

        AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF;

        AIC_ConfigureIT(AT91C_ID_PIOABCDE, priority, InterruptHandler);

        AIC_EnableIT(AT91C_ID_PIOABCDE);

    #endif

#endif

#if defined(AT91C_ID_PIOCDE)

    // Treat PIOCDE interrupts

    #if !defined(AT91C_ID_PIOC) \

     && !defined(AT91C_ID_PIOD) \

     && !defined(AT91C_ID_PIOE)

        trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOC\n\r");

        AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOCDE;

        AT91C_BASE_PIOC->PIO_ISR;

        AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF;

        AIC_ConfigureIT(AT91C_ID_PIOCDE, priority, InterruptHandler);

        AIC_EnableIT(AT91C_ID_PIOCDE);

    #endif

#endif

}

//------------------------------------------------------------------------------

/// Configures an interrupt source.

/// \param pPin  Interrupt source.

/// \param handler  Desired interrupt handler for the source.

//------------------------------------------------------------------------------

void PIO_ConfigureIt(const Pin *pPin, void (*handler)(const Pin *))

{

    InterruptSource *pSource;

    trace_LOG(trace_DEBUG, "-D- PIO_ConfigureIt()\n\r");

    SANITY_CHECK(pPin);

    ASSERT(numSources < MAX_INTERRUPT_SOURCES,

           "-F- PIO_ConfigureIt: Increase MAX_INTERRUPT_SOURCES\n\r");

    // Define new source

    trace_LOG(trace_DEBUG, "-D- PIO_ConfigureIt: Defining new source #%d.\n\r", numSources);

    pSource = &(pSources[numSources]);

    pSource->pPin = pPin;

    pSource->handler = handler;

    numSources++;

}

//------------------------------------------------------------------------------

/// Enables the given interrupt source if it has been configured.

/// \param pPin  Interrupt source to enable.

//------------------------------------------------------------------------------

void PIO_EnableIt(const Pin *pPin)

{

    trace_LOG(trace_DEBUG, "-D- PIO_EnableIt()\n\r");

    SANITY_CHECK(pPin);

#ifndef NOASSERT

    unsigned int i = 0;

    unsigned char found = 0;

    while ((i < numSources) && !found) {

        if (pSources[i].pPin == pPin) {

            found = 1;

        }

        i++;

    }

    ASSERT(found, "-F- PIO_EnableIt: Interrupt source has not been configured\n\r");

#endif

    pPin->pio->PIO_ISR;

    pPin->pio->PIO_IER = pPin->mask;

}

//------------------------------------------------------------------------------

/// Disables a given interrupt source.

/// \param pPin  Interrupt source to disable.

//------------------------------------------------------------------------------

void PIO_DisableIt(const Pin *pPin)

{

    SANITY_CHECK(pPin);

    trace_LOG(trace_DEBUG, "-D- PIO_DisableIt()\n\r");

    pPin->pio->PIO_IDR = pPin->mask;

}