ATLEDGE-84 - Interrupt framework

Arduino functions implemented:
  * attachInterrupt(Arduino_Pin, handler, mode):
     * it works for all Arduino GPIO (IO0 - IO19)
     * CHANGE mode is supported only for SoC GPIOs (hardware limitation:
       SS doesn't support interrupt generation on both rising and falling
       edges.)
  * detachInterrupt()
  * interrupts()
  * noInterrupts()

Above functions behaviour is according to Arduino website description.
For details please see below references:
   http://www.arduino.cc/en/Reference/AttachInterrupt
   http://www.arduino.cc/en/Reference/DetachInterrupt
   http://www.arduino.cc/en/Reference/Interrupts
   http://www.arduino.cc/en/Reference/NoInterrupts

This implementation uses ss_gpio and soc_gpio drivers from thunderdome.

Signed-off-by: Bogdan Pricop <bogdan.pricop@emutex.com>

Author: David Hunt

cores/arduino/WInterrupts.c

@@ -0,0 +1,138 @@
+/*
+ Copyright (c) 2015 Intel Corporation.  All right reserved.
+
+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 Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+ */
+
+#include "WInterrupts.h"
+#include "wiring_digital.h"
+#include "gpio.h"
+#include "interrupt.h"
+
+/* Saves the interrupt state from STATUS32 register before disabling the
+ * interrupts */
+static uint32_t irq_flags;
+/* Works kinda like a semaphore: make sure one has called noInterrupts() before
+ * interrupts() */
+static uint32_t noInterrupts_executed;
+
+void attachInterrupt(uint32_t pin, void(*callback)(void), uint32_t mode)
+{
+    if (pin >= NUM_DIGITAL_PINS) {
+#ifdef DEBUG
+        __asm__("flag 0x01") ; /* Halt the CPU */
+#endif
+        return;
+    }
+    PinDescription *p = &g_APinDescription[pin];
+    gpio_cfg_data_t config;
+    DRIVER_API_RC ret;
+
+    /* First de-config the GPIO in case it was previously configured as IRQ */
+    if (p->ulGPIOType == SS_GPIO)
+        ret = ss_gpio_deconfig(p->ulGPIOPort, p->ulGPIOId);
+    else
+        ret = soc_gpio_deconfig(p->ulGPIOPort, p->ulGPIOId);
+#ifdef DEBUG
+    if (ret != DRV_RC_OK)
+        __asm__("flag 0x01") ; /* Halt the CPU */
+#endif
+
+    switch (mode) {
+    case LOW:
+        config.int_type = LEVEL;
+        config.int_polarity = ACTIVE_LOW;
+        break;
+    case HIGH:
+        config.int_type = LEVEL;
+        config.int_polarity = ACTIVE_HIGH;
+	break;
+    case RISING:
+        config.int_type = EDGE;
+        config.int_polarity = ACTIVE_HIGH;
+	break;
+    case FALLING:
+        config.int_type = EDGE;
+        config.int_polarity = ACTIVE_LOW;
+	break;
+    case CHANGE:
+	if (p->ulGPIOType == SOC_GPIO) {
+            config.int_type = DOUBLE_EDGE;
+            config.int_polarity = ACTIVE_LOW;
+	} else { /* ARC GPIOs don't support both edges IRQ */
+            config.int_type = EDGE;
+            config.int_polarity = ACTIVE_LOW;
+	}
+	break;
+    default:
+#ifdef DEBUG
+	__asm__("flag 0x01"); /* Halt the CPU */
+#endif
+	return;
+    }
+    config.gpio_type = GPIO_INTERRUPT;
+    config.int_debounce = DEBOUNCE_ON;
+    config.int_ls_sync = LS_SYNC_OFF;
+    config.gpio_cb = callback;
+
+    if (p->ulGPIOType == SS_GPIO)
+        ret = ss_gpio_set_config(p->ulGPIOPort, p->ulGPIOId, &config);
+    else
+	ret = soc_gpio_set_config(p->ulGPIOPort, p->ulGPIOId, &config);
+#ifdef DEBUG
+    if (ret != DRV_RC_OK)
+        __asm__("flag 0x01") ; /* Halt the CPU */
+#endif
+}
+
+
+void detachInterrupt(uint32_t pin)
+{
+    if (pin >= NUM_DIGITAL_PINS) {
+#ifdef DEBUG
+        __asm__("flag 0x01") ; /* Halt the CPU */
+#endif
+        return;
+    }
+    PinDescription *p = &g_APinDescription[pin];
+    DRIVER_API_RC ret;
+
+    if (p->ulGPIOType == SS_GPIO)
+        ret = ss_gpio_deconfig(p->ulGPIOPort, p->ulGPIOId);
+    else
+        ret = soc_gpio_deconfig(p->ulGPIOPort, p->ulGPIOId);
+#ifdef DEBUG
+    if (ret != DRV_RC_OK)
+        __asm__("flag 0x01") ; /* Halt the CPU */
+#endif
+}
+
+
+void interrupts(void)
+{
+    if (noInterrupts_executed) {
+        noInterrupts_executed = 0;
+	interrupt_unlock(irq_flags);
+    }
+}
+
+void noInterrupts(void)
+{
+    if (!noInterrupts_executed) {
+        noInterrupts_executed = 1;
+        irq_flags = interrupt_lock();
+    }
+}

