/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file    hw_timerserver.c
 * @author  MCD Application Team
 * @brief   Hardware timerserver source file for STM32WPAN Middleware.
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2021 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "app_common.h"
#include "hw_conf.h"

/* Private typedef -----------------------------------------------------------*/
typedef enum
{
    TimerID_Free,
    TimerID_Created,
    TimerID_Running
} TimerIDStatus_t;

typedef enum
{
    SSR_Read_Requested,
    SSR_Read_Not_Requested
} RequestReadSSR_t;

typedef enum
{
    WakeupTimerValue_Overpassed,
    WakeupTimerValue_LargeEnough
} WakeupTimerLimitation_Status_t;

typedef struct
{
    HW_TS_pTimerCb_t pTimerCallBack;
    uint32_t CounterInit;
    uint32_t CountLeft;
    TimerIDStatus_t TimerIDStatus;
    HW_TS_Mode_t TimerMode;
    uint32_t TimerProcessID;
    uint8_t PreviousID;
    uint8_t NextID;
} TimerContext_t;

/* Private defines -----------------------------------------------------------*/
#define SSR_FORBIDDEN_VALUE 0xFFFFFFFF
#define TIMER_LIST_EMPTY 0xFFFF

/* Private macros ------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

/**
 * START of Section TIMERSERVER_CONTEXT
 */

PLACE_IN_SECTION("TIMERSERVER_CONTEXT") static volatile TimerContext_t aTimerContext[CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER];
PLACE_IN_SECTION("TIMERSERVER_CONTEXT") static volatile uint8_t CurrentRunningTimerID;
PLACE_IN_SECTION("TIMERSERVER_CONTEXT") static volatile uint8_t PreviousRunningTimerID;
PLACE_IN_SECTION("TIMERSERVER_CONTEXT") static volatile uint32_t SSRValueOnLastSetup;
PLACE_IN_SECTION("TIMERSERVER_CONTEXT") static volatile WakeupTimerLimitation_Status_t WakeupTimerLimitation;

/**
 * END of Section TIMERSERVER_CONTEXT
 */

static RTC_HandleTypeDef * phrtc; /**< RTC handle */
static uint8_t WakeupTimerDivider;
static uint8_t AsynchPrescalerUserConfig;
static uint16_t SynchPrescalerUserConfig;
static volatile uint16_t MaxWakeupTimerSetup;

/* Global variables ----------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static void RestartWakeupCounter(uint16_t Value);
static uint16_t ReturnTimeElapsed(void);
static void RescheduleTimerList(void);
static void UnlinkTimer(uint8_t TimerID, RequestReadSSR_t RequestReadSSR);
static void LinkTimerBefore(uint8_t TimerID, uint8_t RefTimerID);
static void LinkTimerAfter(uint8_t TimerID, uint8_t RefTimerID);
static uint16_t linkTimer(uint8_t TimerID);
static uint32_t ReadRtcSsrValue(void);

__weak void HW_TS_RTC_CountUpdated_AppNot(void);

/* Functions Definition ------------------------------------------------------*/

/**
 * @brief  Read the RTC_SSR value
 *         As described in the reference manual, the RTC_SSR shall be read twice to ensure
 *         reliability of the value
 * @param  None
 * @retval SSR value read
 */
static uint32_t ReadRtcSsrValue(void)
{
    uint32_t first_read;
    uint32_t second_read;

    first_read = (uint32_t) (READ_BIT(RTC->SSR, RTC_SSR_SS));

    second_read = (uint32_t) (READ_BIT(RTC->SSR, RTC_SSR_SS));

    while (first_read != second_read)
    {
        first_read = second_read;

        second_read = (uint32_t) (READ_BIT(RTC->SSR, RTC_SSR_SS));
    }

    return second_read;
}

/**
 * @brief  Insert a Timer in the list after the Timer ID specified
 * @param  TimerID:   The ID of the Timer
 * @param  RefTimerID: The ID of the Timer to be linked after
 * @retval None
 */
