Add BusPal to the right firmware.

right/src/buspal/microseconds/microseconds.h

@@ -0,0 +1,50 @@
+/*
+ * @file microseconds.h
+ * @brief Microseconds timer driver based on PIT(Periodic Interrupt Timer)
+ *
+ * Notes:
+ */
+
+#ifndef ___MICROSECONDS_H__
+#define ___MICROSECONDS_H__
+
+#include <stdio.h>
+#include "fsl_device_registers.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Prototypes
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__cplusplus)
+extern "C" {
+#endif // __cplusplus
+
+/********************************************************************/
+//! @brief Initialize timer facilities.
+void microseconds_init(void);
+
+//! @brief Shutdown the microsecond timer
+void microseconds_shutdown(void);
+
+//! @brief Read back the running tick count
+uint64_t microseconds_get_ticks(void);
+
+//! @brief Returns the conversion of ticks to actual microseconds
+//!        This is used to seperate any calculations from getting a tick
+//         value for speed critical scenarios
+uint32_t microseconds_convert_to_microseconds(uint32_t ticks);
+
+//! @brief Returns the conversion of microseconds to ticks
+uint64_t microseconds_convert_to_ticks(uint32_t microseconds);
+
+//! @brief Delay specified time
+void microseconds_delay(uint32_t us);
+
+//! @brief Gets the clock value used for microseconds driver
+uint32_t microseconds_get_clock(void);
+
+#if defined(__cplusplus)
+}
+#endif // __cplusplus
+
+#endif /* ___MICROSECONDS_H__ */

right/src/buspal/microseconds/src/microseconds_pit.c

