/*BEGIN_FILE_HDR
********************************************************************************
* NOTICE
* This software is the property of HiRain Technologies. Any information
* contained in this doc should not be reproduced, or used, or disclosed
* without the written authorization from HiRain Technologies.
********************************************************************************
* File Name:       Os_Timer.c
********************************************************************************
* Project/Product: AUTOSAR OS PROJECT
* Title:           Os_Timer.c
* Author:          Hirain
********************************************************************************
* Description:     System Timer Module of OS
*
********************************************************************************
* Limitations     : None
*
********************************************************************************
*
********************************************************************************
* Revision History:
* Reference to Os_Cpu.c File
********************************************************************************
* END_FILE_HDR*/
#include "Os_Internal.h"


#define OS_START_SEC_VAR_NOINIT_UNSPECIFIED
#include "Os_MemMap.h"
#if(OS_SYSTICK_MODE == OS_HRT_MODE)
STATIC VAR(Os_uint32, OS_VAR) Os_nextCounterTime[OS_COUNTER_NUMBER];
STATIC VAR(Os_uint32, OS_VAR) Os_treeHeadNum[OS_COUNTER_NUMBER];
STATIC VAR(TickType, OS_VAR)  Os_irqProcessTime[OS_COUNTER_NUMBER];
STATIC VAR(Os_uint32, OS_VAR) Os_storeCounterTick[OS_COUNTER_NUMBER];
STATIC VAR(Os_uint32, OS_VAR) Os_lastSystCTRL[OS_COUNTER_NUMBER];
STATIC VAR(Os_boolean, OS_VAR)  Os_SysCntRunning[OS_PL_MAX_CORE_NUMBER];
STATIC VAR(Os_uint32, OS_VAR) Os_LastReload[OS_PL_MAX_CORE_NUMBER];
#endif/* (OS_SYSTICK_MODE == OS_HRT_MODE) */
#define OS_STOP_SEC_VAR_NOINIT_UNSPECIFIED
#include "Os_MemMap.h"


/*****************************************************************************
* MACRO
******************************************************************************/
#define OS_PL_STM_CMCON_MSIZE1_VAL  ((Os_uint32)0x0000001F)
#define OS_PL_STM_SR_TOS_OFFSET     ((Os_uint32)11)
#define OS_SYS_TIMER_MAX_VALUE      OS_PL_SYSTIMER_RELOAD_VAL

#define OS_TP_TIMER_MAX_VALUE       (0xFFFFFFFF)
#if(OS_ON == OS_TP_FCTIMER_NEED)
#define OS_TP_FCTIMER_MAX_VALUE     (0xFFFFFFFF)
#endif

#define OS_START_SEC_CODE
#include "Os_MemMap.h"
/*****************************************************************************
* Os Internal Functions
******************************************************************************/