static void LinkTimerAfter(uint8_t TimerID, uint8_t RefTimerID)
{
    uint8_t next_id;

    next_id = aTimerContext[RefTimerID].NextID;

    if (next_id != CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
    {
        aTimerContext[next_id].PreviousID = TimerID;
    }
    aTimerContext[TimerID].NextID     = next_id;
    aTimerContext[TimerID].PreviousID = RefTimerID;
    aTimerContext[RefTimerID].NextID  = TimerID;

    return;
}

/**
 * @brief  Insert a Timer in the list before the ID specified
 * @param  TimerID:   The ID of the Timer
 * @param  RefTimerID: The ID of the Timer to be linked before
 * @retval None
 */
static void LinkTimerBefore(uint8_t TimerID, uint8_t RefTimerID)
{
    uint8_t previous_id;

    if (RefTimerID != CurrentRunningTimerID)
    {
        previous_id = aTimerContext[RefTimerID].PreviousID;

        aTimerContext[previous_id].NextID    = TimerID;
        aTimerContext[TimerID].NextID        = RefTimerID;
        aTimerContext[TimerID].PreviousID    = previous_id;
        aTimerContext[RefTimerID].PreviousID = TimerID;
    }
    else
    {
        aTimerContext[TimerID].NextID        = RefTimerID;
        aTimerContext[RefTimerID].PreviousID = TimerID;
    }

    return;
}

/**
 * @brief  Insert a Timer in the list
 * @param  TimerID:   The ID of the Timer
 * @retval None
 */
static uint16_t linkTimer(uint8_t TimerID)
{
    uint32_t time_left;
    uint16_t time_elapsed;
    uint8_t timer_id_lookup;
    uint8_t next_id;

    if (CurrentRunningTimerID == CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
    {
        /**
         * No timer in the list
         */
        PreviousRunningTimerID        = CurrentRunningTimerID;
        CurrentRunningTimerID         = TimerID;
        aTimerContext[TimerID].NextID = CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER;

        SSRValueOnLastSetup = SSR_FORBIDDEN_VALUE;
        time_elapsed        = 0;
    }
    else
    {
        time_elapsed = ReturnTimeElapsed();

        /**
         * update count of the timer to be linked
         */
        aTimerContext[TimerID].CountLeft += time_elapsed;
        time_left = aTimerContext[TimerID].CountLeft;

        /**
         * Search for index where the new timer shall be linked
         */
        if (aTimerContext[CurrentRunningTimerID].CountLeft <= time_left)
        {
            /**
             * Search for the ID after the first one
             */
            timer_id_lookup = CurrentRunningTimerID;
            next_id         = aTimerContext[timer_id_lookup].NextID;
            while ((next_id != CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER) && (aTimerContext[next_id].CountLeft <= time_left))
            {
                timer_id_lookup = aTimerContext[timer_id_lookup].NextID;
                next_id         = aTimerContext[timer_id_lookup].NextID;
            }

            /**
             * Link after the ID
             */
            LinkTimerAfter(TimerID, timer_id_lookup);
        }
        else
        {
            /**
             * Link before the first ID
             */
            LinkTimerBefore(TimerID, CurrentRunningTimerID);
            PreviousRunningTimerID = CurrentRunningTimerID;
            CurrentRunningTimerID  = TimerID;
        }
    }

    return time_elapsed;
}

/**
 * @brief  Remove a Timer from the list
 * @param  TimerID:   The ID of the Timer
 * @param  RequestReadSSR: Request to read the SSR register or not
 * @retval None
 */
static void UnlinkTimer(uint8_t TimerID, RequestReadSSR_t RequestReadSSR)
{
    uint8_t previous_id;
    uint8_t next_id;

    if (TimerID == CurrentRunningTimerID)
    {
        PreviousRunningTimerID = CurrentRunningTimerID;
        CurrentRunningTimerID  = aTimerContext[TimerID].NextID;
    }
    else
    {
        previous_id = aTimerContext[TimerID].PreviousID;
        next_id     = aTimerContext[TimerID].NextID;

        aTimerContext[previous_id].NextID = aTimerContext[TimerID].NextID;
        if (next_id != CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
        {
            aTimerContext[next_id].PreviousID = aTimerContext[TimerID].PreviousID;
        }
    }

    /**
     * Timer is out of the list
     */
    aTimerContext[TimerID].TimerIDStatus = TimerID_Created;

    if ((CurrentRunningTimerID == CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER) && (RequestReadSSR == SSR_Read_Requested))
    {
        SSRValueOnLastSetup = SSR_FORBIDDEN_VALUE;
    }

    return;
}

/**
 * @brief  Return the number of ticks counted by the wakeuptimer since it has been started
 * @note  The API is reading the SSR register to get how many ticks have been counted
 *        since the time the timer has been started
 * @param  None
 * @retval Time expired in Ticks
 */
static uint16_t ReturnTimeElapsed(void)
{
    uint32_t return_value;
    uint32_t wrap_counter;

    if (SSRValueOnLastSetup != SSR_FORBIDDEN_VALUE)
    {
        return_value = ReadRtcSsrValue(); /**< Read SSR register first */

        if (SSRValueOnLastSetup >= return_value)
        {
            return_value = SSRValueOnLastSetup - return_value;
        }
        else
        {
            wrap_counter = SynchPrescalerUserConfig - return_value;
            return_value = SSRValueOnLastSetup + wrap_counter;
        }

        /**
         * At this stage, ReturnValue holds the number of ticks counted by SSR
         * Need to translate in number of ticks counted by the Wakeuptimer
         */
        return_value = return_value * AsynchPrescalerUserConfig;
        return_value = return_value >> WakeupTimerDivider;
    }
    else
    {
        return_value = 0;
    }

    return (uint16_t) return_value;
}

/**
 * @brief  Set the wakeup counter
 * @note  The API is writing the counter value so that the value is decreased by one to cope with the fact
 *    the interrupt is generated with 1 extra clock cycle (See RefManuel)
 *    It assumes all condition are met to be allowed to write the wakeup counter
 * @param  Value: Value to be written in the counter
 * @retval None
 */
static void RestartWakeupCounter(uint16_t Value)
{
    /**
     * The wakeuptimer has been disabled in the calling function to reduce the time to poll the WUTWF
     * FLAG when the new value will have to be written
     *  __HAL_RTC_WAKEUPTIMER_DISABLE(phrtc);
     */

    if (Value == 0)
    {
        SSRValueOnLastSetup = ReadRtcSsrValue();

        /**
         * Simulate that the Timer expired
         */
        HAL_NVIC_SetPendingIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID);
    }
    else
    {
        if ((Value > 1) || (WakeupTimerDivider != 1))
        {
            Value -= 1;
        }

        while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTWF) == RESET)
            ;

        /**
         * make sure to clear the flags after checking the WUTWF.
         * It takes 2 RTCCLK between the time the WUTE bit is disabled and the
         * time the timer is disabled. The WUTWF bit somehow guarantee the system is stable
         * Otherwise, when the timer is periodic with 1 Tick, it may generate an extra interrupt in between
         * due to the autoreload feature
         */
        __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(phrtc, RTC_FLAG_WUTF);    /**<  Clear flag in RTC module */
        __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();                   /**<  Clear flag in EXTI module */
        HAL_NVIC_ClearPendingIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Clear pending bit in NVIC */

        MODIFY_REG(RTC->WUTR, RTC_WUTR_WUT, Value);

        /**
         * Update the value here after the WUTWF polling that may take some time
         */
        SSRValueOnLastSetup = ReadRtcSsrValue();

        __HAL_RTC_WAKEUPTIMER_ENABLE(phrtc); /**<  Enable the Wakeup Timer */

        HW_TS_RTC_CountUpdated_AppNot();
    }

    return;
}

