Time related Arduino core functions: Re-write

* Change Timer0 configuration according to Alexandre D'Alton suggestion:
  use it as a free-run timer which delivers interrupts every 0xFFFFFFFF
  clock ticks and its ISR increments a global variable; in this way a
  64-bit virtual RTC is created. The downside is the delay() function
  cannot take advantage of ARc's power management features anymore.

* Change delay() implementation to make use of 64-bit time-stamp.

* Change delayMicroseconds to use Timer0 counter value and unsigned
  arithmetic's features to handle the overflow case.
  The credit goes to Dan O'Dononvan.

* Add function to get an atomic 64-bit time-stamp.

* Change millis() and micros() implementation to use the 64-bit time-stamp.

Signed-off-by: Bogdan Pricop <[email protected]>

Author: Bogdan Pricop

Diff for: cores/arduino/wiring.c

@@ -20,7 +20,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #include "Arduino.h"
 
 #include "wiring.h"
-#include "arcv2_timer0.h"
 #include "data_type.h"
 #include "conf.h"
 #include "interrupt.h"
@@ -29,94 +28,55 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 #define FREQ_MHZ    ((ARCV2_TIMER0_CLOCK_FREQ)/1000000)
 
-void delay(uint32_t msec)
-{
-    uint32_t no_of_irqs = timer0_overflows + msec;
-    uint32_t microseconds = arcv2_timer0_count_get();
-
-    while(timer0_overflows < no_of_irqs){
-        yield();
-      /* Go to sleep and wait to be awaken by Timer0 (or an external) 
-       * interrupt. */
-	__asm__ volatile ("sleep");
-    }
-   /* For the last fraction of millisecond don't go to sleep - you'll wake up
-    * too late - just spin */
-    while ((arcv2_timer0_count_get() < microseconds) &&
-		    (timer0_overflows ==  no_of_irqs));
-}
-
-
-uint32_t millis(void)
-{
-    return timer0_overflows;
-}
-
 
-uint32_t micros(void)
+static uint64_t getTimeStampClks(void)
 {
-   __asm__ __volatile__ (
+    __asm__ volatile (
    /* Disable interrupts - we don't want to be disturbed */
    "clri r2			    \n\t"
-   /* Load in r3 value of timer0_overflows */
-   "ld r3, %0			    \n\t"
-   /* Use only the least-significant 22 bits of timer0_overflows */
-   "and r3, r3, 0x3FFFFF	    \n\t"
+   /* Load in r1 value of timer0_overflows */
+   "ld r1, %0			    \n\t"
    /* Read COUNT0 register */
    "lr r0, [0x21]		    \n\t"
-   /* Read CONTORL0 register */
-   "lr r1, [0x22]		    \n\t"
-   /* If CONTROL0.IP is set COUNT0 reached LIMIT0 => r0 value might not be
+   /* Read CONTROL0 register */
+   "lr r3, [0x22]		    \n\t"
+   /* If CONTROL0.IP is set COUNT0 reached LIMIT0 => r1 value might not be
     * accurate => read COUNT0 again */
-   "bbit0.nt r1, 3, continue	    \n\t"
+   "bbit0.nt r3, 3, end	    \n\t"
    /* Read COUNT0 again*/
    "lr r0, [0x21]		    \n\t"
    /* Timer0 overflowed => timer0_overflows++ */
-   "add r3, r3, 1		    \n\t"
+   "add r1, r1, 1		    \n\t"
    /***/
-   "continue:			    \n\t"
-	   /* Compute microseconds time-stamp */
-   /* Transform milliseconds in microseconds */
-   "mpy r3, r3, 1000		    \n\t"
-   /* Transform ticks in microseconds */
-   "div r0, r0, 32		    \n\t"
-   /* Store the final result in R0 register.
-    * The function returns the result in R0 register. */
-   "add r0, r0, r3		    \n\t"
+   "end:			    \n\t"
    "seti r2			    \n\t"
-   :	    /* Output parameters and their constraints */
-   : "m"(timer0_overflows)   /* Input parameters and their constraints */
-   : "r0", "r1", "r2", "r3" /* Killed registers */
-			);
+   : /* Output parameters and their constraints */
+   :  "m"(timer0_overflows)   /* Input parameters and their constraints */
+   :  "r0", "r1", "r2", "r3" /* Killed registers */
+   );
 }
 