#if(OS_ON == OS_TP_TIMER_NEED)
/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_GetState
*
* Description:   get timer enable state
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
STATIC FUNC(Os_boolean, OS_CODE) OsTpTimer_GetState 
(
    CoreIdType CoreID
)
{
    Os_boolean ctrlStatus = OS_FALSE;
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;    
    (void)CoreID; 
    /* enable STIM moudle,otherwise the reg cannot be read*/
    OsCpu_SYSCTRL_EnableModule(OS_SYSCTRL_STIM);
    /* check enable flag */
    if(STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].EN == 1U)/* STIM channelx is enable*/
        ctrlStatus = OS_TRUE;
    else/*disable*/
        OsCpu_SYSCTRL_ResetModule(OS_SYSCTRL_STIM); 
    return ctrlStatus;
}
#endif
/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsSysTimer_Init
*
* Description:   Sys timer init
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsSysTimer_Init
(
    CoreIdType CoreID
)
{
#if(OS_USED_CORE_NUMBER > 1)
    CoreIdType phyCoreId = Os_LogCoreToPhy[CoreID];
    Os_uint32 stmsr_tos = phyCoreId;
#endif
    Os_uint32 stm_pri;

    stm_pri = Os_ISRCfg[Os_CoreCfg[CoreID].sysCntIsrId].Prio;

    OS_PL_STM_VAL = 0UL;
    OS_PL_NVIC_SHPR3_REG |= ((OS_PL_LOWEST_INT_PRIO - stm_pri) << (OS_PL_PRIO_REG_BITS - OS_PL_PRIO_BITS)) << OS_PL_STM_PRIO_SHIFT;
    OS_PL_STM_CTRL = (Os_uint32)(OS_PL_STM_CLKSOURCE << OS_PL_STM_CLKSOURCE_SHIFT);

    /* Check register val */
    if((OS_PL_STM_VAL != 0) || (OS_PL_STM_CTRL != (Os_uint32)(OS_PL_STM_CLKSOURCE << OS_PL_STM_CLKSOURCE_SHIFT)))
    {
        OsHook_FataErrReport(CoreID, E_OS_PL_SYSFATA_REG_ERR, OSServiceId_OsSysTimer_Init,\
                OS_IE_NOMORE_INFO, OS_IE_NO_ERRPAR, OS_IE_NO_ERRPAR, OS_IE_NO_ERRPAR);
    }

}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsSysTimer_Run
*
* Description:   start system timer
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsSysTimer_Run
(
    CoreIdType CoreID
)
{
#if(OS_SYSTICK_MODE == OS_HRT_MODE)    
    CounterType counterID = Os_CoreCfg[CoreID].startCntId;    
    P2CONST(Os_CounterCfgType, AUTOMATIC, OS_CONST) cntCfgPtr = &Os_CounterCfg[counterID];
    Os_uint8 objID = (Os_uint8)(cntCfgPtr->treeQue[0].ObjId);
    TickType timeVal = 0;

    Os_SysCntRunning[CoreID] = OS_FALSE;
#if(OS_SCHTBL_NUMBER > 0)
    if(OS_FALSE == cntCfgPtr->treeQue[0].isAlarm)
    {
        if(SCHEDULETABLE_RUNNING == Os_SchTblCBTable[objID].OsSchTblState)
        {
            timeVal = Os_SchTblCBTable[objID].timeVal; 
            Os_SysCntRunning[CoreID] = OS_TRUE;
        }
        else
        {
            Os_SysCntRunning[CoreID] = OS_FALSE;
        }
    }
    else
#endif/*(OS_SCHTBL_NUMBER > 0)*/
    {
#if(OS_ALARM_NUMBER > 0)
        if(OS_TRUE == Os_AlarmCBTable[objID].isAlive)
        {
            timeVal = Os_AlarmCBTable[objID].timeVal;
            Os_SysCntRunning[CoreID] = OS_TRUE;
        }
        else
        {
            Os_SysCntRunning[CoreID] = OS_FALSE;
        }
#endif/*(OS_ALARM_NUMBER > 0)*/
    }

    if(Os_SysCntRunning[CoreID] == OS_TRUE)   
    {
        OS_PL_STM_LOAD = timeVal;
        OS_PL_STM_CTRL |= ((Os_uint32)Os_SysTick_CTRL_TICKINT_MSK | (Os_uint32)Os_SysTick_CTRL_ENABLE_MSK);  /* Enable SysTick IRQ and SysTick Timer */
    }  
    else
    {
        OS_PL_STM_LOAD = OS_PL_SYSTIMER_MAX_RELOAD_VAL;   /* 24bits */
        OS_PL_STM_CTRL |= ((Os_uint32)Os_SysTick_CTRL_ENABLE_MSK );  /* enable SysTick Timer */
        OS_PL_STM_CTRL &= (~((Os_uint32)Os_SysTick_CTRL_TICKINT_MSK ));  /* disable SysTick IRQ  */
    }

    Os_LastReload[CoreID] = OS_PL_STM_LOAD;
    Os_nextCounterTime[counterID] = OS_PL_STM_LOAD;

#else/* (OS_SYSTICK_MODE == OS_HRT_MODE) */    
    OS_PL_STM_LOAD = (Os_uint32)(OS_PL_SYSTIMER_RELOAD_VAL - 1UL);                       /* set reload register */
    OS_PL_STM_CTRL |= (Os_SysTick_CTRL_TICKINT_MSK | Os_SysTick_CTRL_ENABLE_MSK);    /* Enable SysTick IRQ and SysTick Timer */
#endif/* (OS_SYSTICK_MODE == OS_HRT_MODE) */    
}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsSysTimer_Stop
*
* Description:   stop system timer SRC_STM0SR0.B.SRE = 0;
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/ 
FUNC(void, OS_CODE)  OsSysTimer_Stop(CoreIdType CoreID)
{
    OS_PL_STM_CTRL  &=   ~(Os_SysTick_CTRL_TICKINT_MSK | Os_SysTick_CTRL_ENABLE_MSK);
}
 