cores/arduino/WInterrupts.h

@@ -29,6 +29,10 @@ void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode);
 
 void detachInterrupt(uint32_t pin);
 
+void interrupts(void);
+
+void noInterrupts(void);
+
 #ifdef __cplusplus
 }
 #endif

cores/arduino/wiring.c

@@ -25,6 +25,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #include "conf.h"
 #include "interrupt.h"
 #include "aux_regs.h"
+#include "board.h"
 
 #define FREQ_MHZ    ((ARCV2_TIMER0_CLOCK_FREQ)/1000000)
 
@@ -37,8 +38,8 @@ void delay(uint32_t msec)
 
     while(timer0_overflows < no_of_irqs){
         yield();
-      /* Enter sleep and enable interrupts and sets interrupts threshold to 3 */
-        __asm__ volatile ("sleep 0x13");
+      /* Enable interrupts, sets interrupts threshold to 2 and go to sleep. */
+	__asm__ volatile ("sleep %0" :: "i" (INTERRUPT_ENABLE | INTERRUPT_THRESHOLD));
     }
    /* For the last fraction of millisecond don't go to sleep - you'll wake up
     * too late - just spin */

cores/arduino/wiring_constants.h

@@ -77,9 +77,6 @@ enum BitOrder {
 #define degrees(rad) ((rad)*RAD_TO_DEG)
 #define sq(x) ((x)*(x))
 
-#define interrupts() __enable_irq()
-#define noInterrupts() __disable_irq()
-
 #define lowByte(w) ((uint8_t) ((w) & 0xff))
 #define highByte(w) ((uint8_t) ((w) >> 8))
 

system/libarc32_edu/bootcode/conf.h

@@ -21,7 +21,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #define _ARCV2_CONF__H_
 
 
-#define _WRS_CONFIG_NUM_IRQS	64
+#define SS_NUM_IRQS		53
+#define SS_NUM_EXCEPTIONS	16
 
 #define _RAM_END		(0xa8010000 + 0x4000)
 

system/libarc32_edu/bootcode/interrupt.c

@@ -19,17 +19,16 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #include "conf.h"
 #include "aux_regs.h"
 #include "interrupt.h"
+#include "board.h"
 
-#define INTERRUPT_ENABLE    (1 << 4)
-#define INTERRUPT_THRESHOLD (3)
 
 struct _IsrTableEntry
 {
     void *arg;
     void (*isr)(void);
 };
 
-struct _IsrTableEntry __attribute__((section(".data"))) _IsrTable[_WRS_CONFIG_NUM_IRQS];
+struct _IsrTableEntry __attribute__((section(".data"))) _IsrTable[SS_NUM_IRQS];
 
 static void _dummy_isr(void)
 {
@@ -46,16 +45,16 @@ static void _dummy_isr(void)
 __attribute__ ((interrupt ("ilink")))
 void _do_isr(void)
 {
-    unsigned int irq_cause = aux_reg_read(ARC_V2_ICAUSE) - 16;
+    unsigned int irq_cause = aux_reg_read(ARC_V2_ICAUSE) - SS_NUM_EXCEPTIONS;
     if (_IsrTable[irq_cause].isr != 0x00)
         _IsrTable[irq_cause].isr();
-    else 
-	_dummy_isr();    
+    else
+	_dummy_isr();
 }
 
 void interrupt_connect(unsigned int irq, void (*isr)(void), void *arg)
 {
-    int index = irq - 16;
+    int index = irq - SS_NUM_EXCEPTIONS;
     unsigned int flags = interrupt_lock();
     _IsrTable[index].isr = isr;
     _IsrTable[index].arg = arg;
@@ -64,15 +63,14 @@ void interrupt_connect(unsigned int irq, void (*isr)(void), void *arg)
 
 void interrupt_disconnect(unsigned int irq)
 {
-    int index = irq - 16;
+    int index = irq - SS_NUM_EXCEPTIONS;
     _IsrTable[index].isr = _dummy_isr;
 }
 
 void interrupt_enable(unsigned int irq)
 {
     unsigned int flags = interrupt_lock();
     aux_reg_write (ARC_V2_IRQ_SELECT, irq);
-    aux_reg_write (ARC_V2_IRQ_PRIORITY, 1);
     aux_reg_write (ARC_V2_IRQ_TRIGGER, ARC_V2_INT_LEVEL);
     aux_reg_write (ARC_V2_IRQ_ENABLE, ARC_V2_INT_ENABLE);
     interrupt_unlock(flags);
@@ -97,17 +95,17 @@ void interrupt_priority_set (int irq, unsigned char priority)
 void interrupt_unit_device_init(void)
 {
     int irq_index;
-    for (irq_index = 16; irq_index < 256; irq_index++)
+    int min_irq_no = VECTOR_FROM_IRQ(0);
+    int max_irq_no = VECTOR_FROM_IRQ(SS_NUM_IRQS);
+    for (irq_index = min_irq_no; irq_index < max_irq_no; irq_index++)
     {
         aux_reg_write(ARC_V2_IRQ_SELECT, irq_index);
         aux_reg_write(ARC_V2_IRQ_PRIORITY, 1);
         aux_reg_write(ARC_V2_IRQ_ENABLE, ARC_V2_INT_DISABLE);
         aux_reg_write(ARC_V2_IRQ_TRIGGER, ARC_V2_INT_LEVEL);
     }
-
     /* Setup automatic (hardware) context saving feature */
-    aux_reg_write(ARC_V2_AUX_IRQ_CTRL,AUX_IRQ_CTRL_SAVE_ALL); 
-
+    aux_reg_write(ARC_V2_AUX_IRQ_CTRL, AUX_IRQ_CTRL_SAVE_ALL);
     /* Configure the interrupt priority threshold and enable interrupts */
     __builtin_arc_seti(INTERRUPT_ENABLE | INTERRUPT_THRESHOLD);
 }

system/libarc32_edu/bootcode/interrupt.h

@@ -19,6 +19,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #ifndef __INTERRUPT_H__
 #define __INTERRUPT_H__
 
+#define INTERRUPT_ENABLE    (1 << 4)
+ /* According to IRQ_BUILD register the ARC core has only 2 interrupt priority
+  * levels (0 and 1).
+  * */
+#define INTERRUPT_THRESHOLD (2)
+
+
 extern void interrupt_connect(unsigned int irq, void (*isr)(void), void *arg);
 extern void interrupt_disconnect(unsigned int irq);
 extern void interrupt_enable(unsigned int irq);

system/libarc32_edu/common/board.h

@@ -40,6 +40,7 @@ This header file is used to specify and describe board-level aspects for the
 #define _BOARD__H_
 
 #include <misc/util.h>
+#include <stdint.h>
 
 /* default system clock */
 

system/libarc32_edu/drivers/gpio.h

@@ -27,7 +27,7 @@
 
 #include "data_type.h"
 
-typedef void (*gpio_callback_fn)( uint32_t , void*);
+typedef void (*gpio_callback_fn)(void);
 
 /*!
  * GPIO types
@@ -81,7 +81,6 @@ typedef struct gpio_cfg_data {
     INT_DEBOUNCE      int_debounce;      /*!< GPIO debounce configuration */
     INT_LS_SYNC       int_ls_sync;       /*!< GPIO ls sync configuration */
     gpio_callback_fn  gpio_cb;           /*!< Callback function called when an interrupt is triggered on this pin */
-    void             *gpio_cb_arg;       /*!< Data passed as an argument for the callback function */
 } gpio_cfg_data_t;
 
 /*!
@@ -96,7 +95,6 @@ typedef struct gpio_port_cfg_data {
     uint32_t           int_debounce;     /*!< GPIO debounce configuration (0=OFF, 1=ON) */
     uint32_t           int_ls_sync;      /*!< GPIO ls sync configuration (0=OFF, 1=ON) */
     gpio_callback_fn   gpio_cb[32];      /*!< Callback function called when an interrupt is triggered on this pin */
-    void              *gpio_cb_arg[32];  /*!< Data passed as an argument for the callback function */
 } gpio_port_cfg_data_t;
 
 #endif  /* GPIO_IFACE_H_ */