-void delayMicroseconds(uint32_t usec)
+
+void delay(uint32_t msec)
 {
-    /* Function parameter is stored in R0 register */
-    __asm__ __volatile__ (
-    "mpy.f r0, r0, 32	    \n\t" /* delay_ticks = delay_usec * 32 */
-    "bz.d _end		    \n\t" /* if usec == 0 goto end */
-    /* Subtract the function call overhead and the time spent by the previous
-     * instructions of the function.
-     * T function_call = 4 clks
-     * T mpy + T bz = 3 + 3 = 6 clks
-     * T exit_function + loop_precision ~ 5 clks
-     * The above described timings were computed using a scope and infinite
-     * loops in the code, meaning the instructions were most likely executed
-     * from ICACHE. 
-     * */
-    "sub r0, r0, 15	    \n\t"
-    /* Minimum value of r0 = 32 => the above subtraction cannot overflow */
-    "_repeat:		    \n\t"
-    /* T sub.f = 1 clk; T bnc.nd = 3 clks */
-    "sub.f r0, r0, 4	    \n\t"
-    /* Repeat above subtraction until carry flag is set */
-    "bnc.nd _repeat	    \n\t"
-    "_end:		    \n\t"
-    : /* output parameters of ASM instructions */
-    : /* input parameters */
-    : "r0" /* registers killed by above ASM instructions. */
-    );
+    uint64_t initial_timestamp = getTimeStampClks();
+    uint64_t delay_clks = msec * FREQ_MHZ * 1000;
+
+    while (getTimeStampClks() - initial_timestamp < delay_clks) {
+        yield();
+    }
 }
 
 
+uint64_t millis(void)
+{
+    uint64_t timestamp = getTimeStampClks();
+    return (uint64_t)(timestamp / (FREQ_MHZ * 1000));
+}
+
+uint64_t micros(void)
+{
+    uint64_t timestamp = getTimeStampClks();
+    /* Divide by FREQ_MHZ and return */
+    return (timestamp >> 5);
+}

Diff for: cores/arduino/wiring.h

@@ -1,6 +1,6 @@
 /*
   Copyright (c) 2011 Arduino.  All right reserved.
-  Copyright (c) 2013 by Paul Stoffregen <[email protected]> (delayMicroseconds)
+  Copyright (c) 2015 Intel Corporation.  All right reserved (delayMicroseconds).
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -26,6 +26,8 @@ extern "C" {
 
 #include <stdint.h>
 #include "wiring_constants.h"
+#include "arcv2_timer0.h"
+
 
 /**
  *
@@ -34,50 +36,68 @@ extern void initVariant( void ) ;
 extern void init( void ) ;
 
 /**
- * \brief Returns the number of milliseconds since the Arduino board began running the current program.
+ * \brief Returns the number of milliseconds since the Intel EDU board began
+ * running the current program.
  *
- * This number will overflow (go back to zero), after approximately 50 days.
+ * This number will practically never overflow (go back to zero).
  *
- * \return Number of milliseconds since the program started (uint32_t)
+ * \return Number of milliseconds since the program started (uint64_t).
  */
-extern uint32_t millis( void ) ;
+extern uint64_t millis( void ) ;
 
 /**
- * \brief Returns the number of microseconds since the Arduino board began running the current program.
+ * \brief Returns the number of microseconds since the Intel EDU board began
+ * running the current program.
  *
- * This number will overflow (go back to zero), after approximately 70 minutes. On 16 MHz Arduino boards
- * (e.g. Duemilanove and Nano), this function has a resolution of four microseconds (i.e. the value returned is
- * always a multiple of four). On 8 MHz Arduino boards (e.g. the LilyPad), this function has a resolution
- * of eight microseconds.
+ * This number will practically never overflow (go back to zero).
+ * It will overflow after more than 18000 years.
+ * This function has a resolution of 2 microseconds.
  *
- * \note There are 1,000 microseconds in a millisecond and 1,000,000 microseconds in a second.
+ * \note There are 1,000 microseconds in a millisecond and 1,000,000
+ * microseconds in a second.
  */
-extern uint32_t micros( void ) ;
+extern uint64_t micros( void ) ;
 
 /**
- * \brief Pauses the program for the amount of time (in miliseconds) specified as parameter.
- * (There are 1000 milliseconds in a second.)
+ * \brief Pauses the program for the amount of time (in milliseconds) specified
+ *  as parameter.
+ *
+ *  This function relies on Timer0 interrupts, therefore it shouldn't be called
+ *  from a context with interrupts disabled.
+ *  It doesn't use CPU's power management features.
  *
  * \param dwMs the number of milliseconds to pause (uint32_t)
+ *
+ * \note There are 1000 milliseconds in a second.
  */
 extern void delay( uint32_t dwMs ) ;
 
 
 /**
  * \brief Pauses the program for the amount of time (in microseconds) specified
  *  as parameter.
- *  Theoretically it works pretty accurate in the range 1 microsecond and up.
- *  The precision should be +- 0.15 microseconds.
- *  The above statements are based on measurements done when the function was
- *  most likely executed from cache.
- *  The accuracy for values <= 4 microseconds is impacted by cache miss, Timer
- *  or external interrupts.
- *  It doesn't disable the interrupts.
+ *
+ *  The precision is +- 0.5 microsecond.
+ *  It doesn't disable the interrupts and it doesn't rely on interrupts,
+ *  meaning this function works reliable even if the interrupts are disabled.
  *  It doesn't use CPU's power management features.
  *
- * \param usec the number of microseconds to pause (uint32_t)
+ * \param dwUs the number of microseconds to pause (uint32_t)
+ *	Accepted range: from 1 microsecond up to 0x07FFFFFF microseconds.
+ *	If dwUs > above specifies threshold, the delay overflows.
+ *	E.g. If dwUs = 0x08000000 (0x07FFFFFF + 1), it actually means dwUs = 0
  */