/**
 * @brief  Reschedule the list of timer
 * @note  1) Update the count left for each timer in the list
 *    2) Setup the wakeuptimer
 * @param  None
 * @retval None
 */
static void RescheduleTimerList(void)
{
    uint8_t localTimerID;
    uint32_t timecountleft;
    uint16_t wakeup_timer_value;
    uint16_t time_elapsed;

    /**
     * The wakeuptimer is disabled now to reduce the time to poll the WUTWF
     * FLAG when the new value will have to be written
     */
    if ((READ_BIT(RTC->CR, RTC_CR_WUTE) == (RTC_CR_WUTE)) == SET)
    {
        /**
         * Wait for the flag to be back to 0 when the wakeup timer is enabled
         */
        while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTWF) == SET)
            ;
    }
    __HAL_RTC_WAKEUPTIMER_DISABLE(phrtc); /**<  Disable the Wakeup Timer */

    localTimerID = CurrentRunningTimerID;

    /**
     * Calculate what will be the value to write in the wakeuptimer
     */
    timecountleft = aTimerContext[localTimerID].CountLeft;

    /**
     * Read how much has been counted
     */
    time_elapsed = ReturnTimeElapsed();

    if (timecountleft < time_elapsed)
    {
        /**
         * There is no tick left to count
         */
        wakeup_timer_value    = 0;
        WakeupTimerLimitation = WakeupTimerValue_LargeEnough;
    }
    else
    {
        if (timecountleft > (time_elapsed + MaxWakeupTimerSetup))
        {
            /**
             * The number of tick left is greater than the Wakeuptimer maximum value
             */
            wakeup_timer_value = MaxWakeupTimerSetup;

            WakeupTimerLimitation = WakeupTimerValue_Overpassed;
        }
        else
        {
            wakeup_timer_value    = timecountleft - time_elapsed;
            WakeupTimerLimitation = WakeupTimerValue_LargeEnough;
        }
    }

    /**
     * update ticks left to be counted for each timer
     */
    while (localTimerID != CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
    {
        if (aTimerContext[localTimerID].CountLeft < time_elapsed)
        {
            aTimerContext[localTimerID].CountLeft = 0;
        }
        else
        {
            aTimerContext[localTimerID].CountLeft -= time_elapsed;
        }
        localTimerID = aTimerContext[localTimerID].NextID;
    }

    /**
     * Write next count
     */
    RestartWakeupCounter(wakeup_timer_value);

    return;
}