@@ -0,0 +1,145 @@
+/*
+ * @file microseconds.c
+ * @brief Microseconds timer driver source file
+ *
+ * Notes: The driver configure PIT as lifetime timer
+ */
+#include "microseconds/microseconds.h"
+#include <stdarg.h>
+//#include "bootloader_common.h"
+#include "bus_pal_hardware.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// Definitions
+////////////////////////////////////////////////////////////////////////////////
+
+// Below MACROs are defined in order to keep this driver compabtile among all targets.
+#if defined(PIT0)
+#define PIT PIT0
+#endif
+#if defined(SIM_SCGC6_PIT0_MASK)
+#define SIM_SCGC6_PIT_MASK SIM_SCGC6_PIT0_MASK
+#endif
+
+enum
+{
+    kFrequency_1MHz = 1000000UL
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Variables
+////////////////////////////////////////////////////////////////////////////////
+uint32_t s_tickPerMicrosecondMul8; //!< This value equal to 8 times ticks per microseconds
+
+////////////////////////////////////////////////////////////////////////////////
+// Code
+////////////////////////////////////////////////////////////////////////////////
+
+//! @brief Initialize timer facilities.
+//!
+//! It is initialize the timer to lifetime timer by chained channel 0
+//! and channel 1 together, and set b0th channels to maximum counting period
+void microseconds_init(void)
+{
+    uint32_t busClock;
+
+    // PIT clock gate control ON
+    SIM->SCGC6 |= SIM_SCGC6_PIT_MASK;
+
+    // Turn on PIT: MDIS = 0, FRZ = 0
+    PIT->MCR = 0x00;
+
+    // Set up timer 1 to max value
+    PIT->CHANNEL[1].LDVAL = 0xFFFFFFFF;          // setup timer 1 for maximum counting period
+    PIT->CHANNEL[1].TCTRL = 0;                   // Disable timer 1 interrupts
+    PIT->CHANNEL[1].TFLG = 1;                    // clear the timer 1 flag
+    PIT->CHANNEL[1].TCTRL |= PIT_TCTRL_CHN_MASK; // chain timer 1 to timer 0
+    PIT->CHANNEL[1].TCTRL |= PIT_TCTRL_TEN_MASK; // start timer 1
+
+    // Set up timer 0 to max value
+    PIT->CHANNEL[0].LDVAL = 0xFFFFFFFF;         // setup timer 0 for maximum counting period
+    PIT->CHANNEL[0].TFLG = 1;                   // clear the timer 0 flag
+    PIT->CHANNEL[0].TCTRL = PIT_TCTRL_TEN_MASK; // start timer 0
+
+    /* Calculate this value early
+     * The reason why use this solution is that lowest clock frequency supported by L0PB and L4KS
+     * is 0.25MHz, this solution will make sure ticks per microscond is greater than 0.
+     */
+
+    busClock = get_bus_clock();
+    s_tickPerMicrosecondMul8 = (busClock * 8) / kFrequency_1MHz;
+
+    // Make sure this value is greater than 0
+    if (!s_tickPerMicrosecondMul8)
+    {
+        s_tickPerMicrosecondMul8 = 1;
+    }
+}
+
+//! @brief Shutdown the microsecond timer
+void microseconds_shutdown(void)
+{
+    // Turn off PIT: MDIS = 1, FRZ = 0
+    PIT->MCR |= PIT_MCR_MDIS_MASK;
+}
+
+//! @brief Read back running tick count
+uint64_t microseconds_get_ticks(void)
+{
+    uint64_t valueH;
+    uint32_t valueL;
+
+#if defined(FSL_FEATURE_PIT_HAS_LIFETIME_TIMER) && (FSL_FEATURE_PIT_HAS_LIFETIME_TIMER == 1)
+    valueH = PIT->LTMR64H;
+    valueL = PIT->LTMR64L;
+#else
+    // Make sure that there are no rollover of valueL.
+    // Because the valueL always decreases, so, if the formal valueL is greater than
+    // current value, that means the valueH is updated during read valueL.
+    // In this case, we need to re-update valueH and valueL.
+    do
+    {
+        valueH = PIT->CHANNEL[1].CVAL;
+        valueL = PIT->CHANNEL[0].CVAL;
+    } while (valueL < PIT->CHANNEL[0].CVAL);
+#endif // FSL_FEATURE_PIT_HAS_LIFETIME_TIMER
+
+    // Invert to turn into an up counter
+    return ~((valueH << 32) | valueL);
+}
+
+//! @brief Returns the conversion of ticks to actual microseconds
+//!        This is used to seperate any calculations from getting a timer
+//         value for speed critical scenarios
+uint32_t microseconds_convert_to_microseconds(uint32_t ticks)
+{
+    // return the total ticks divided by the number of Mhz the system clock is at to give microseconds
+    return (8 * ticks / s_tickPerMicrosecondMul8); //!< Assumes system clock will never be < 0.125 Mhz
+}
+
+//! @brief Returns the conversion of microseconds to ticks
+uint64_t microseconds_convert_to_ticks(uint32_t microseconds)
+{
+    return ((uint64_t)microseconds * s_tickPerMicrosecondMul8 / 8);
+}
+
+//! @brief Delay specified time
+//!
+//! @param us Delay time in microseconds unit
+void microseconds_delay(uint32_t us)
+{
+    uint64_t currentTicks = microseconds_get_ticks();
+
+    //! The clock value in Mhz = ticks/microsecond
+    uint64_t ticksNeeded = ((uint64_t)us * s_tickPerMicrosecondMul8 / 8) + currentTicks;
+    while (microseconds_get_ticks() < ticksNeeded)
+    {
+        ;
+    }
+}
+
+//! @brief Gets the clock value used for microseconds driver
+uint32_t microseconds_get_clock(void)
+{
+    return get_bus_clock();
+}

right/src/buspal/microseconds/src/microseconds_sysclk.c

@@ -0,0 +1,132 @@
+/*
+ * @file microseconds_sysclk.c
+ * @brief Microseconds sysclk timer driver source file
+ *
+ * Notes: The driver configure sysclk as lifetime timer
+ */
+//#include "bootloader_common.h"
+#include "microseconds/microseconds.h"
+#include "fsl_device_registers.h"
+#include <stdarg.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// Definitions
+////////////////////////////////////////////////////////////////////////////////
+
+enum
+{
+    kFrequency_1MHz = 1000000UL
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Variables
+////////////////////////////////////////////////////////////////////////////////
+//! @brief Tracks number of timer rollovers for extended time keeping
+//!        with 32 bits here + the 24 bits of the counter for lower resolution
+//!        it will be years worth of time
+volatile uint32_t s_highCounter;
+uint32_t s_tickPerMicrosecondMul8; //!< This value equal to 8 times ticks per microseconds
+
+////////////////////////////////////////////////////////////////////////////////
+// Code
+////////////////////////////////////////////////////////////////////////////////
+
+//! @brief Initialize and start the timer facilities using the SysTick.
+void microseconds_init(void)
+{
+    s_highCounter = 0;
+    SysTick->LOAD = SysTick_LOAD_RELOAD_Msk; // Set reload register to max value
+    SysTick->VAL = 0;                        // As per ARM reference initialization, set initial value to 0
+                                             //  interrupts are only triggered when going from 1 to 0
+
+    SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | // Set timer to core clock frequency
+                    SysTick_CTRL_TICKINT_Msk |   // Enable interrupts on timeout
+                    SysTick_CTRL_ENABLE_Msk;     // Enable SysTick IRQ and SysTick Timer
+
+    /* Calculate this value early
+     * The reason why use this solution is that lowest clock frequency supported by L0PB and L4KS
+     * is 0.25MHz, this solution will make sure ticks per microscond is greater than 0.
+     */
+    s_tickPerMicrosecondMul8 = (SystemCoreClock * 8) / kFrequency_1MHz;
+
+    // Make sure this value is greater than 0
+    if (!s_tickPerMicrosecondMul8)
+    {
+        s_tickPerMicrosecondMul8 = 1;
+    }
+}
+
+//! @brief Shutdown the microsecond timer
+void microseconds_shutdown(void)
+{
+    // Disable the timer and interrupts from it
+    SysTick->CTRL = SysTick->CTRL & ~(SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk);
+
+    // Clear the current value register
+    SysTick->VAL = 0;
+}
+
+//! @brief Read back the running tick count
+uint64_t microseconds_get_ticks(void)
+{
+    uint64_t retVal;
+
+    //! The rollover counter keeps track of increments higher than the 24 bit SysTick counter
+    //! to combine them shift rollover up 24 bits and add the current ticks
+    uint32_t high;
+    uint32_t low;
+
+    // Check for an overflow condition between the two reads above
+    do
+    {
+        high = s_highCounter;
+        low = ~SysTick->VAL & SysTick_LOAD_RELOAD_Msk;
+    } while (high != s_highCounter);
+
+    retVal = ((uint64_t)high << 24) + low;
+
+    return retVal;
+}
+
+//! @brief Returns the conversion of ticks to actual microseconds
+//!        This is used to seperate any calculations from getting a timer
+//         value for timing sensitive scenarios
+uint32_t microseconds_convert_to_microseconds(uint32_t ticks)
+{
+    // return the total ticks divided by the number of Mhz the system clock is at to give microseconds
+    return (8 * ticks / s_tickPerMicrosecondMul8); //!< Assumes system clock will never be < 0.125 Mhz
+}
+
+//! @brief Returns the conversion of microseconds to ticks
+uint64_t microseconds_convert_to_ticks(uint32_t microseconds)
+{
+    return ((uint64_t)microseconds * s_tickPerMicrosecondMul8 / 8);
+}
+
+//! @brief Delay specified time
+//!
+//! @param us Delay time in microseconds unit
+void microseconds_delay(uint32_t us)
+{
+    uint64_t currentTicks = microseconds_get_ticks();
+
+    //! The clock value in Mhz = ticks/microsecond
+    uint64_t ticksNeeded = ((uint64_t)us * s_tickPerMicrosecondMul8 / 8) + currentTicks;
+    while (microseconds_get_ticks() < ticksNeeded)
+    {
+        ;
+    }
+}
+
+//! @brief Gets the clock value used for microseconds driver
+uint32_t microseconds_get_clock(void)
+{
+    return SystemCoreClock;
+}
+
+//! @brief Interrupt handler for the SysTick timer, this will just increment
+//         the rollover counter for extended time keeping
+void SysTick_Handler(void)
+{
+    s_highCounter++;
+}