379 lines
8.9 KiB
C
379 lines
8.9 KiB
C
/*
|
|
Copyright (c) 2015 Arduino LLC. All right reserved.
|
|
SAMD51 support added by Adafruit - Copyright (c) 2018 Dean Miller for Adafruit Industries
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "Arduino.h"
|
|
#include "wiring_private.h"
|
|
|
|
#include <string.h>
|
|
|
|
static voidFuncPtr ISRcallback[EXTERNAL_NUM_INTERRUPTS];
|
|
static uint32_t ISRlist[EXTERNAL_NUM_INTERRUPTS];
|
|
static uint32_t nints; // Stores total number of attached interrupts
|
|
|
|
|
|
/* Configure I/O interrupt sources */
|
|
static void __initialize()
|
|
{
|
|
memset(ISRlist, 0, sizeof(ISRlist));
|
|
memset(ISRcallback, 0, sizeof(ISRcallback));
|
|
nints = 0;
|
|
|
|
#if defined(__SAMD51__)
|
|
///EIC MCLK is enabled by default
|
|
for (uint32_t i = 0; i <= 15; i++) // EIC_0_IRQn = 12 ... EIC_15_IRQn = 27
|
|
{
|
|
uint8_t irqn = EIC_0_IRQn + i;
|
|
NVIC_DisableIRQ(irqn);
|
|
NVIC_ClearPendingIRQ(irqn);
|
|
NVIC_SetPriority(irqn, 0);
|
|
NVIC_EnableIRQ(irqn);
|
|
}
|
|
|
|
GCLK->PCHCTRL[EIC_GCLK_ID].reg = GCLK_PCHCTRL_GEN_GCLK2_Val | (1 << GCLK_PCHCTRL_CHEN_Pos);
|
|
#else
|
|
NVIC_DisableIRQ(EIC_IRQn);
|
|
NVIC_ClearPendingIRQ(EIC_IRQn);
|
|
NVIC_SetPriority(EIC_IRQn, 0);
|
|
NVIC_EnableIRQ(EIC_IRQn);
|
|
|
|
// Enable GCLK for IEC (External Interrupt Controller)
|
|
GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(GCM_EIC));
|
|
#endif
|
|
|
|
/* Shall we do that?
|
|
// Do a software reset on EIC
|
|
EIC->CTRL.SWRST.bit = 1 ;
|
|
while ((EIC->CTRL.SWRST.bit == 1) && (EIC->STATUS.SYNCBUSY.bit == 1)) { }
|
|
*/
|
|
|
|
// Enable EIC
|
|
#if defined(__SAMD51__)
|
|
EIC->CTRLA.bit.ENABLE = 1;
|
|
while (EIC->SYNCBUSY.bit.ENABLE == 1) { }
|
|
#else
|
|
EIC->CTRL.bit.ENABLE = 1;
|
|
while (EIC->STATUS.bit.SYNCBUSY == 1) { }
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* \brief Specifies a named Interrupt Service Routine (ISR) to call when an interrupt occurs.
|
|
* Replaces any previous function that was attached to the interrupt.
|
|
*/
|
|
void attachInterrupt(uint32_t pin, voidFuncPtr callback, uint32_t mode)
|
|
{
|
|
static int enabled = 0;
|
|
uint32_t config;
|
|
uint32_t pos;
|
|
|
|
#if ARDUINO_SAMD_VARIANT_COMPLIANCE >= 10606
|
|
EExt_Interrupts in = g_APinDescription[pin].ulExtInt;
|
|
#else
|
|
EExt_Interrupts in = digitalPinToInterrupt(pin);
|
|
#endif
|
|
if (in == NOT_AN_INTERRUPT) return;
|
|
|
|
if (!enabled) {
|
|
__initialize();
|
|
enabled = 1;
|
|
}
|
|
uint32_t inMask = (1UL << in);
|
|
// Enable wakeup capability on pin in case being used during sleep
|
|
#if defined(__SAMD51__)
|
|
//I believe this is done automatically
|
|
#else
|
|
EIC->WAKEUP.reg |= (1 << in);
|
|
#endif
|
|
|
|
// Only store when there is really an ISR to call.
|
|
// This allow for calling attachInterrupt(pin, NULL, mode), we set up all needed register
|
|
// but won't service the interrupt, this way we also don't need to check it inside the ISR.
|
|
if (callback)
|
|
{
|
|
if (in == EXTERNAL_INT_NMI) {
|
|
EIC->NMIFLAG.bit.NMI = 1; // Clear flag
|
|
switch (mode) {
|
|
case LOW:
|
|
EIC->NMICTRL.bit.NMISENSE = EIC_NMICTRL_NMISENSE_LOW;
|
|
break;
|
|
|
|
case HIGH:
|
|
EIC->NMICTRL.bit.NMISENSE = EIC_NMICTRL_NMISENSE_HIGH;
|
|
break;
|
|
|
|
case CHANGE:
|
|
EIC->NMICTRL.bit.NMISENSE = EIC_NMICTRL_NMISENSE_BOTH;
|
|
break;
|
|
|
|
case FALLING:
|
|
EIC->NMICTRL.bit.NMISENSE = EIC_NMICTRL_NMISENSE_FALL;
|
|
break;
|
|
|
|
case RISING:
|
|
EIC->NMICTRL.bit.NMISENSE = EIC_NMICTRL_NMISENSE_RISE;
|
|
break;
|
|
}
|
|
|
|
// Assign callback to interrupt
|
|
ISRcallback[EXTERNAL_INT_NMI] = callback;
|
|
|
|
} else { // Not NMI, is external interrupt
|
|
|
|
// Assign pin to EIC
|
|
pinPeripheral(pin, PIO_EXTINT);
|
|
|
|
// Store interrupts to service in order of when they were attached
|
|
// to allow for first come first serve handler
|
|
uint32_t current = 0;
|
|
|
|
// Check if we already have this interrupt
|
|
for (current=0; current<nints; current++) {
|
|
if (ISRlist[current] == inMask) {
|
|
break;
|
|
}
|
|
}
|
|
if (current == nints) {
|
|
// Need to make a new entry
|
|
nints++;
|
|
}
|
|
ISRlist[current] = inMask; // List of interrupt in order of when they were attached
|
|
ISRcallback[current] = callback; // List of callback adresses
|
|
|
|
// Look for right CONFIG register to be addressed
|
|
if (in > EXTERNAL_INT_7) {
|
|
config = 1;
|
|
pos = (in - 8) << 2;
|
|
} else {
|
|
config = 0;
|
|
pos = in << 2;
|
|
}
|
|
|
|
#if defined (__SAMD51__)
|
|
EIC->CTRLA.bit.ENABLE = 0;
|
|
while (EIC->SYNCBUSY.bit.ENABLE == 1) { }
|
|
#endif
|
|
|
|
EIC->CONFIG[config].reg &=~ (EIC_CONFIG_SENSE0_Msk << pos); // Reset sense mode, important when changing trigger mode during runtime
|
|
switch (mode)
|
|
{
|
|
case LOW:
|
|
EIC->CONFIG[config].reg |= EIC_CONFIG_SENSE0_LOW_Val << pos;
|
|
break;
|
|
|
|
case HIGH:
|
|
EIC->CONFIG[config].reg |= EIC_CONFIG_SENSE0_HIGH_Val << pos;
|
|
break;
|
|
|
|
case CHANGE:
|
|
EIC->CONFIG[config].reg |= EIC_CONFIG_SENSE0_BOTH_Val << pos;
|
|
break;
|
|
|
|
case FALLING:
|
|
EIC->CONFIG[config].reg |= EIC_CONFIG_SENSE0_FALL_Val << pos;
|
|
break;
|
|
|
|
case RISING:
|
|
EIC->CONFIG[config].reg |= EIC_CONFIG_SENSE0_RISE_Val << pos;
|
|
break;
|
|
}
|
|
}
|
|
// Enable the interrupt
|
|
EIC->INTENSET.reg = EIC_INTENSET_EXTINT(1 << in);
|
|
}
|
|
|
|
#if defined (__SAMD51__)
|
|
EIC->CTRLA.bit.ENABLE = 1;
|
|
while (EIC->SYNCBUSY.bit.ENABLE == 1) { }
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* \brief Turns off the given interrupt.
|
|
*/
|
|
void detachInterrupt(uint32_t pin)
|
|
{
|
|
#if (ARDUINO_SAMD_VARIANT_COMPLIANCE >= 10606)
|
|
EExt_Interrupts in = g_APinDescription[pin].ulExtInt;
|
|
#else
|
|
EExt_Interrupts in = digitalPinToInterrupt(pin);
|
|
#endif
|
|
if (in == NOT_AN_INTERRUPT) return;
|
|
|
|
if(in == EXTERNAL_INT_NMI) {
|
|
EIC->NMICTRL.bit.NMISENSE = 0; // Turn off detection
|
|
} else {
|
|
EIC->INTENCLR.reg = EIC_INTENCLR_EXTINT(1 << in);
|
|
|
|
// Disable wakeup capability on pin during sleep
|
|
#if defined(__SAMD51__)
|
|
//I believe this is done automatically
|
|
#else
|
|
// Disable wakeup capability on pin during sleep
|
|
EIC->WAKEUP.reg &= ~(1 << in);
|
|
#endif
|
|
}
|
|
|
|
// Remove callback from the ISR list
|
|
uint32_t current;
|
|
for (current=0; current<nints; current++) {
|
|
if (ISRlist[current] == (1UL << in)) {
|
|
break;
|
|
}
|
|
}
|
|
if (current == nints) return; // We didn't have it
|
|
|
|
// Shift the reminder down
|
|
for (; current<nints-1; current++) {
|
|
ISRlist[current] = ISRlist[current+1];
|
|
ISRcallback[current] = ISRcallback[current+1];
|
|
}
|
|
nints--;
|
|
}
|
|
|
|
/*
|
|
* External Interrupt Controller NVIC Interrupt Handler
|
|
*/
|
|
#if defined(__SAMD51__)
|
|
void InterruptHandler(uint32_t unused_i)
|
|
{
|
|
(void)unused_i;
|
|
// Calling the routine directly from -here- takes about 1us
|
|
// Depending on where you are in the list it will take longer
|
|
|
|
// Loop over all enabled interrupts in the list
|
|
for (uint32_t i=0; i<nints; i++)
|
|
{
|
|
if ((EIC->INTFLAG.reg & ISRlist[i]) != 0)
|
|
{
|
|
// Call the callback function
|
|
ISRcallback[i]();
|
|
// Clear the interrupt
|
|
EIC->INTFLAG.reg = ISRlist[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void EIC_0_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_0);
|
|
}
|
|
|
|
void EIC_1_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_1);
|
|
}
|
|
|
|
void EIC_2_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_2);
|
|
}
|
|
|
|
void EIC_3_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_3);
|
|
}
|
|
|
|
void EIC_4_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_4);
|
|
}
|
|
|
|
void EIC_5_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_5);
|
|
}
|
|
|
|
void EIC_6_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_6);
|
|
}
|
|
|
|
void EIC_7_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_7);
|
|
}
|
|
|
|
void EIC_8_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_8);
|
|
}
|
|
|
|
void EIC_9_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_9);
|
|
}
|
|
|
|
void EIC_10_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_10);
|
|
}
|
|
|
|
void EIC_11_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_11);
|
|
}
|
|
|
|
void EIC_12_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_12);
|
|
}
|
|
|
|
void EIC_13_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_13);
|
|
}
|
|
|
|
void EIC_14_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_14);
|
|
}
|
|
|
|
void EIC_15_Handler(void)
|
|
{
|
|
InterruptHandler(EXTERNAL_INT_15);
|
|
}
|
|
#else
|
|
|
|
void EIC_Handler(void)
|
|
{
|
|
// Calling the routine directly from -here- takes about 1us
|
|
// Depending on where you are in the list it will take longer
|
|
|
|
// Loop over all enabled interrupts in the list
|
|
for (uint32_t i=0; i<nints; i++)
|
|
{
|
|
if ((EIC->INTFLAG.reg & ISRlist[i]) != 0)
|
|
{
|
|
// Call the callback function
|
|
ISRcallback[i]();
|
|
// Clear the interrupt
|
|
EIC->INTFLAG.reg = ISRlist[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* NMI Interrupt Handler
|
|
*/
|
|
void NMI_Handler(void)
|
|
{
|
|
if (ISRcallback[EXTERNAL_INT_NMI]) ISRcallback[EXTERNAL_INT_NMI]();
|
|
EIC->NMIFLAG.bit.NMI = 1; // Clear interrupt
|
|
}
|
|
#endif
|