/* Public functions ----------------------------------------------------------*/

/**
 * For all public interface except that may need write access to the RTC, the RTC
 * shall be unlock at the beginning and locked at the output
 * In order to ease maintainability, the unlock is done at the top and the lock at then end
 * in case some new implementation is coming in the future
 */

void HW_TS_RTC_Wakeup_Handler(void)
{
    HW_TS_pTimerCb_t ptimer_callback;
    uint32_t timer_process_id;
    uint8_t local_current_running_timer_id;
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    uint32_t primask_bit;
#endif

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    primask_bit = __get_PRIMASK(); /**< backup PRIMASK bit */
    __disable_irq();               /**< Disable all interrupts by setting PRIMASK bit on Cortex*/
#endif

    /* Disable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);

    /**
     * Disable the Wakeup Timer
     * This may speed up a bit the processing to wait the timer to be disabled
     * The timer is still counting 2 RTCCLK
     */
    __HAL_RTC_WAKEUPTIMER_DISABLE(phrtc);

    local_current_running_timer_id = CurrentRunningTimerID;

    if (aTimerContext[local_current_running_timer_id].TimerIDStatus == TimerID_Running)
    {
        ptimer_callback  = aTimerContext[local_current_running_timer_id].pTimerCallBack;
        timer_process_id = aTimerContext[local_current_running_timer_id].TimerProcessID;

        /**
         * It should be good to check whether the TimeElapsed is greater or not than the tick left to be counted
         * However, due to the inaccuracy of the reading of the time elapsed, it may return there is 1 tick
         * to be left whereas the count is over
         * A more secure implementation has been done with a flag to state whereas the full count has been written
         * in the wakeuptimer or not
         */
        if (WakeupTimerLimitation != WakeupTimerValue_Overpassed)
        {
            if (aTimerContext[local_current_running_timer_id].TimerMode == hw_ts_Repeated)
            {
                UnlinkTimer(local_current_running_timer_id, SSR_Read_Not_Requested);
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
                __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif
                HW_TS_Start(local_current_running_timer_id, aTimerContext[local_current_running_timer_id].CounterInit);

                /* Disable the write protection for RTC registers */
                __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);
            }
            else
            {
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
                __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif
                HW_TS_Stop(local_current_running_timer_id);

                /* Disable the write protection for RTC registers */
                __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);
            }

            HW_TS_RTC_Int_AppNot(timer_process_id, local_current_running_timer_id, ptimer_callback);
        }
        else
        {
            RescheduleTimerList();
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
            __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif
        }
    }
    else
    {
        /**
         * We should never end up in this case
         * However, if due to any bug in the timer server this is the case, the mistake may not impact the user.
         * We could just clean the interrupt flag and get out from this unexpected interrupt
         */
        while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTWF) == RESET)
            ;

        /**
         * make sure to clear the flags after checking the WUTWF.
         * It takes 2 RTCCLK between the time the WUTE bit is disabled and the
         * time the timer is disabled. The WUTWF bit somehow guarantee the system is stable
         * Otherwise, when the timer is periodic with 1 Tick, it may generate an extra interrupt in between
         * due to the autoreload feature
         */
        __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(phrtc, RTC_FLAG_WUTF); /**<  Clear flag in RTC module */
        __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();                /**<  Clear flag in EXTI module */

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
        __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif
    }

    /* Enable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_ENABLE(phrtc);

    return;
}

void HW_TS_Init(HW_TS_InitMode_t TimerInitMode, RTC_HandleTypeDef * hrtc)
{
    uint8_t loop;
    uint32_t localmaxwakeuptimersetup;

    /**
     * Get RTC handler
     */
    phrtc = hrtc;

    /* Disable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);

    SET_BIT(RTC->CR, RTC_CR_BYPSHAD);

    /**
     * Readout the user config
     */
    WakeupTimerDivider = (4 - ((uint32_t) (READ_BIT(RTC->CR, RTC_CR_WUCKSEL))));

    AsynchPrescalerUserConfig =
        (uint8_t) (READ_BIT(RTC->PRER, RTC_PRER_PREDIV_A) >> (uint32_t) POSITION_VAL(RTC_PRER_PREDIV_A)) + 1;

    SynchPrescalerUserConfig = (uint16_t) (READ_BIT(RTC->PRER, RTC_PRER_PREDIV_S)) + 1;

    /**
     *  Margin is taken to avoid wrong calculation when the wrap around is there and some
     *  application interrupts may have delayed the reading
     */
    localmaxwakeuptimersetup =
        ((((SynchPrescalerUserConfig - 1) * AsynchPrescalerUserConfig) - CFG_HW_TS_RTC_HANDLER_MAX_DELAY) >> WakeupTimerDivider);

    if (localmaxwakeuptimersetup >= 0xFFFF)
    {
        MaxWakeupTimerSetup = 0xFFFF;
    }
    else
    {
        MaxWakeupTimerSetup = (uint16_t) localmaxwakeuptimersetup;
    }

    /**
     * Configure EXTI module
     */
    LL_EXTI_EnableRisingTrig_0_31(RTC_EXTI_LINE_WAKEUPTIMER_EVENT);
    LL_EXTI_EnableIT_0_31(RTC_EXTI_LINE_WAKEUPTIMER_EVENT);

    if (TimerInitMode == hw_ts_InitMode_Full)
    {
        WakeupTimerLimitation = WakeupTimerValue_LargeEnough;
        SSRValueOnLastSetup   = SSR_FORBIDDEN_VALUE;

        /**
         * Initialize the timer server
         */
        for (loop = 0; loop < CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER; loop++)
        {
            aTimerContext[loop].TimerIDStatus = TimerID_Free;
        }

        CurrentRunningTimerID = CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER; /**<  Set ID to non valid value */

        __HAL_RTC_WAKEUPTIMER_DISABLE(phrtc);                      /**<  Disable the Wakeup Timer */
        __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(phrtc, RTC_FLAG_WUTF);    /**<  Clear flag in RTC module */
        __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();                   /**<  Clear flag in EXTI module  */
        HAL_NVIC_ClearPendingIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Clear pending bit in NVIC  */
        __HAL_RTC_WAKEUPTIMER_ENABLE_IT(phrtc, RTC_IT_WUT);        /**<  Enable interrupt in RTC module  */
    }
    else
    {
        if (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTF) != RESET)
        {
            /**
             * Simulate that the Timer expired
             */
            HAL_NVIC_SetPendingIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID);
        }
    }

    /* Enable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_ENABLE(phrtc);

    HAL_NVIC_SetPriority(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID, CFG_HW_TS_NVIC_RTC_WAKEUP_IT_PREEMPTPRIO,
                         CFG_HW_TS_NVIC_RTC_WAKEUP_IT_SUBPRIO); /**<  Set NVIC priority */
    HAL_NVIC_EnableIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID);        /**<  Enable NVIC */

    return;
}