/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: OsSysTimer_GetTimer
*
* Description:   get system timer, read TIM0
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/
/*Has been implemented in the form of macro definitions in the Os_Pl_InternalCode.h file*/


/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: OsSysTimer_GetElapsedTime
*
* Description:   get elapsed time of system timer
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_SysTickType, OS_CODE) OsSysTimer_GetElapsedTime
(
    CoreIdType CoreID,
    Os_SysTickType startTime
)
{
    Os_SysTickType dtime;
    (void)CoreID;
    Os_SysTickType ctime = OS_PL_STM_VAL;

    if(startTime > ctime)
    {
        dtime = startTime - ctime;
    }
    else
    {
#if(OS_SYSTICK_MODE == OS_HRT_MODE)
        dtime = OS_PL_STM_LOAD - (ctime - startTime);
#else
        dtime = OS_SYS_TIMER_MAX_VALUE - (ctime - startTime);   
#endif/* (OS_SYSTICK_MODE == OS_HRT_MODE) */        
    }

    return dtime;
}

#if(OS_SYSTICK_MODE == OS_HRT_MODE)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: OsSysTimer_UpdateCounter
*
* Description:   Update Counter Value
*
* Inputs:        CoreID, CounterID
*
* Outputs:       Os_uint32
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/
FUNC (Os_uint32, OS_CODE) OsSysTimer_UpdateCounter
(
    CoreIdType CoreID,
    CounterType CounterID
)
{
    (void)CoreID;
    TickType tempCounterTick;
    TickType tempInterval = OS_PL_STM_LOAD - OS_PL_STM_VAL + 1;
    Os_uint32 milliSecond = 0;
    Os_uint32 microSecond = 0;

    if(CounterID == Os_CoreCfg[CoreID].startCntId)
    {
        if(Os_LastReload[CoreID] == OS_PL_STM_LOAD)
        {
            tempCounterTick = Os_CounterTick[CounterID] + tempInterval;
            Os_storeCounterTick[CounterID] = tempCounterTick;    
        }
        else
        {
            tempCounterTick = Os_storeCounterTick[CounterID] + tempInterval;
        }

        milliSecond = tempCounterTick / OS_PL_SYSTIMER_MAX_RELOAD_VAL;
        microSecond = (tempCounterTick % OS_PL_SYSTIMER_MAX_RELOAD_VAL) % OS_PL_SYSTIMER_RESOLUTION;
        if(microSecond != 0)
        {
            microSecond = ((tempCounterTick % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION) + 1;
        }
        else
        {
            microSecond = (tempCounterTick % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION;
        }
        tempCounterTick = milliSecond*OS_PL_SYSTIMER_MAX_RELOAD_VAL + microSecond*OS_PL_SYSTIMER_RESOLUTION;

    }
    else
    {
      tempCounterTick = Os_CounterTick[CounterID];
    }


   return tempCounterTick;

}
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: OsSysTimer_UpdateReloadTimer
*
* Description:   Update Systimer Reload Register
*
* Inputs:        CoreID,CounterID,newTimeVal,originalTimeVal,lastCounterTick,newAlarmCycle
*
* Outputs:       void
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/
FUNC (void, OS_CODE) OsSysTimer_UpdateReloadTimer
(
    CoreIdType CoreID,
    CounterType CounterID,
    TickType newTimeVal,
    TickType originalTimeVal,
    TickType lastCounterTick,
    TickType newAlarmCycle
)
{
    Os_boolean systimerEnable;
    Os_boolean systimerIRQEnable;
    Os_uint32 temp;
    Os_uint32 milliSecond = 0;
    Os_uint32 microSecond = 0;

    if((OS_PL_STM_CTRL & Os_SysTick_CTRL_ENABLE_MSK) != 0)
    {
        systimerEnable = OS_TRUE;
    }
    else
    {
        systimerEnable = OS_FALSE;
    } 
    if((OS_PL_STM_CTRL & Os_SysTick_CTRL_TICKINT_MSK) != 0)
    {
        systimerIRQEnable = OS_TRUE;
    }
    else
    {
        systimerIRQEnable = OS_FALSE;
    }
    
    if(CounterID == Os_CoreCfg[CoreID].startCntId)
    {
        if(Os_SysCntRunning[CoreID] == OS_TRUE)
        {
                if(Os_CounterTick[CounterID] != lastCounterTick + OS_PL_STM_LOAD)
                {
                    if(newTimeVal < originalTimeVal)
                    {
                        if(newTimeVal > Os_CounterTick[CounterID])
                        {
                            /* OS_PL_STM_LOAD = newTimeVal - Os_CounterTick[CounterID];
                               OS_PL_STM_VAL = (Os_uint32)0UL;*/
                        }
                    }
                }
                else
                {
                    if((OS_PL_SYSTIMER_MAX_RELOAD_VAL - Os_CounterTick[CounterID]) < newAlarmCycle)
                    {
                        OS_PL_STM_LOAD = newAlarmCycle;
                    }
                    else
                    {
                        Os_CounterTick[CounterID] = lastCounterTick + OS_PL_STM_LOAD;
                    }
                }
        }
        else
        {
            if((systimerEnable == OS_TRUE)&&(systimerIRQEnable == OS_FALSE))
            {          
                milliSecond = newTimeVal / OS_PL_SYSTIMER_MAX_RELOAD_VAL;
                microSecond = (newTimeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) % OS_PL_SYSTIMER_RESOLUTION;
                if(microSecond != 0)
                {
                    microSecond = ((newTimeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION) + 1;
                }
                else
                {
                    microSecond = (newTimeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION;
                }
                newTimeVal = milliSecond*OS_PL_SYSTIMER_MAX_RELOAD_VAL + microSecond*OS_PL_SYSTIMER_RESOLUTION;

                if(newTimeVal > Os_CounterTick[CounterID])
                {
                    OS_PL_STM_LOAD = newTimeVal - Os_CounterTick[CounterID];     
                }
                else
                {
                    OS_PL_STM_LOAD = OS_PL_SYSTIMER_MAX_RELOAD_VAL - Os_CounterTick[CounterID] + newTimeVal;
                }
                OS_PL_STM_VAL = (Os_uint32)0UL;
                OS_PL_STM_CTRL |= ((Os_uint32)Os_SysTick_CTRL_TICKINT_MSK );  /* enable SysTick IRQ  */
                Os_SysCntRunning[CoreID] = OS_TRUE;
            }
            
        }
      
    }
    
}
#endif/* (OS_SYSTICK_MODE == OS_HRT_MODE) */ 

/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: OsSysTimer_ISR
*
* Description:   called when system timer interrupt triggered
*
* Inputs:        None
*
* Outputs:       None
*
* Limitations:   None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsSysTimer_ISR(void)
{
    CoreIdType CoreID;
    CoreID = OsCpu_GetCoreID();
#if(OS_SYSTICK_MODE == OS_HRT_MODE)
    Os_uint8 objId;
    CounterType counterID = Os_CoreCfg[CoreID].startCntId;                        
    P2CONST(Os_CounterCfgType, AUTOMATIC, OS_CONST) cntCfgPtr = &Os_CounterCfg[counterID]; 

    Os_uint32 delayFlag = 0;
    Os_uint32 milliSecond = 0;
    Os_uint32 microSecond = 0;

    Os_uint32 preProcessTime = OS_PL_STM_LOAD - OS_PL_STM_VAL;
    OS_PL_STM_LOAD = OS_PL_SYSTIMER_MAX_RELOAD_VAL;
    OS_PL_STM_VAL = 0;

    objId = (Os_uint8)(cntCfgPtr->treeQue[0].ObjId);
#if(OS_SCHTBL_NUMBER > 0)
    if(OS_FALSE == cntCfgPtr->treeQue[0].isAlarm)
    {
        if(SCHEDULETABLE_RUNNING == Os_SchTblCBTable[objId].OsSchTblState)
        {
            Os_nextCounterTime[counterID] = Os_SchTblCBTable[objId].timeVal;  
        }
    }
    else
#endif/*(OS_SCHTBL_NUMBER > 0)*/
    {
#if(OS_ALARM_NUMBER > 0)
        if(OS_TRUE == Os_AlarmCBTable[objId].isAlive)
        {
            Os_nextCounterTime[counterID] = Os_AlarmCBTable[objId].timeVal;
        }
#endif/*(OS_ALARM_NUMBER > 0)*/
    }

    milliSecond = Os_nextCounterTime[counterID] / OS_PL_SYSTIMER_MAX_RELOAD_VAL;
    microSecond = (Os_nextCounterTime[counterID] % OS_PL_SYSTIMER_MAX_RELOAD_VAL) % OS_PL_SYSTIMER_RESOLUTION;
    if(microSecond != 0)
    {
        microSecond = ((Os_nextCounterTime[counterID] % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION) + 1;
    }
    else
    {
        microSecond = (Os_nextCounterTime[counterID] % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION;
    }

    Os_nextCounterTime[counterID] = milliSecond*OS_PL_SYSTIMER_MAX_RELOAD_VAL + microSecond*OS_PL_SYSTIMER_RESOLUTION;
    Os_CounterTick[counterID] = Os_nextCounterTime[counterID];
    Os_treeHeadNum[counterID] = OsCnt_CheckCounter(CoreID, Os_CoreCfg[CoreID].startCntId);
    

    Os_irqProcessTime[counterID] = OS_PL_STM_LOAD - OS_PL_STM_VAL + preProcessTime;

    if(Os_treeHeadNum[counterID] != 0)
    {
        objId = (Os_uint8)(cntCfgPtr->treeQue[0].ObjId);

#if(OS_SCHTBL_NUMBER > 0)
        if(OS_FALSE == cntCfgPtr->treeQue[0].isAlarm)
        {
            if(SCHEDULETABLE_RUNNING == Os_SchTblCBTable[objId].OsSchTblState)
            {
                milliSecond = Os_SchTblCBTable[objId].timeVal / OS_PL_SYSTIMER_MAX_RELOAD_VAL;
                microSecond = ((Os_SchTblCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) % OS_PL_SYSTIMER_RESOLUTION);
                if(microSecond != 0)
                {
                    microSecond = ((Os_SchTblCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION) + 1;
                }
                else
                {                 
                    microSecond = ((Os_SchTblCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION);
                }
                Os_nextCounterTime[counterID] = milliSecond*OS_PL_SYSTIMER_MAX_RELOAD_VAL + microSecond*OS_PL_SYSTIMER_RESOLUTION;
                if(Os_nextCounterTime[counterID] != Os_SchTblCBTable[objId].timeVal)
                {
                    Os_SchTblCBTable[objId].timeVal = Os_nextCounterTime[counterID];
                    for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                    {
                        if(Os_SchTblCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                        {
                            Os_SchTblCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                        }
                    }
                }
                if(Os_SchTblCBTable[objId].timeVal > Os_CounterTick[counterID])
                {
                    if((Os_SchTblCBTable[objId].timeVal - Os_CounterTick[counterID]) < Os_irqProcessTime[counterID])
                    {
                        Os_SchTblCBTable[objId].timeVal += OS_PL_SYSTIMER_RESOLUTION;
                        Os_nextCounterTime[counterID] = Os_SchTblCBTable[objId].timeVal;
                        for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                        {
                            if(Os_SchTblCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                            {
                                Os_SchTblCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                            }
                        }
                    }
                }
                else
                {
                    if((OS_PL_SYSTIMER_MAX_RELOAD_VAL - Os_SchTblCBTable[objId].timeVal + Os_CounterTick[counterID])< Os_irqProcessTime[counterID])
                    {
                        Os_SchTblCBTable[objId].timeVal += OS_PL_SYSTIMER_RESOLUTION;
                        Os_nextCounterTime[counterID] = Os_SchTblCBTable[objId].timeVal;
                        for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                        {
                            if(Os_SchTblCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                            {
                                Os_SchTblCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                            }
                        }
                    }
                }
            }
        }
        else
#endif/*(OS_SCHTBL_NUMBER > 0)*/
        {
#if(OS_ALARM_NUMBER > 0)
            if(OS_TRUE == Os_AlarmCBTable[objId].isAlive)
            {
                milliSecond = Os_AlarmCBTable[objId].timeVal / OS_PL_SYSTIMER_MAX_RELOAD_VAL;
                microSecond = ((Os_AlarmCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) % OS_PL_SYSTIMER_RESOLUTION);
                if(microSecond != 0)
                {
                    microSecond = ((Os_AlarmCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION) + 1;
                }
                else
                {                 
                    microSecond = ((Os_AlarmCBTable[objId].timeVal % OS_PL_SYSTIMER_MAX_RELOAD_VAL) / OS_PL_SYSTIMER_RESOLUTION);
                }
                Os_nextCounterTime[counterID] = milliSecond*OS_PL_SYSTIMER_MAX_RELOAD_VAL + microSecond*OS_PL_SYSTIMER_RESOLUTION;
                if(Os_nextCounterTime[counterID] != Os_AlarmCBTable[objId].timeVal)
                {
                    Os_AlarmCBTable[objId].timeVal = Os_nextCounterTime[counterID];
                    for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                    {
                        if(Os_AlarmCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                        {
                            Os_AlarmCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                        }
                    }
                }
                if(Os_AlarmCBTable[objId].timeVal > Os_CounterTick[counterID])
                {
                    if((Os_AlarmCBTable[objId].timeVal - Os_CounterTick[counterID]) < Os_irqProcessTime[counterID])
                    {
                        Os_AlarmCBTable[objId].timeVal += OS_PL_SYSTIMER_RESOLUTION;
                        Os_nextCounterTime[counterID] = Os_AlarmCBTable[objId].timeVal;
                        for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                        {
                            if(Os_AlarmCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                            {
                                Os_AlarmCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                            }
                        }
                    }
                }
                else
                {
                    if((OS_PL_SYSTIMER_MAX_RELOAD_VAL - Os_AlarmCBTable[objId].timeVal + Os_CounterTick[counterID])< Os_irqProcessTime[counterID])
                    {
                        Os_AlarmCBTable[objId].timeVal += OS_PL_SYSTIMER_RESOLUTION;
                        Os_nextCounterTime[counterID] = Os_AlarmCBTable[objId].timeVal;
                        for(delayFlag=0; delayFlag<Os_treeHeadNum[counterID]; delayFlag++)
                        {
                            if(Os_AlarmCBTable[delayFlag].timeVal < Os_nextCounterTime[counterID])
                            {
                                Os_AlarmCBTable[delayFlag].timeVal = Os_nextCounterTime[counterID];
                            }
                        }
                    }
                }
                
                
                
            }
#endif/*(OS_ALARM_NUMBER > 0)*/
        }

        Os_irqProcessTime[counterID] = OS_PL_STM_LOAD - OS_PL_STM_VAL + preProcessTime;
        Os_SysCntRunning[CoreID] = OS_TRUE;

        if(Os_nextCounterTime[counterID] > Os_CounterTick[counterID])
        {
            OS_PL_STM_LOAD = Os_nextCounterTime[counterID] - Os_CounterTick[counterID] - Os_irqProcessTime[counterID];
        }
        else
        {
            OS_PL_STM_LOAD = OS_PL_SYSTIMER_MAX_RELOAD_VAL - Os_CounterTick[counterID] + Os_nextCounterTime[counterID] - Os_irqProcessTime[counterID];
        }
        
        OS_PL_STM_VAL = 0;
        

    }
    else
    {
        OS_PL_STM_LOAD = OS_PL_SYSTIMER_MAX_RELOAD_VAL;   /* 24bits */
        OS_PL_STM_VAL = 0;
        OS_PL_STM_CTRL |= ((Os_uint32)Os_SysTick_CTRL_ENABLE_MSK );  /* enable SysTick Timer */
        OS_PL_STM_CTRL &= (~((Os_uint32)Os_SysTick_CTRL_TICKINT_MSK ));  /* disable SysTick IRQ  */
        Os_SysCntRunning[CoreID] = OS_FALSE;
    }
    Os_LastReload[CoreID] = OS_PL_STM_LOAD;

#else/* (OS_SYSTICK_MODE == OS_HRT_MODE) */    
    OsCnt_InternalIncreaseCounter(CoreID, Os_CoreCfg[CoreID].startCntId);
#endif/* (OS_SYSTICK_MODE == OS_HRT_MODE) */    
}

/*****************************************************************************
* Os TP timer
******************************************************************************/
#if(OS_ON == OS_TP_TIMER_NEED)

/*******************************************************************************
 * Code
 ******************************************************************************/

/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_Init
*
* Description:   Init timer used by time protection
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC (void, OS_CODE) OsTpTimer_Init 
(
    CoreIdType CoreID
)
{

    Os_boolean ret;
    Os_uint32 intStatus;
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;

    /*get timer enable state*/
    ret = OsTpTimer_GetState(CoreID);
    if(ret == OS_TRUE)
    {
        OsHook_FataErrReport(CoreID,E_OS_PL_SYSFATA_REG_ERR,OSServiceId_OsTpTimer_Init,OS_IE_NOMORE_INFO, OS_IE_NO_ERRPAR, OS_IE_NO_ERRPAR, OS_IE_NO_ERRPAR);
    }
    /* Enable STIM module */
    OsCpu_SYSCTRL_EnableModule(OS_SYSCTRL_STIM);
    /* Dis STIM NVIC IRQ*/
    OS_NVIC_DisableIRQ(OS_STIM_IRQn);
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].EN = 0U;
    OS_NVIC_ClearPendingIRQ(OS_STIM_IRQn);
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].MODE = (Os_uint32)OS_STIM_FREE_COUNT;
    STIMx->STIM_CVn[OS_TPTIMER_CHANNEL].CV = (Os_uint32)OS_TP_TIMER_MAX_VALUE;
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].RSTDIS = (Os_uint32)OS_STIM_INCREASE_FROM_0;
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].CLKS = (Os_uint32)OS_PL_TPTM_CLKSOURCE;
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].PSEN = (Os_uint32)0;
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].PSDIV = (Os_uint32)0;
    /* Read the interrupt status */
    intStatus = STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].FLAG;
    /* only check enabled interrupt */
    intStatus = intStatus & STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].IE;
    /* clear the interrupt */
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].FLAG = intStatus;
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].IE = (Os_uint32)1;
    /* Enable STIM NVIC IRQ*/
    OS_NVIC_EnableIRQ(OS_STIM_IRQn);

}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_Set
*
* Description:   Set the time value and start tp timer, If timer value reached, may generate interrupt
*
* Inputs:        CoreID, value
*
* Outputs:       Os_uint32, return the current timer val
*
* Limitations:   the value is delta valus, if nessary, this funtion need to read current value and add to rel value
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_TpTickType, OS_CODE) OsTpTimer_Set
(
    CoreIdType CoreID,
    Os_TpTickType value
)
{

    Os_uint32 ctime;
    (void)CoreID;
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;
    /* Current Value of STIM */
    ctime = 0;
    STIMx->STIM_CVn[OS_TPTIMER_CHANNEL].CV = (Os_uint32)(value + ctime);
    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].EN = 1U;
    return ctime;

}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_Stop
*
* Description:   Stop the tp timer , implement as macro
*
* Inputs:        CoreID, channel
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsTpTimer_Stop
(
    CoreIdType CoreID
)
{
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;

    STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].EN = 0U;
}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_GetElapsedTime
*
* Description:   Get Elapsed time from start
*
* Inputs:        CoreID, startTime
*
* Outputs:       Os_uint32
*
* Limitations:   Not possible if timer overflow/underflow twice
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_TpTickType, OS_CODE) OsTpTimer_GetElapsedTime
(
    CoreIdType CoreID,
    Os_TpTickType startTime
)
{

    Os_TpTickType ctime = OsTpTimer_Get(CoreID);
 
    if(startTime > ctime)
    {
        /* FATA not possible */
        OsHook_FataErrReport(CoreID, E_OS_PL_SYSFATA_TP_TIMER_ERROR, OSServiceId_OsTpTimer_GetElapsedTime, OS_IE_NOMORE_INFO, startTime, ctime, OS_IE_NO_ERRPAR);
    }

    return (ctime - startTime);

}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_Get
*
* Description:   Get Current time ,implement as macro
*
* Inputs:        CoreID,
*
* Outputs:       Os_uint32
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_TpTickType, OS_CODE) OsTpTimer_Get
(
    CoreIdType CoreID
)
{
    Os_uint32 ctime;
    
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;
    (void)CoreID;
    /* Current Value of STIM */
    ctime = ((Os_uint32)STIMx->STIM_CNTn[OS_TPTIMER_CHANNEL].CNT);
    
    return ctime;
}

