diff --git a/Demo/CORTEX_A2F200_IAR_and_Keil/RTOSDemo_IAR.ewp b/Demo/CORTEX_A2F200_IAR_and_Keil/RTOSDemo_IAR.ewp
index 25a9ca018..75afbc5e4 100644
--- a/Demo/CORTEX_A2F200_IAR_and_Keil/RTOSDemo_IAR.ewp
+++ b/Demo/CORTEX_A2F200_IAR_and_Keil/RTOSDemo_IAR.ewp
@@ -2019,6 +2019,7 @@
$PROJ_DIR$/WebServer
$PROJ_DIR$/../Common/ethernet/FreeTCPIP/apps/httpd
$PROJ_DIR$/../Common/ethernet/FreeTCPIP
+ $PROJ_DIR$/../Common/ethernet/FreeTCPIP/net
$PROJ_DIR$/../Common/include
$PROJ_DIR$/MicroSemi_Code/drivers/I2C
$PROJ_DIR$/MicroSemi_Code/drivers/mss_ethernet_mac
diff --git a/Demo/CORTEX_A2F200_SoftConsole/MicroSemi_Code/drivers/mss_timer/mss_timer.h b/Demo/CORTEX_A2F200_SoftConsole/MicroSemi_Code/drivers/mss_timer/mss_timer.h
new file mode 100644
index 000000000..d83519d54
--- /dev/null
+++ b/Demo/CORTEX_A2F200_SoftConsole/MicroSemi_Code/drivers/mss_timer/mss_timer.h
@@ -0,0 +1,598 @@
+/*******************************************************************************
+ * (c) Copyright 2009 Actel Corporation. All rights reserved.
+ *
+ * SmartFusion microcontroller subsystem (MSS) timer driver API.
+ *
+ * SVN $Revision: 2661 $
+ * SVN $Date: 2010-04-19 17:14:26 +0100 (Mon, 19 Apr 2010) $
+ */
+/*=========================================================================*//**
+ @mainpage SmartFusion MSS Timer Bare Metal Driver.
+
+ @section intro_sec Introduction
+ The SmartFusion Microcontroller Subsystem (MSS) includes a timer hardware
+ block which can be used as two independent 32-bits timers or as a single
+ 64-bits timer in periodic or one-shot mode.
+
+ This driver provides a set of functions for controlling the MSS timer as part
+ of a bare metal system where no operating system is available. These drivers
+ can be adapted for use as part of an operating system but the implementation
+ of the adaptation layer between this driver and the operating system's driver
+ model is outside the scope of this driver.
+
+ @section theory_op Theory of Operation
+ The MSS Timer driver uses the SmartFusion "Cortex Microcontroler Software
+ Interface Standard - Peripheral Access Layer" (CMSIS-PAL) to access hadware
+ registers. You must ensure that the SmartFusion CMSIS-PAL is either included
+ in the software toolchain used to build your project or is included in your
+ project. The most up-to-date SmartFusion CMSIS-PAL files can be obtained using
+ the Actel Firmware Catalog.
+ The SmartFusion MSS Timer can be used in one of two mutually exclusive modes;
+ either as a single 64-bits timer or as two independent 32-bits timers. The MSS
+ Timer can be used in either periodic mode or one-shot mode. A timer configured
+ for periodic mode operations will generate an interrupt and reload its
+ down-counter when it reaches 0. The timer will then continue decrementing from
+ its reload value without waiting for the interrupt to be cleared. A timer
+ configured for one-shot mode will only generate an interrupt once when its
+ down-counter reaches 0. It must be explitcitly reloaded to start decrementing
+ again.
+
+ The MSS Timer driver functions are grouped into the following categories:
+ - Initialization and Configuration
+ - Timer control
+ - Interrupt control
+
+ The MSS Timer driver provides three initialization functions:
+ - MSS_TIM1_init()
+ - MSS_TIM2_init()
+ - MSS_TIM64_init()
+ The MSS Timer driver is initialized through calls to these functions and at
+ least one of them must be called before any other MSS Timer driver functions
+ can be called.
+ You should only use the MSS_TIM1_init() and MSS_TIM2_init() functions if you
+ intend to use the timer in 32-bits mode. Use the MSS_TIM64_init() function is
+ you intend to use the MSS Timer as a single 64-bits timer. The initialization
+ functions take a single parameter specifying the operating mode of the timer
+ being initialized.
+
+ Once initialized a timer can be controlled using the following functions:
+ - MSS_TIM1_load_immediate()
+ - MSS_TIM1_load_background()
+ - MSS_TIM1_get_current_value()
+ - MSS_TIM1_start()
+ - MSS_TIM1_stop()
+ - MSS_TIM2_load_immediate()
+ - MSS_TIM2_load_background()
+ - MSS_TIM2_get_current_value()
+ - MSS_TIM2_start()
+ - MSS_TIM2_stop()
+ - MSS_TIM64_load_immediate()
+ - MSS_TIM64_load_background()
+ - MSS_TIM64_get_current_value()
+ - MSS_TIM64_start()
+ - MSS_TIM64_stop()
+
+ Timer interrupts are controlled using the following functions:
+ - MSS_TIM1_enable_irq()
+ - MSS_TIM1_disable_irq()
+ - MSS_TIM1_clear_irq()
+ - MSS_TIM2_enable_irq()
+ - MSS_TIM2_disable_irq()
+ - MSS_TIM2_clear_irq()
+ - MSS_TIM64_enable_irq()
+ - MSS_TIM64_disable_irq()
+ - MSS_TIM64_clear_irq()
+
+ The function prototypes for the timer interrupt handlers are:
+ - void Timer1_IRQHandler( void )
+ - void Timer2_IRQHandler( void )
+ Entries for these interrupt handlers are provided in the SmartFusion CMSIS-PAL
+ vector table. To add a Timer 1 interrupt handler, you must implement a
+ Timer1_IRQHandler( ) function as part of your application code. To add a
+ Timer 2 interrupt handler, you must implement a Timer2_IRQHandler( ) function
+ as part of your application code. When using the MSS Timer as a 64-bit timer,
+ you must implement a Timer1_IRQHandler( ) function as part of your
+ application code. The Timer 2 interrupt is not used when the MSS Timer is
+ configured as a 64-bit timer.
+
+ *//*=========================================================================*/
+#ifndef MSS_TIMER_H_
+#define MSS_TIMER_H_
+
+
+#include "../../CMSIS/a2fxxxm3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*-------------------------------------------------------------------------*//**
+ * Timer mode selection. This enumeration is used to select between the two
+ * possible timer modes of operation: periodic and one-shot mode. It is used as
+ * an argument to the MSS_TIM1_init(), MSS_TIM2_init() and MSS_TIM64_init()
+ * functions.
+ * MSS_TIMER_PERIODIC_MODE:
+ * In periodic mode the timer generates interrupts at constant intervals. On
+ * reaching zero, the timer's counter is reloaded with a value held in a
+ * register and begins counting down again.
+ * MSS_TIMER_ONE_SHOT_MODE:
+ * The timer generates a single interrupt in this mode. On reaching zero, the
+ * timer's counter halts until reprogrammed by the user.
+ */
+typedef enum __mss_timer_mode_t
+{
+ MSS_TIMER_PERIODIC_MODE = 0,
+ MSS_TIMER_ONE_SHOT_MODE = 1
+} mss_timer_mode_t;
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_init() function initializes the SmartFusion MSS Timer block for
+ use as a 32-bit timer and selects the operating mode for Timer 1. This function
+ takes the MSS Timer block out of reset in case this hasn’t been done already,
+ stops Timer 1, disables its interrupt and sets the Timer 1 operating mode.
+ Please note that the SmartFusion MSS Timer block cannot be used both as a
+ 64-bit and 32-bit timer. Calling MSS_TIM1_init() will overwrite any previous
+ configuration of the MSS Timer as a 64-bit timer.
+
+
+ @param mode
+ The mode parameter specifies whether the timer will operate in periodic or
+ one-shot mode. Allowed values for this parameter are:
+ - MSS_TIMER_PERIODIC_MODE
+ - MSS_TIMER_ONE_SHOT_MODE
+ */
+static __INLINE void MSS_TIM1_init( mss_timer_mode_t mode )
+{
+ NVIC_DisableIRQ( Timer1_IRQn ); /* Disable timer 1 irq in the Cortex-M3 NVIC */
+
+ SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */
+
+ TIMER->TIM64_MODE = 0U; /* switch to 32 bits mode */
+
+ TIMER_BITBAND->TIM1ENABLE = 0U; /* disable timer */
+ TIMER_BITBAND->TIM1INTEN = 0U; /* disable interrupt */
+ TIMER_BITBAND->TIM1MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */
+
+ TIMER->TIM1_RIS = 1U; /* clear timer 1 interrupt */
+ NVIC_ClearPendingIRQ( Timer1_IRQn ); /* clear timer 1 interrupt within NVIC */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_start() function enables Timer 1 and starts its down-counter
+ decrementing from the load_value specified in previous calls to the
+ MSS_TIM1_load_immediate() or MSS_TIM1_load_background() functions.
+ */
+static __INLINE void MSS_TIM1_start( void )
+{
+ TIMER_BITBAND->TIM1ENABLE = 1U; /* enable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_stop() function disables Timer 1 and stops its down-counter
+ decrementing.
+ */
+static __INLINE void MSS_TIM1_stop( void )
+{
+ TIMER_BITBAND->TIM1ENABLE = 0U; /* disable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_get_current_value() returns the current value of the Timer 1
+ down-counter.
+
+ @return
+ This function returns the 32-bits current value of the Timer 1 down-counter.
+ */
+static __INLINE uint32_t MSS_TIM1_get_current_value( void )
+{
+ return TIMER->TIM1_VAL;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_load_immediate() function loads the value passed by the
+ load_value parameter into the Timer 1 down-counter. The counter will decrement
+ immediately from this value once Timer 1 is enabled. The MSS Timer will
+ generate an interrupt when the counter reaches zero if Timer 1 interrupts are
+ enabled. This function is intended to be used when Timer 1 is configured for
+ one-shot mode to time a single delay.
+
+ @param load_value
+ The load_value parameter specifies the value from which the Timer 1 down-counter
+ will start decrementing from.
+ */
+static __INLINE void MSS_TIM1_load_immediate( uint32_t load_value )
+{
+ TIMER->TIM1_LOADVAL = load_value;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_load_background() function is used to specify the value that will
+ be reloaded into the Timer 1 down-counter the next time the counter reaches
+ zero. This function is typically used when Timer 1 is configured for periodic
+ mode operation to select or change the delay period between the interrupts
+ generated by Timer 1.
+
+ @param load_value
+ The load_value parameter specifies the value that will be loaded into the
+ Timer 1 down-counter the next time the down-counter reaches zero. The Timer
+ 1 down-counter will start decrementing from this value after the current
+ count expires.
+ */
+static __INLINE void MSS_TIM1_load_background( uint32_t load_value )
+{
+ TIMER->TIM1_BGLOADVAL = load_value;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_enable_irq() function is used to enable interrupt generation for
+ Timer 1. This function also enables the interrupt in the Cortex-M3 interrupt
+ controller. The Timer1_IRQHandler() function will be called when a Timer 1
+ interrupt occurs.
+ Note: Note: A Timer1_IRQHandler() default implementation is defined, with
+ weak linkage, in the SmartFusion CMSIS-PAL. You must provide your own
+ implementation of the Timer1_IRQHandler() function, that will override the
+ default implementation, to suit your application.
+
+ */
+static __INLINE void MSS_TIM1_enable_irq( void )
+{
+ TIMER_BITBAND->TIM1INTEN = 1U;
+ NVIC_EnableIRQ( Timer1_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_disable_irq() function is used to disable interrupt generation
+ for Timer 1. This function also disables the interrupt in the Cortex-M3
+ interrupt controller.
+ */
+static __INLINE void MSS_TIM1_disable_irq( void )
+{
+ TIMER_BITBAND->TIM1INTEN = 0U;
+ NVIC_DisableIRQ( Timer1_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM1_clear_irq() function is used to clear a pending interrupt from
+ Timer 1. This function also clears the interrupt in the Cortex-M3 interrupt
+ controller.
+ Note: You must call the MSS_TIM1_clear_irq() function as part of your
+ implementation of the Timer1_IRQHandler() Timer 1 interrupt service routine
+ (ISR) in order to prevent the same interrupt event retriggering a call to the
+ ISR.
+
+ */
+static __INLINE void MSS_TIM1_clear_irq( void )
+{
+ TIMER->TIM1_RIS = 1U;
+ NVIC_ClearPendingIRQ( Timer1_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_init() function initializes the SmartFusion MSS Timer block for
+ use as a 32-bit timer and selects the operating mode for Timer 2. This function
+ takes the MSS Timer block out of reset in case this hasn’t been done already,
+ stops Timer 2, disables its interrupt and sets the Timer 2 operating mode.
+ Note: Please note that the SmartFusion MSS Timer block cannot be used both as
+ a 64-bit and 32-bit timer. Calling MSS_TIM2_init() will overwrite any previous
+ configuration of the MSS Timer as a 64-bit timer.
+
+ @param mode
+ The mode parameter specifies whether the timer will operate in periodic or
+ one-shot mode. Allowed values for this parameter are:
+ - MSS_TIMER_PERIODIC_MODE
+ - MSS_TIMER_ONE_SHOT_MODE
+ */
+static __INLINE void MSS_TIM2_init( mss_timer_mode_t mode )
+{
+ NVIC_DisableIRQ( Timer2_IRQn ); /* Disable timer 2 irq in the Cortex-M3 NVIC */
+
+ SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */
+
+ TIMER->TIM64_MODE = 0U; /* switch to 32 bits mode */
+
+ TIMER_BITBAND->TIM2ENABLE = 0U; /* disable timer */
+ TIMER_BITBAND->TIM2INTEN = 0U; /* disable interrupt */
+ TIMER_BITBAND->TIM2MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */
+
+ TIMER->TIM2_RIS = 1U; /* clear timer 2 interrupt */
+ NVIC_ClearPendingIRQ( Timer2_IRQn ); /* clear timer 2 interrupt within NVIC */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_start() function enables Timer 2 and starts its down-counter
+ decrementing from the load_value specified in previous calls to the
+ MSS_TIM2_load_immediate() or MSS_TIM2_load_background() functions.
+ */
+static __INLINE void MSS_TIM2_start( void )
+{
+ TIMER_BITBAND->TIM2ENABLE = 1U; /* enable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_stop() function disables Timer 2 and stops its down-counter
+ decrementing.
+ */
+static __INLINE void MSS_TIM2_stop( void )
+{
+ TIMER_BITBAND->TIM2ENABLE = 0U; /* disable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_get_current_value() returns the current value of the Timer 2
+ down-counter.
+ */
+static __INLINE uint32_t MSS_TIM2_get_current_value( void )
+{
+ return TIMER->TIM2_VAL;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_load_immediate() function loads the value passed by the
+ load_value parameter into the Timer 2 down-counter. The counter will decrement
+ immediately from this value once Timer 2 is enabled. The MSS Timer will
+ generate an interrupt when the counter reaches zero if Timer 2 interrupts are
+ enabled. This function is intended to be used when Timer 2 is configured for
+ one-shot mode to time a single delay.
+
+ @param load_value
+ The load_value parameter specifies the value from which the Timer 2
+ down-counter will start decrementing.
+ */
+static __INLINE void MSS_TIM2_load_immediate( uint32_t load_value )
+{
+ TIMER->TIM2_LOADVAL = load_value;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_load_background() function is used to specify the value that will
+ be reloaded into the Timer 2 down-counter the next time the counter reaches
+ zero. This function is typically used when Timer 2 is configured for periodic
+ mode operation to select or change the delay period between the interrupts
+ generated by Timer 2.
+
+ @param load_value
+ The load_value parameter specifies the value that will be loaded into the
+ Timer 2 down-counter the next time the down-counter reaches zero. The Timer
+ 2 down-counter will start decrementing from this value after the current
+ count expires.
+ */
+static __INLINE void MSS_TIM2_load_background( uint32_t load_value )
+{
+ TIMER->TIM2_BGLOADVAL = load_value;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_enable_irq() function is used to enable interrupt generation for
+ Timer 2. This function also enables the interrupt in the Cortex-M3 interrupt
+ controller. The Timer2_IRQHandler() function will be called when a Timer 2
+ interrupt occurs.
+ Note: A Timer2_IRQHandler() default implementation is defined, with weak
+ linkage, in the SmartFusion CMSIS-PAL. You must provide your own implementation
+ of the Timer2_IRQHandler() function, that will override the default
+ implementation, to suit your application.
+ */
+static __INLINE void MSS_TIM2_enable_irq( void )
+{
+ TIMER_BITBAND->TIM2INTEN = 1U;
+ NVIC_EnableIRQ( Timer2_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_disable_irq() function is used to disable interrupt generation
+ for Timer 2. This function also disables the interrupt in the Cortex-M3
+ interrupt controller.
+ */
+static __INLINE void MSS_TIM2_disable_irq( void )
+{
+ TIMER_BITBAND->TIM2INTEN = 0U;
+ NVIC_DisableIRQ( Timer2_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM2_clear_irq() function is used to clear a pending interrupt from
+ Timer 2. This function also clears the interrupt in the Cortex-M3 interrupt
+ controller.
+ Note: You must call the MSS_TIM2_clear_irq() function as part of your
+ implementation of the Timer2_IRQHandler() Timer 2 interrupt service routine
+ (ISR) in order to prevent the same interrupt event retriggering a call to the
+ ISR.
+ */
+static __INLINE void MSS_TIM2_clear_irq( void )
+{
+ TIMER->TIM2_RIS = 1U;
+ NVIC_ClearPendingIRQ( Timer2_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_init() function initializes the SmartFusion MSS Timer block for
+ use as a single 64-bit timer and selects the operating mode of the timer. This
+ function takes the MSS Timer block out of reset in case this hasn’t been done
+ already, stops the timer, disables its interrupts and sets the timer's
+ operating mode.
+ Note: Please note that the SmartFusion MSS Timer block cannot be used both as
+ a 64-bit and 32-bit timer. Calling MSS_TIM64_init() will overwrite any previous
+ configuration of the MSS Timer as a 32-bit timer.
+
+ @param mode
+ The mode parameter specifies whether the timer will operate in periodic or
+ one-shot mode. Allowed values for this parameter are:
+ - MSS_TIMER_PERIODIC_MODE
+ - MSS_TIMER_ONE_SHOT_MODE
+ */
+static __INLINE void MSS_TIM64_init( mss_timer_mode_t mode )
+{
+ NVIC_DisableIRQ( Timer1_IRQn ); /* disable timer 1 interrupt within NVIC */
+ NVIC_DisableIRQ( Timer2_IRQn ); /* disable timer 2 interrupt within NVIC */
+
+ SYSREG->SOFT_RST_CR &= ~SYSREG_TIMER_SOFTRESET_MASK; /* Take timer block out of reset */
+
+ TIMER->TIM64_MODE = 1U; /* switch to 64 bits mode */
+
+ TIMER_BITBAND->TIM64ENABLE = 0U; /* disable timer */
+ TIMER_BITBAND->TIM64INTEN = 0U; /* disable interrupt */
+ TIMER_BITBAND->TIM64MODE = (uint32_t)mode; /* set mode (continuous/one-shot) */
+
+ TIMER->TIM1_RIS = 1U; /* clear timer 1 interrupt */
+ TIMER->TIM2_RIS = 1U; /* clear timer 2 interrupt */
+ NVIC_ClearPendingIRQ( Timer1_IRQn ); /* clear timer 1 interrupt within NVIC */
+ NVIC_ClearPendingIRQ( Timer2_IRQn ); /* clear timer 2 interrupt within NVIC */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_start() function enables the 64-bit timer and starts its
+ down-counter decrementing from the load_value specified in previous calls to
+ the MSS_TIM64_load_immediate() or MSS_TIM64_load_background() functions.
+ */
+static __INLINE void MSS_TIM64_start( void )
+{
+ TIMER_BITBAND->TIM64ENABLE = 1U; /* enable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_stop() function disables the 64-bit timer and stops its
+ down-counter decrementing.
+ */
+static __INLINE void MSS_TIM64_stop( void )
+{
+ TIMER_BITBAND->TIM64ENABLE = 0U; /* disable timer */
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_get_current_value() is used to read the current value of the
+ 64-bit timer down-counter.
+
+ @param load_value_u
+ The load_value_u parameter is a pointer to a 32-bit variable where the upper
+ 32 bits of the current value of the 64-bit timer down-counter will be copied.
+
+ @param load_value_l
+ The load_value_l parameter is a pointer to a 32-bit variable where the lower
+ 32 bits of the current value of the 64-bit timer down-counter will be copied.
+
+ Example:
+ @code
+ uint32_t current_value_u = 0;
+ uint32_t current_value_l = 0;
+ MSS_TIM64_get_current_value( ¤t_value_u, ¤t_value_l );
+ @endcode
+ */
+static __INLINE void MSS_TIM64_get_current_value
+(
+ uint32_t * load_value_u,
+ uint32_t * load_value_l
+)
+{
+ *load_value_l = TIMER->TIM64_VAL_L;
+ *load_value_u = TIMER->TIM64_VAL_U;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_load_immediate() function loads the values passed by the
+ load_value_u and load_value_l parameters into the 64-bit timer down-counter.
+ The counter will decrement immediately from the concatenated 64-bit value once
+ the 64-bit timer is enabled. The MSS Timer will generate an interrupt when the
+ counter reaches zero if 64-bit timer interrupts are enabled. This function is
+ intended to be used when the 64-bit timer is configured for one-shot mode to
+ time a single delay.
+
+ @param load_value_u
+ The load_value_u parameter specifies the upper 32 bits of the 64-bit timer
+ load value from which the 64-bit timer down-counter will start decrementing.
+
+ @param load_value_l
+ The load_value_l parameter specifies the lower 32 bits of the 64-bit timer
+ load value from which the 64-bit timer down-counter will start decrementing.
+ */
+static __INLINE void MSS_TIM64_load_immediate
+(
+ uint32_t load_value_u,
+ uint32_t load_value_l
+)
+{
+ TIMER->TIM64_LOADVAL_U = load_value_u;
+ TIMER->TIM64_LOADVAL_L = load_value_l;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_load_background() function is used to specify the 64-bit value
+ that will be reloaded into the 64-bit timer down-counter the next time the
+ counter reaches zero. This function is typically used when the 64-bit timer is
+ configured for periodic mode operation to select or change the delay period
+ between the interrupts generated by the 64-bit timer.
+
+ @param load_value_u
+ The load_value_u parameter specifies the upper 32 bits of the 64-bit timer
+ load value. The concatenated 64-bit value formed from load_value_u and
+ load_value_l will be loaded into the 64-bit timer down-counter the next
+ time the down-counter reaches zero. The 64-bit timer down-counter will start
+ decrementing from the concatenated 64-bit value after the current count
+ expires.
+
+ @param load_value_l
+ The load_value_l parameter specifies the lower 32 bits of the 64-bit timer
+ load value. The concatenated 64-bit value formed from load_value_u and
+ load_value_l will be loaded into the 64-bit timer down-counter the next time
+ the down-counter reaches zero. The 64-bit timer down-counter will start
+ decrementing from the concatenated 64-bit value after the current count
+ expires.
+
+ */
+static __INLINE void MSS_TIM64_load_background
+(
+ uint32_t load_value_u,
+ uint32_t load_value_l
+)
+{
+ TIMER->TIM64_BGLOADVAL_U = load_value_u;
+ TIMER->TIM64_BGLOADVAL_L = load_value_l;
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_enable_irq() function is used to enable interrupt generation for
+ the 64-bit timer. This function also enables the interrupt in the Cortex-M3
+ interrupt controller. The Timer1_IRQHandler() function will be called when a
+ 64-bit timer interrupt occurs.
+ Note: A Timer1_IRQHandler() default implementation is defined, with weak
+ linkage, in the SmartFusion CMSIS-PAL. You must provide your own
+ implementation of the Timer1_IRQHandler() function, that will override the
+ default implementation, to suit your application.
+ Note: The MSS_TIM64_enable_irq() function enables and uses Timer 1 interrupts
+ for the 64-bit timer. Timer 2 interrupts remain disabled.
+ */
+static __INLINE void MSS_TIM64_enable_irq( void )
+{
+ TIMER_BITBAND->TIM64INTEN = 1U;
+ NVIC_EnableIRQ( Timer1_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_disable_irq() function is used to disable interrupt generation
+ for the 64-bit timer. This function also disables the interrupt in the
+ Cortex-M3 interrupt controller.
+ */
+static __INLINE void MSS_TIM64_disable_irq( void )
+{
+ TIMER_BITBAND->TIM64INTEN = 0U;
+ NVIC_DisableIRQ( Timer1_IRQn );
+}
+
+/*-------------------------------------------------------------------------*//**
+ The MSS_TIM64_clear_irq() function is used to clear a pending interrupt from
+ the 64-bit timer. This function also clears the interrupt in the Cortex-M3
+ interrupt controller.
+ Note: You must call the MSS_TIM64_clear_irq() function as part of your
+ implementation of the Timer1_IRQHandler() 64-bit timer interrupt service
+ routine (ISR) in order to prevent the same interrupt event retriggering a
+ call to the ISR.
+ */
+static __INLINE void MSS_TIM64_clear_irq( void )
+{
+ TIMER->TIM64_RIS = 1U;
+ NVIC_ClearPendingIRQ( Timer1_IRQn );
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*MSS_TIMER_H_*/