HW_TS_ReturnStatus_t HW_TS_Create(uint32_t TimerProcessID, uint8_t * pTimerId, HW_TS_Mode_t TimerMode,
                                  HW_TS_pTimerCb_t pftimeout_handler)
{
    HW_TS_ReturnStatus_t localreturnstatus;
    uint8_t loop = 0;
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    uint32_t primask_bit;
#endif

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    primask_bit = __get_PRIMASK(); /**< backup PRIMASK bit */
    __disable_irq();               /**< Disable all interrupts by setting PRIMASK bit on Cortex*/
#endif

    while ((loop < CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER) && (aTimerContext[loop].TimerIDStatus != TimerID_Free))
    {
        loop++;
    }

    if (loop != CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
    {
        aTimerContext[loop].TimerIDStatus = TimerID_Created;

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
        __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif

        aTimerContext[loop].TimerProcessID = TimerProcessID;
        aTimerContext[loop].TimerMode      = TimerMode;
        aTimerContext[loop].pTimerCallBack = pftimeout_handler;
        *pTimerId                          = loop;

        localreturnstatus = hw_ts_Successful;
    }
    else
    {
#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
        __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif

        localreturnstatus = hw_ts_Failed;
    }

    return (localreturnstatus);
}

void HW_TS_Delete(uint8_t timer_id)
{
    HW_TS_Stop(timer_id);

    aTimerContext[timer_id].TimerIDStatus = TimerID_Free; /**<  release ID */

    return;
}

void HW_TS_Stop(uint8_t timer_id)
{
    uint8_t localcurrentrunningtimerid;

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    uint32_t primask_bit;
#endif

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    primask_bit = __get_PRIMASK(); /**< backup PRIMASK bit */
    __disable_irq();               /**< Disable all interrupts by setting PRIMASK bit on Cortex*/
#endif

    HAL_NVIC_DisableIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Disable NVIC */

    /* Disable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);

    if (aTimerContext[timer_id].TimerIDStatus == TimerID_Running)
    {
        UnlinkTimer(timer_id, SSR_Read_Requested);
        localcurrentrunningtimerid = CurrentRunningTimerID;

        if (localcurrentrunningtimerid == CFG_HW_TS_MAX_NBR_CONCURRENT_TIMER)
        {
            /**
             * List is empty
             */

            /**
             * Disable the timer
             */
            if ((READ_BIT(RTC->CR, RTC_CR_WUTE) == (RTC_CR_WUTE)) == SET)
            {
                /**
                 * Wait for the flag to be back to 0 when the wakeup timer is enabled
                 */
                while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTWF) == SET)
                    ;
            }
            __HAL_RTC_WAKEUPTIMER_DISABLE(phrtc); /**<  Disable the Wakeup Timer */

            while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(phrtc, RTC_FLAG_WUTWF) == RESET)
                ;

            /**
             * make sure to clear the flags after checking the WUTWF.
             * It takes 2 RTCCLK between the time the WUTE bit is disabled and the
             * time the timer is disabled. The WUTWF bit somehow guarantee the system is stable
             * Otherwise, when the timer is periodic with 1 Tick, it may generate an extra interrupt in between
             * due to the autoreload feature
             */
            __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(phrtc, RTC_FLAG_WUTF);    /**<  Clear flag in RTC module */
            __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();                   /**<  Clear flag in EXTI module */
            HAL_NVIC_ClearPendingIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Clear pending bit in NVIC */
        }
        else if (PreviousRunningTimerID != localcurrentrunningtimerid)
        {
            RescheduleTimerList();
        }
    }

    /* Enable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_ENABLE(phrtc);

    HAL_NVIC_EnableIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Enable NVIC */

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif

    return;
}