/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpTimer_ISR
*
* Description:  process timeing protection error
*
* Inputs:        None
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsTpTimer_ISR(void)
{ 
    Os_uint32 intStatus;
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;
    
    /* Read the interrupt status */
    intStatus = STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].FLAG;
    /* only check enabled interrupt */
    intStatus = intStatus & STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].IE;
    if((Os_uint32)0 != intStatus)
    {
        OsCpu_TpFlag = OS_TRUE;
        /* clear the interrupt */
        STIMx->STIM_SCn[OS_TPTIMER_CHANNEL].FLAG = intStatus;
        OsTp_ProtectionProcess();
    }

}





#if(OS_ON == OS_TP_FCTIMER_NEED)

/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpFcTimer_Init
*
* Description:   init fc timer
*
* Inputs:        CoreID
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(void, OS_CODE) OsTpFcTimer_Init
(
    CoreIdType CoreID
)
{
    Os_uint32 intStatus;
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;
    
    (void)CoreID;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].EN = 0U;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].MODE = (Os_uint32)OS_STIM_FREE_COUNT;
    STIMx->STIM_CVn[OS_TPFCTIMER_CHANNEL].CV = (Os_uint32)OS_TP_TIMER_MAX_VALUE;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].RSTDIS = (Os_uint32)OS_STIM_INCREASE_FROM_0;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].CLKS = (Os_uint32)OS_STIM_FUNCTION_CLOCK;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].PSEN = (Os_uint32)0;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].PSDIV = (Os_uint32)0;
    /* Read the interrupt status */
    intStatus = STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].FLAG;
    /* only check enabled interrupt */
    intStatus = intStatus & STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].IE;
    /* clear the interrupt */
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].FLAG = intStatus;
    STIMx->STIM_SCn[OS_TPFCTIMER_CHANNEL].EN = 1U;
}