-void delayMicroseconds(uint32_t dwMs);
+static inline __attribute__ ((always_inline))
+void delayMicroseconds(uint32_t dwUs)
+{
+    if (0 == dwUs) return;
+    uint32_t init_count = arcv2_timer0_count_get();
+    /* Multiply microseconds with FREQ_MHZ to transform them in clocks */
+    uint32_t clocks = dwUs << 5;
+
+    while (arcv2_timer0_count_get() - init_count < clocks);
+}
+
 
 #ifdef __cplusplus
 }

Diff for: system/libarc32_edu/common/arcv2_timer0.h

@@ -42,12 +42,9 @@ extern "C" {
 #endif
 
 
-/* Maxim number of Timer0 overflows used to compute micros()
- * It overflows at 70 minutes = 70*60 sec = 70*60*1000 millis = 4200000 */
-#define MAX_OVERFLOWS_US    4200000UL
-
 /* Increments every Timer0 overflow.
- * Timer0 is configured to overflow and fire an IRQ every 1 millisecond
+ * Timer0 is configured as a free-run timer; it overflows every 0xFFFFFFFF
+ * clocks.
  */
 extern uint32_t volatile timer0_overflows;
 
@@ -56,8 +53,8 @@ extern uint32_t volatile timer0_overflows;
 *
 * timer0_driver_init - initialize and enable the system clock
 *
-* This routine is used to program the ARCv2 timer to deliver interrupts at the
-* 1 millisecond rate specified via the ONE_MILLISECOND macro.
+* This routine is used to program the ARCv2 Timer as a free-run timer.
+* It delivers interrupts every 0xFFFFFFFF clocks.
 *
 * RETURNS: N/A
 */

Diff for: system/libarc32_edu/drivers/arcv2_timer0.c

@@ -45,10 +45,6 @@ The ARCv2 processor timer provides a 32-bit incrementing, wrap-to-zero counter.
 #include "conf.h"
 #include "interrupt.h"
 
-#define ONE_MILLISECOND	    ARCV2_TIMER0_CLOCK_FREQ/1000
-
-
-/* globals */
 
 uint32_t volatile timer0_overflows = 0x00;
 
@@ -83,18 +79,19 @@ void arcv2_timer0_enable(uint32_t count)
 
 /*******************************************************************************
 *
-* _arcv2_timer0_int_handler - system clock periodic tick handler
+* _arcv2_timer0_int_handler - Timer0 ISR
 *
-* This routine handles the system clock periodic tick interrupt.
-* It increments number of milliseconds since sketch begun.
+* This routine handles the overflows of 32-bit free-run Timer0.
+* In this way a virtually 64-bit RTC is created:
+*   timer0_overflows = high double word of virtual RTC.
+*   COUNT0 of Tiemr0 = low double word of virtual RTC.
 *
 * RETURNS: N/A
 *
 * \NOMANUAL
 */
 void _arcv2_timer0_int_handler(void)
 {
-
     /* clear the interrupt (by writing 0 to IP bit of the control register) */
     aux_reg_write(ARC_V2_TMR0_CONTROL,
                   ARC_V2_TMR_CTRL_NH | ARC_V2_TMR_CTRL_IE);
@@ -106,17 +103,18 @@ void _arcv2_timer0_int_handler(void)
 *
 * timer0_driver_init - initialize and enable the system clock
 *
-* This routine is used to program the ARCv2 timer to deliver interrupts at the
-* 1 millisecond rate specified via the ONE_MILLISECOND macro.
+* This routine is used to the ARCv2 Timer as a free-run timer.
+* It delivers interrupts evry 0xFFFFFFFF clocks.
 *
 * RETURNS: N/A
 */
 void timer0_driver_init(void)
 {
     /* connect specified routine/parameter to the timer 0 interrupt vector */
     interrupt_connect(ARCV2_IRQ_TIMER0, _arcv2_timer0_int_handler, 0);
-    /* configure timer to overflow and fire an IRQ every 1 ms */
-    arcv2_timer0_enable(ONE_MILLISECOND);
+    /* Enable Timer0 as a free-run timer. */
+    arcv2_timer0_enable(0xFFFFFFFF);
+
     /* Everything has been configured. It is now safe to enable the interrupt */
     interrupt_enable(ARCV2_IRQ_TIMER0);
 }