void HW_TS_Start(uint8_t timer_id, uint32_t timeout_ticks)
{
    uint16_t time_elapsed;
    uint8_t localcurrentrunningtimerid;

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    uint32_t primask_bit;
#endif

    if (aTimerContext[timer_id].TimerIDStatus == TimerID_Running)
    {
        HW_TS_Stop(timer_id);
    }

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    primask_bit = __get_PRIMASK(); /**< backup PRIMASK bit */
    __disable_irq();               /**< Disable all interrupts by setting PRIMASK bit on Cortex*/
#endif

    HAL_NVIC_DisableIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Disable NVIC */

    /* Disable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_DISABLE(phrtc);

    aTimerContext[timer_id].TimerIDStatus = TimerID_Running;

    aTimerContext[timer_id].CountLeft   = timeout_ticks;
    aTimerContext[timer_id].CounterInit = timeout_ticks;

    time_elapsed = linkTimer(timer_id);

    localcurrentrunningtimerid = CurrentRunningTimerID;

    if (PreviousRunningTimerID != localcurrentrunningtimerid)
    {
        RescheduleTimerList();
    }
    else
    {
        aTimerContext[timer_id].CountLeft -= time_elapsed;
    }

    /* Enable the write protection for RTC registers */
    __HAL_RTC_WRITEPROTECTION_ENABLE(phrtc);

    HAL_NVIC_EnableIRQ(CFG_HW_TS_RTC_WAKEUP_HANDLER_ID); /**<  Enable NVIC */

#if (CFG_HW_TS_USE_PRIMASK_AS_CRITICAL_SECTION == 1)
    __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/
#endif

    return;
}

uint16_t HW_TS_RTC_ReadLeftTicksToCount(void)
{
    uint32_t primask_bit;
    uint16_t return_value, auro_reload_value, elapsed_time_value;

    primask_bit = __get_PRIMASK(); /**< backup PRIMASK bit */
    __disable_irq();               /**< Disable all interrupts by setting PRIMASK bit on Cortex*/

    if ((READ_BIT(RTC->CR, RTC_CR_WUTE) == (RTC_CR_WUTE)) == SET)
    {
        auro_reload_value = (uint32_t) (READ_BIT(RTC->WUTR, RTC_WUTR_WUT));

        elapsed_time_value = ReturnTimeElapsed();

        if (auro_reload_value > elapsed_time_value)
        {
            return_value = auro_reload_value - elapsed_time_value;
        }
        else
        {
            return_value = 0;
        }
    }
    else
    {
        return_value = TIMER_LIST_EMPTY;
    }

    __set_PRIMASK(primask_bit); /**< Restore PRIMASK bit*/

    return (return_value);
}

__weak void HW_TS_RTC_Int_AppNot(uint32_t TimerProcessID, uint8_t TimerID, HW_TS_pTimerCb_t pTimerCallBack)
{
    pTimerCallBack();

    return;
}