/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpFcTimer_Stop
*
* Description:   Stop the fc tp timer , implement as macro
*
* Inputs:        CoreID,
*
* Outputs:       None
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
/*Has been implemented in the form of macro definitions in the Os_Pl_InternalCode.h file*/

/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpFcTimer_GetElapsedTime
*
* Description:   Get Elapsed time user by frame check
*
* Inputs:        CoreID,startTime
*
* Outputs:       Os_uint32
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_TpTickType, OS_CODE) OsTpFcTimer_GetElapsedTime
(
    CoreIdType CoreID,
    Os_TpTickType startTime
)
{
    Os_TpTickType dtime;
    Os_TpTickType ctime = OsTpFcTimer_Get(CoreID);

    if(startTime < ctime)
    {
        dtime = ctime - startTime;
    }
    else
    {
        dtime = OS_TP_FCTIMER_MAX_VALUE - (startTime - ctime);
    }


    return dtime;
}


/* BEGIN_FUNCTION_HDR
***********************************************************************************************
* Function Name: OsTpFcTimer_Get
*
* Description:   Get Current time user by frame check, implement as macro
*
* Inputs:        CoreID,
*
* Outputs:       Os_uint32
*
* Limitations:   None
***********************************************************************************************
END_FUNCTION_HDR*/
FUNC(Os_TpTickType, OS_CODE) OsTpFcTimer_Get
(
    CoreIdType CoreID
)
{
    Os_sint32 ctime;
    
    os_stim_reg_t * STIMx = (os_stim_reg_t*)OS_STIM_BASE_ADDR;
    (void)CoreID;
    /* Current Value of STIM */
    ctime = ((Os_uint32)STIMx->STIM_CNTn[OS_TPFCTIMER_CHANNEL].CNT);
    
    return ctime;
}
#endif/*#if(OS_ON == OS_TP_FCTIMER_NEED)*/
#endif/*#if(OS_ON == OS_TIMING_PROTECTION_SUPPORT)*/