/* 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 : WdgM.c ******************************************************************************** * Project/Product : AUTOSAR R21-11 * Title : Watchdog Manager module Source File * Author : Hirain ******************************************************************************** * Description : Watchdog Manager module Source File * ******************************************************************************** * Limitations : None * ******************************************************************************** * ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------ ---------- --------------- * 04.00.00 05/26/2023 Zhuoran.Lu N/A Original ******************************************************************************** * END_FILE_HDR*/ /******************************************************************************* * General QAC Suppression *******************************************************************************/ /*PRQA S 3214,0862,3614,3416 EOF*/ /* According to the requirements of AUTOSAR Specification,when locating address segments in the files of each module,#include "WdgM_MemMap.h" is required.Defined XXX_START_SEC_ will undefine in WdgM_MemMap.h. In a If statement,calling a function to directly determine the return value is allowed if there is only one judge branch. */ /*PRQA S 3432 EOF*/ /* P2VAR and other macros in the Compiler conforms to AUTOSAR standard.There's no need to revise. */ /*PRQA S 3429,3453,553 EOF*/ /* Allow the use of macrofunction access definitions, and the department is verified and there is no problem. Particularity of configuration files,the file can be void in some situations. */ /*PRQA S 3227,3204 EOF*/ /* Read-only function input parameters may not be defined as const,it does not affect the function. AUTOSAR API shall define standard input parameters according to specification requirements. */ /*PRQA S 2100,2101 EOF*/ /* Integer promotion related. */ /*PRQA S 3119 EOF*/ /* In the function,the unused input parameter use void.For example, if the input parameter is not at the postbuild level,the configset pointer in the initialization function needs to be void. */ /*PRQA S 2000 EOF*/ /* When there is only one If,there can be no else. */ /*PRQA S 3141,3138 EOF*/ /* This message can be ignored in the following cases:when the code of each module calls the code of SchM's inbound and outbound critical segments. */ /*PRQA S 857 EOF*/ /* Macro definitions exceed 1024.The number of macros is unlimited */ /*PRQA S 4570 EOF*/ /* Permission ~ operator, specific implementation methods. */ /******************************************************************************* * Includes *******************************************************************************/ #include "WdgM.h" #include "WdgIf.h" #include "SchM_WdgM.h" #if(STD_ON == WDGM_DEV_ERROR_DETECT) #include "Det.h" #endif /******************************************************************************* * Version Check *******************************************************************************/ #if(STD_ON == WDGM_PRIVATE_VERSION_CHECK) /* check Version with other import module */ /* check Version with cfg file */ #if ((WDGM_AR_RELEASE_MAJOR_VERSION != WDGM_AR_RELEASE_MAJOR_VERSION_CFG) || \ (WDGM_AR_RELEASE_MINOR_VERSION != WDGM_AR_RELEASE_MINOR_VERSION_CFG)) #error "AutoSar Version Numbers of WDGM and its cfg file are different" #endif #if ((WDGM_SW_MAJOR_VERSION != WDGM_SW_MAJOR_VERSION_CFG) || \ (WDGM_SW_MINOR_VERSION != WDGM_SW_MINOR_VERSION_CFG)) #error "SW Version Numbers of WDGM and its cfg file are different" #endif #endif/*#if(STD_ON == WDGM_PRIVATE_VERSION_CHECK)*/ /******************************************************************************* * Macro *******************************************************************************/ #if(STD_ON == WDGM_DEV_ERROR_DETECT) #define WDGM_DET_REPORT_ERROR(ApiId, errcode) \ Det_ReportError(WDGM_MODULE_ID_VALUE, WDGM_INSTANCE_ID_VALUE_0, (ApiId), (errcode)) #else #define WDGM_DET_REPORT_ERROR(ApiId, errcode) #endif #if(STD_OFF == WDGM_DEM_USED) #define WDGM_DEM_REPORT(eventId,status) #else #define WDGM_DEM_REPORT(eventId,status) Dem_SetEventStatus(eventId,status) #endif #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) #define WdgM_MULT_DEVICE_MASK ((uint8)0x01) #endif /******************************************************************************* * Local Data Define *******************************************************************************/ #if(WDGM_CORE_NUMBER > 1) #define WDGM_START_SEC_VAR_INIT_GLOBAL_8 #else #define WDGM_START_SEC_VAR_INIT_8 #endif #include "WdgM_MemMap.h" STATIC VAR(Std_InitStateType, WDGM_VAR) WdgM_InitStatus = STD_UNINITIALIZED; #if(WDGM_CORE_NUMBER > 1) STATIC VAR(WdgM_MultiMask, WDGM_VAR) WdgM_MultiDeviceMask = (WdgM_MultiMask)0; STATIC VAR(WdgM_MultiStateType, WDGM_VAR) WdgM_Multistate = WDGM_MULTI_NO_REQUEST; #if(STD_ON == WDGM_MASTER_RESET_ALL) STATIC VAR(uint8, WDGM_VAR)WdgMCoreCycleCount[WDGM_CORE_NUMBER] = {0}; #endif/*#if(STD_ON == WDGM_MASTER_RESET_ALL)*/ #else STATIC CONST(uint8, WDGM_VAR) WdgM_CoreId = (uint8)0; #endif/*#if(WDGM_CORE_NUMBER > 1)*/ #if(WDGM_CORE_NUMBER > 1) #define WDGM_STOP_SEC_VAR_INIT_GLOBAL_8 #else #define WDGM_STOP_SEC_VAR_INIT_8 #endif #include "WdgM_MemMap.h" #if(WDGM_CORE_NUMBER > 1) #define WDGM_START_SEC_VAR_NOINIT_GLOBAL_8 #else #define WDGM_START_SEC_VAR_NOINIT_8 #endif #include "WdgM_MemMap.h" STATIC VAR(WdgM_ModeType, WDGM_VAR) WdgM_runTimeModeIndex; STATIC VAR(WdgM_GlobalStatusType, WDGM_VAR) WdgM_GlobalMonitoringStatus[WDGM_CORE_NUMBER]; #if(WDGM_CORE_NUMBER > 1) #define WDGM_STOP_SEC_VAR_NOINIT_GLOBAL_8 #else #define WDGM_STOP_SEC_VAR_NOINIT_8 #endif #include "WdgM_MemMap.h" #if(WDGM_CORE_NUMBER > 1) #define WDGM_START_SEC_VAR_NOINIT_GLOBAL_16 #else #define WDGM_START_SEC_VAR_NOINIT_16 #endif #include "WdgM_MemMap.h" STATIC VAR(uint16, WDGM_VAR) WdgM_GStatusExpired_Cnt[WDGM_CORE_NUMBER]; STATIC VAR(WdgM_SupervisedEntityIdType, WDGM_VAR) WdgM_FirstExpSeId; STATIC VAR(WdgM_SupervisedEntityIdType, WDGM_VAR) WdgM_FirstExpSeIdInv; #if(WDGM_CORE_NUMBER > 1) #define WDGM_STOP_SEC_VAR_NOINIT_GLOBAL_16 #else #define WDGM_STOP_SEC_VAR_NOINIT_16 #endif #include "WdgM_MemMap.h" #if(WDGM_CORE_NUMBER > 1) #define WDGM_START_SEC_VAR_NOINIT_GLOBAL_UNSPECIFIED #else #define WDGM_START_SEC_VAR_NOINIT_UNSPECIFIED #endif #include "WdgM_MemMap.h" STATIC P2CONST(WdgM_ConfigType, WDGM_VAR_NOINIT, WDGM_CONST) WdgM_runTimeConfig; STATIC P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_CONST) WdgM_runTimeMode; #if(WDGM_CORE_NUMBER > 1) STATIC VAR(WdgM_SpinLockFlagType, WDGM_VAR) WdgM_ModeLockFalg; STATIC VAR(WdgM_SpinLockFlagType, WDGM_VAR) WdgM_MultiMaskFalg; #if(STD_ON == WDGM_MASTER_RESET_ALL) STATIC VAR(WdgM_SpinLockFlagType, WDGM_VAR) WdgMCoreCycleCountFlag[WDGM_CORE_NUMBER]; #endif/*#if(STD_ON == WDGM_MASTER_RESET_ALL)*/ #if(WDGM_TOTAL_FLOW_NUM > 0) STATIC VAR(WdgM_SpinLockFlagType, WDGM_VAR) WdgM_FlowSLockFalg[WDGM_USED_FLOW_NUM]; #endif/*(WDGM_TOTAL_FLOW_NUM > 0)*/ #endif/*(WDGM_CORE_NUMBER > 1)*/ #if(WDGM_CORE_NUMBER > 1) #define WDGM_STOP_SEC_VAR_NOINIT_GLOBAL_UNSPECIFIED #else #define WDGM_STOP_SEC_VAR_NOINIT_UNSPECIFIED #endif #include "WdgM_MemMap.h" /******************************************************************************* * Private Function Define *******************************************************************************/ #define WDGM_START_SEC_CODE #include "WdgM_MemMap.h" #if(STD_OFF == WDGM_OFF_MODE_ENABLED) STATIC FUNC(boolean, WDGM_CODE) WdgM_HasWdgOffMode ( WdgM_ModeType Mode ); #endif STATIC FUNC(void, WDGM_CODE) WdgM_setWdgMode(void); STATIC FUNC(void, WDGM_CODE) WdgM_setTriggerValue ( uint8 CoreId ); #if(WDGM_TOTAL_FLOW_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetFlow(void); #endif #if(WDGM_TOTAL_ALIVE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetAliveMonitor(void); #endif #if(WDGM_TOTAL_DEADLINE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetDeadlineMonitor(void); STATIC FUNC(void, WDGM_CODE) WdgM_DeadlineCheck ( WdgM_SupervisedEntityIdType SEID, WdgM_CheckpointIdType CheckpointID ); #endif #if(WDGM_TOTAL_FLOW_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_TransitionCheck ( WdgM_SupervisedEntityIdType SEID, WdgM_CheckpointIdType CheckpointID ); #endif #if(WDGM_TOTAL_ALIVE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_AliveMonitorMainFunction ( uint8 CoreId ); #endif #if(STD_ON == WDGM_ENABLE_TIMEOUT_DETECTION) STATIC FUNC(void, WDGM_CODE) WdgM_DeadlineMonitorMainFunction ( uint8 CoreId ); #endif STATIC FUNC(void, WDGM_CODE) WdgM_UpdateGlobalStatus ( uint8 CoreId ); STATIC FUNC(void, WDGM_CODE) WdgM_UpdateLocalStatus ( uint8 CoreId ); STATIC FUNC(boolean, WDGM_CODE) WdgM_IsSEActiveInCurrentMode ( WdgM_SupervisedEntityIdType se ); STATIC FUNC(void, WDGM_CODE) WdgM_ChangeLocalMode ( WdgM_SupervisedEntityIdType seid, WdgM_LocalStatusType status ); STATIC FUNC(void, WDGM_CODE) WdgM_ChangeGlobalMode ( uint8 CoreId, WdgM_GlobalStatusType status ); #if(WDGM_CORE_NUMBER > 1) STATIC FUNC(void, WDGM_CODE) WdgM_ModeEffectStatus ( void ); STATIC FUNC(boolean, WDGM_CODE) WdgM_MultiExecute ( uint8 CoreId ); #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ChangeLocalMode * * Description: update local se's status,and indication to rte * * Inputs: seid ,status * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_ChangeLocalMode ( WdgM_SupervisedEntityIdType seid, WdgM_LocalStatusType status ) { uint8 rte_status = (uint8)status; if(status != WdgM_LocalMonitoringStatus[seid]) { WdgM_LocalMonitoringStatus[seid] = status; if(NULL_PTR != WdgMSupervisedEntity[seid].seModeInd) { (void)WdgMSupervisedEntity[seid].seModeInd(rte_status); /*SWS_WdgM_00197*/ } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ChangeGlobalMode * * Description: update global status,and indication to rte * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_ChangeGlobalMode ( uint8 CoreId, WdgM_GlobalStatusType status ) { uint8 rte_status = (uint8)status; #if(STD_ON == WDGM_IMMEDIATE_RESET) if(WDGM_GLOBAL_STATUS_STOPPED == status) { /* perform immediate reset SWS_WdgM_00133 134 dont notification if immReset */ Mcu_PerformReset(); } #endif if(status != WdgM_GlobalMonitoringStatus[CoreId]) { WdgM_GlobalMonitoringStatus[CoreId] = status; if(NULL_PTR != WdgM_GlobalStatusInd) { (void)WdgM_GlobalStatusInd(rte_status); /*SWS_WdgM_00198 199*/ } } #if(STD_ON == WDGM_MASTER_RESET_ALL) if(WDGM_GLOBAL_STATUS_STOPPED == status) { WdgM_GlobalMonitoringStatus[WDGM_CORE_MASTER_ID] = WDGM_GLOBAL_STATUS_STOPPED; } #endif } #if(STD_OFF == WDGM_OFF_MODE_ENABLED) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_HasWdgOffMode * * Description: check if current wdgM mode has wdg off mode * * Inputs: None * * Outputs: boolean * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(boolean, WDGM_CODE) WdgM_HasWdgOffMode ( WdgM_ModeType Mode ) { boolean retValue = FALSE; uint8 index; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = &WdgM_runTimeConfig->WdgMMode[Mode]; for(index = ((uint8)0); index < runTimeMode->numOfTrigger; index++) { if(WDGIF_OFF_MODE == runTimeMode->WdgMTrigger[index].WdgMWatchdogMode) { retValue = TRUE; break; } } return retValue; } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_setWdgMode * * Description: Called in Init and SetMode, * when new WdgM Mode is entered, new wdg Mode need to be set * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_setWdgMode(void) { uint8 dogIndex; Std_ReturnType ret = E_NOT_OK; P2CONST(WdgM_TriggerType, AUTOMATIC, WDGM_CONST) dog = NULL_PTR; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; /* switch dog mode */ for(dogIndex = ((uint8)0); dogIndex < runTimeMode->numOfTrigger; dogIndex++) { dog = &(runTimeMode->WdgMTrigger[dogIndex]); #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) if(dog->DeviceCoreId == WDGM_GET_CORE_ID()) #endif { ret = WdgIf_SetMode(dog->WdgMWatchdogDeviceRef, dog->WdgMWatchdogMode); if(E_NOT_OK == ret) { /*SWS_WdgM_00186 if mode switch failed, set global status stop and reset */ WdgM_ChangeGlobalMode(dog->DeviceCoreId, WDGM_GLOBAL_STATUS_STOPPED); WDGM_DET_REPORT_ERROR(WDGM_SETMODE_APIID, WDGM_E_SET_MODE); break; } } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_setTriggerValue * * Description: Called in Mainfunction, * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_setTriggerValue ( uint8 CoreId ) { uint8 dogIndex; /*PRQA S 3203 ++*/ /* dogDevice will be used. */ uint8 dogDevice; /*PRQA S 3203 --*/ uint16 value; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; /* SWS_WdgM_00223 DEACTIVATED don't call WdgIf_SetTriggerCondition SWS_WdgM_00122 stop trigger 0 SWS_WdgM_00120 121 other trigger normal SWS_WdgM_00119 not trigger off mode dog */ if(WDGM_GLOBAL_STATUS_DEACTIVATED != WdgM_GlobalMonitoringStatus[CoreId]) { for(dogIndex = ((uint8)0); dogIndex < runTimeMode->numOfTrigger; dogIndex++) { if((WDGIF_OFF_MODE != runTimeMode->WdgMTrigger[dogIndex].WdgMWatchdogMode)\ && (runTimeMode->WdgMTrigger[dogIndex].DeviceCoreId == CoreId)) { dogDevice = runTimeMode->WdgMTrigger[dogIndex].WdgMWatchdogDeviceRef; value = runTimeMode->WdgMTrigger[dogIndex].WdgMTriggerConditionValue; if(WDGM_GLOBAL_STATUS_STOPPED == WdgM_GlobalMonitoringStatus[CoreId]) { value = ((uint16)0); } WdgIf_SetTriggerCondition(dogDevice, value); } } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ResetFlow * * Description: Init flow related sw vars * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_FLOW_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetFlow(void) { uint16 i; for(i = ((uint16)0); i < WDGM_USED_FLOW_NUM; i++) { #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) WDGM_GET_SPINLOCK(&WdgM_FlowSLockFalg[i]); #endif WdgM_FlowActiveFlag[i] = FALSE; WdgM_LastCP[i] = WDGM_INVALID_CP; #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) WDGM_RELEASE_SPINLOCK(&WdgM_FlowSLockFalg[i]); #endif } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ResetAliveMonitor * * Description: Init alive related sw vars * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_ALIVE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetAliveMonitor(void) { uint16 i; for(i = ((uint16)0); i < WDGM_USED_ALIVE_NUM; i++) { WdgM_AliveCycle[i] = ((uint16)0); WdgM_AliveCnt[i] = ((uint16)0); } for(i = ((uint16)0); i < WDGM_TOTAL_SE_NUM; i++) { WdgM_LocalFailedCnt[i] = ((uint8)0); } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ResetDeadlineMonitor * * Description: Init deadline related sw vars * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_DEADLINE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_ResetDeadlineMonitor(void) { uint16 i; for(i = ((uint16)0); i < WDGM_USED_DEADLINE_NUM; i++) { WdgM_DeadlineState[i] = WDGM_DEADLINE_INACTIVE; WdgM_DeadlineSavedTick[i] = ((TickType)0); } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_TransitionCheck * * Description: Called only in WdgM_CheckpointReached, check tr * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_FLOW_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_TransitionCheck ( WdgM_SupervisedEntityIdType SEID, WdgM_CheckpointIdType CheckpointID ) { WdgM_CheckpointIdType srcCP; uint16 start; uint16 end ; uint16 i; boolean hasValidTr = FALSE; uint16 flowIndex; /*PRQA S 3203 ++*/ /* CrossCoreFlag will be used. */ boolean CrossCoreFlag = FALSE; /*PRQA S 3203 --*/ P2CONST(WdgM_CheckpointIdType, AUTOMATIC, WDGM_CONST) flowPtr = NULL_PTR; uint8 flowCpType; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; boolean docheckflag = FALSE; boolean RecordInternalFlow = FALSE; /* decide the flow this cp belongs to if ext flow , use ext flow first, if no ext flow , use internal flow , */ /*SWS_WdgM_00295*/ if(NULL_PTR != runTimeMode->WdgCpInMode[CheckpointID].FlowPtr) { flowPtr = runTimeMode->WdgCpInMode[CheckpointID].FlowPtr; flowCpType = runTimeMode->WdgCpInMode[CheckpointID].flowCpType; start = runTimeMode->WdgCpInMode[CheckpointID].trOffset; end = start + runTimeMode->WdgCpInMode[CheckpointID].trNum; flowIndex = runTimeMode->WdgCpInMode[CheckpointID].flowIndex; CrossCoreFlag = runTimeMode->WdgCpInMode[CheckpointID].flowCpFlag; docheckflag = TRUE; } do { if(docheckflag == TRUE) { #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) if(CrossCoreFlag == TRUE) { WDGM_GET_SPINLOCK(&WdgM_FlowSLockFalg[flowIndex]); } #endif /*SWS_WdgM_00274 252*/ if(FALSE == WdgM_FlowActiveFlag[flowIndex]) { if(WDGM_CP_FLOW_INIT == flowCpType) { WdgM_FlowActiveFlag[flowIndex] = TRUE;/*SWS_WdgM_00332 273*/ } else { WdgM_ErrFlag[SEID] |= WDGM_FLOW_ERROR; } } else { srcCP = WdgM_LastCP[flowIndex]; for(i = start; i < end; i++) { if(srcCP == flowPtr[i]) { hasValidTr = TRUE; break; } } if(FALSE == hasValidTr) { WdgM_ErrFlag[SEID] |= WDGM_FLOW_ERROR; } if(WDGM_CP_FLOW_END == flowCpType) { WdgM_FlowActiveFlag[flowIndex] = FALSE;/*SWS_WdgM_00331 329*/ } } /*SWS_WdgM_00246*/ WdgM_LastCP[flowIndex] = CheckpointID; #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) if(CrossCoreFlag == TRUE) { WDGM_RELEASE_SPINLOCK(&WdgM_FlowSLockFalg[flowIndex]); } #endif } if((NULL_PTR != WdgMCheckPoint[CheckpointID].FlowPtr) && (RecordInternalFlow == FALSE)) { flowPtr = WdgMCheckPoint[CheckpointID].FlowPtr; flowCpType = WdgMCheckPoint[CheckpointID].flowCpType; start = WdgMCheckPoint[CheckpointID].trOffset; end = start + WdgMCheckPoint[CheckpointID].trNum; flowIndex = WdgMCheckPoint[CheckpointID].flowIndex; docheckflag = TRUE; RecordInternalFlow = TRUE; } else { docheckflag = FALSE; } } while(docheckflag == TRUE); } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_DeadlineCheck * * Description: Called only in WdgM_CheckpointReached, check deadline * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_DEADLINE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_DeadlineCheck ( WdgM_SupervisedEntityIdType SEID, WdgM_CheckpointIdType CheckpointID ) { uint16 deadlineIndex ; CounterType cntIndex = WdgMSupervisedEntity[SEID].osCounterRef; TickType eTick; uint16 deadlineCnt; P2CONST(WdgM_DeadlineSupervisionType, AUTOMATIC, WDGM_CONST) deadlinePtr = NULL_PTR; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; P2CONST(WdgM_CheckPointInModeCfgType, AUTOMATIC, WDGM_CONST) cpModeCfg = &runTimeMode->WdgCpInMode[CheckpointID]; /* SWS_WdgM_00374 374 228 229 294 check if this deadline point is enabled in this mode */ for(deadlineCnt = ((uint16)0); deadlineCnt < cpModeCfg->DeadlineNum; deadlineCnt++) { deadlineIndex = cpModeCfg->DeadlinePtr[deadlineCnt]; deadlinePtr = &runTimeMode->WdgMDeadlineSupervision[deadlineIndex]; if(CheckpointID == deadlinePtr->WdgMDeadlineStartRef) { /* dont break , 1 CP may belong to different deadline */ if(E_OK == WdgM_GetElapsedValue(cntIndex, &WdgM_DeadlineSavedTick[deadlineIndex], &eTick)) { WdgM_DeadlineState[deadlineIndex] = WDGM_DEADLINE_BUSY; } } if(CheckpointID == deadlinePtr->WdgMDeadlineStopRef) { /* dont break , 1 CP may belong to different deadline */ if(WDGM_DEADLINE_BUSY == WdgM_DeadlineState[deadlineIndex]) { if(E_OK == WdgM_GetElapsedValue(cntIndex, &WdgM_DeadlineSavedTick[deadlineIndex], &eTick)) { WdgM_DeadlineSavedTick[deadlineIndex] = ((TickType)0); if((eTick < deadlinePtr->WdgMDeadlineMin) || (eTick > deadlinePtr->WdgMDeadlineMax)) { WdgM_ErrFlag[SEID] |= WDGM_DEADLINE_ERROR; } } WdgM_DeadlineState[deadlineIndex] = WDGM_DEADLINE_INACTIVE; } } } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_AliveMonitorMainFunction * * Description: Called only in mainfuntion, do the alive check alg * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(WDGM_TOTAL_ALIVE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_AliveMonitorMainFunction ( uint8 CoreId ) { WdgM_CheckpointIdType cpId; WdgM_SupervisedEntityIdType seId; uint16 aliveIndex; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; uint16 maxAliveInMode = runTimeMode->numOfAlive; P2CONST(WdgM_AliveSupervisionType, AUTOMATIC, WDGM_CONST) alive = NULL_PTR; for(aliveIndex = ((uint16)0); aliveIndex < maxAliveInMode; aliveIndex++) { alive = &runTimeMode->WdgMAliveSupervision[aliveIndex]; cpId = alive->WdgMAliveSupervisionCheckpointRef; seId = WdgMCheckPoint[cpId].seRef; if(WdgMSupervisedEntity[seId].CoreId == CoreId) { /*SWS_WdgM_00074 115*/ if((WDGM_LOCAL_STATUS_DEACTIVATED != WdgM_LocalMonitoringStatus[seId])\ && (WDGM_LOCAL_STATUS_EXPIRED != WdgM_LocalMonitoringStatus[seId])) { if(WdgM_AliveCycle[aliveIndex] < alive->WdgMSupervisionReferenceCycle) { WdgM_AliveCycle[aliveIndex]++; } if(WdgM_AliveCycle[aliveIndex] >= alive->WdgMSupervisionReferenceCycle) /*SWS_WdgM_00098*/ { WdgM_ErrFlag[seId] |= WDGM_ALIVE_ERROR_TEMP; if((WdgM_AliveCnt[aliveIndex] < alive->WdgMMinMargin) || (WdgM_AliveCnt[aliveIndex] > alive->WdgMMaxMargin)) { WdgM_ErrFlag[seId] |= WDGM_ALIVE_ERROR; } WdgM_AliveCycle[aliveIndex] = ((uint16)0); WdgM_AliveCnt[aliveIndex] = ((uint16)0); } if(WdgM_AliveCycle[aliveIndex] != ((uint16)0)) { WdgM_ErrFlag[seId] |= WDGM_ALIVE_ERROR_WAIT; } } } } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_DeadlineMonitorMainFunction * * Description: Called only in WdgM_MainFunction, do the deadline check * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(STD_ON == WDGM_ENABLE_TIMEOUT_DETECTION) #if(WDGM_TOTAL_DEADLINE_NUM > 0) STATIC FUNC(void, WDGM_CODE) WdgM_DeadlineMonitorMainFunction ( uint8 CoreId ) { WdgM_SupervisedEntityIdType SEID; WdgM_CheckpointIdType StartCheckpointID; uint16 deadlineIndex; CounterType cntIndex; TickType TickRecorded; TickType eTick; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; uint16 maxDeadlineInMode = runTimeMode->numOfDeadline; P2CONST(WdgM_DeadlineSupervisionType, AUTOMATIC, WDGM_CONST) deadlinePtr = NULL_PTR; for(deadlineIndex = ((uint16)0); deadlineIndex < maxDeadlineInMode; deadlineIndex++) { if(WDGM_DEADLINE_BUSY == WdgM_DeadlineState[deadlineIndex]) { StartCheckpointID = runTimeMode->WdgMDeadlineSupervision[deadlineIndex].WdgMDeadlineStartRef; SEID = WdgMCheckPoint[StartCheckpointID].seRef; if((WdgMSupervisedEntity[SEID].CoreId == CoreId)\ && (WdgM_LocalMonitoringStatus[SEID] <= WDGM_LOCAL_STATUS_FAILED)) { cntIndex = WdgMSupervisedEntity[SEID].osCounterRef; deadlinePtr = &(runTimeMode->WdgMDeadlineSupervision[deadlineIndex]); TickRecorded = WdgM_DeadlineSavedTick[deadlineIndex]; if(E_OK == WdgM_GetElapsedValue(cntIndex, &TickRecorded, &eTick)) { if(eTick > (deadlinePtr->WdgMDeadlineMax)) { WdgM_ErrFlag[SEID] |= WDGM_DEADLINE_ERROR; WdgM_DeadlineState[deadlineIndex] = WDGM_DEADLINE_INACTIVE; } } } } } } #endif #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_UpdateGlobalStatus * * Description: Called in mainfuntion and setMode, update global status * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_UpdateGlobalStatus ( uint8 CoreId ) { WdgM_SupervisedEntityIdType seCnt; boolean expiredFlag = FALSE; boolean failFlag = FALSE; /*SWS_WdgM_00078 76 215 217 218 77 117 219*/ /* update globa status based on all se's status*/ /* there may be expire se in other mode's se*/ for(seCnt = ((WdgM_SupervisedEntityIdType)0); seCnt < WDGM_TOTAL_SE_NUM; seCnt++) { if(CoreId == WdgMSupervisedEntity[seCnt].CoreId) { if(WdgM_LocalMonitoringStatus[seCnt] == WDGM_LOCAL_STATUS_EXPIRED) { expiredFlag = TRUE; break; } if(WdgM_LocalMonitoringStatus[seCnt] == WDGM_LOCAL_STATUS_FAILED) { failFlag = TRUE; } } } /* change global status based on all se's status*/ if(TRUE == expiredFlag) { if(((uint16)0) == WdgM_runTimeMode->WdgMExpiredSupervisionCycleTol) { WdgM_ChangeGlobalMode(CoreId, WDGM_GLOBAL_STATUS_STOPPED); } else { /* expired will be switch to stop after time out*/ WdgM_ChangeGlobalMode(CoreId, WDGM_GLOBAL_STATUS_EXPIRED); } } else { if(TRUE == failFlag) { WdgM_ChangeGlobalMode(CoreId, WDGM_GLOBAL_STATUS_FAILED); } else { WdgM_ChangeGlobalMode(CoreId, WDGM_GLOBAL_STATUS_OK); } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_UpdateLocalStatus * * Description: Called only in mainfuntion, update se's local status of active mode * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_UpdateLocalStatus ( uint8 CoreId ) { WdgM_SupervisedEntityIdType seCnt = ((WdgM_SupervisedEntityIdType)0); WdgM_SupervisedEntityIdType seindex = ((WdgM_SupervisedEntityIdType)0); WdgM_SupervisedEntityIdType FirstExpSeIdInv = ((WdgM_SupervisedEntityIdType)0); P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; for(seCnt = ((WdgM_SupervisedEntityIdType)0); seCnt < runTimeMode->numOfLocalStatus; seCnt++) { seindex = runTimeMode->WdgMLocalStatusParams[seCnt].WdgMLocalStatusSupervisionEntityRef; if(WdgMSupervisedEntity[seindex].CoreId == CoreId) { /*SWS_WdgM_00202 203 204 205 300 206*/ if(((uint8)0) != ((uint8)(WdgM_ErrFlag[seindex] & WDGM_FLOW_DEADLINE_MASK))) { /*flow or deadline err, */ WdgM_ChangeLocalMode(seindex, WDGM_LOCAL_STATUS_EXPIRED); #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_LocalFailedCnt[seindex] = ((uint8)0); #endif } #if(WDGM_TOTAL_ALIVE_NUM > 0) else { /* alive err */ if(((uint8)0) != ((uint8)(WdgM_ErrFlag[seindex] & WDGM_ALIVE_ERROR_TEMP))) { if(((uint8)0) != ((uint8)(WdgM_ErrFlag[seindex] & WDGM_ALIVE_ERROR))) { if(WdgM_LocalFailedCnt[seindex] >= runTimeMode->WdgMLocalStatusParams[seCnt].WdgMFailedAliveSupervisionRefCycleTol) { WdgM_LocalFailedCnt[seindex] = ((uint8)0); WdgM_ChangeLocalMode(seindex, WDGM_LOCAL_STATUS_EXPIRED); } else { WdgM_ChangeLocalMode(seindex, WDGM_LOCAL_STATUS_FAILED); } if(WdgM_LocalFailedCnt[seindex] < runTimeMode->WdgMLocalStatusParams[seCnt].WdgMFailedAliveSupervisionRefCycleTol) { WdgM_LocalFailedCnt[seindex]++; } } else { /* no alive err for this cycle */ if((WDGM_LOCAL_STATUS_FAILED == WdgM_LocalMonitoringStatus[seindex])\ && ((((uint8)0) == ((uint8)(WdgM_ErrFlag[seindex] & WDGM_ALIVE_ERROR_WAIT))))) { if(WdgM_LocalFailedCnt[seindex] > ((uint8)0)) { WdgM_LocalFailedCnt[seindex]--; } if(((uint8)0) == WdgM_LocalFailedCnt[seindex]) { WdgM_ChangeLocalMode(seindex, WDGM_LOCAL_STATUS_OK); } } } } } #endif WdgM_ErrFlag[seindex] = WDGM_NO_ERROR; if(WDGM_LOCAL_STATUS_EXPIRED == WdgM_LocalMonitoringStatus[seindex]) { FirstExpSeIdInv = (WdgM_SupervisedEntityIdType)(~WdgM_FirstExpSeIdInv); /* SWS_WdgM_00351 check if this is the first expired se, and save it*/ if(WdgM_FirstExpSeId != FirstExpSeIdInv) { WdgM_FirstExpSeId = seindex; WdgM_FirstExpSeIdInv = (WdgM_SupervisedEntityIdType)(~seindex); } } } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_IsSEActiveInCurrentMode * * Description: Called only in mainfuntion, update se's local status of active mode * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(boolean, WDGM_CODE) WdgM_IsSEActiveInCurrentMode ( WdgM_SupervisedEntityIdType se ) { boolean ret = FALSE; WdgM_SupervisedEntityIdType i; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; for(i = ((WdgM_SupervisedEntityIdType)0); i < runTimeMode->numOfLocalStatus; i++) { if(se == runTimeMode->WdgMLocalStatusParams[i].WdgMLocalStatusSupervisionEntityRef) { ret = TRUE; break; } } return ret; } #if(WDGM_CORE_NUMBER > 1) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_ModeEffectStatus * * Description: Called only in mainfuntion, update se's local status of active mode * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, WDGM_CODE) WdgM_ModeEffectStatus ( void ) { WdgM_SupervisedEntityIdType i = (WdgM_SupervisedEntityIdType)0; uint8 CoreId = WDGM_GET_CORE_ID(); /*SWS_WdgM_00182:if SE is both actived in old and new mode, this SE's status cannot be changed only start a new monitor cycle*/ for(i = ((WdgM_SupervisedEntityIdType)0); i < WDGM_TOTAL_SE_NUM; i++) { /*SWS_WdgM_00207 SWS_WdgM_00291, only ok or failed se canbe change to deactive expired will keep unchange */ if(CoreId == WdgMSupervisedEntity[i].CoreId) { if(FALSE == WdgM_IsSEActiveInCurrentMode(i)) { if(WdgM_LocalMonitoringStatus[i] < WDGM_LOCAL_STATUS_EXPIRED) { WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_DEACTIVATED); } } else { /*SWS_WdgM_00209 , if new mode has the se, se will be set ok, but if old state is expired, this will not change*/ if(WdgM_LocalMonitoringStatus[i] == WDGM_LOCAL_STATUS_DEACTIVATED) { WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_OK); } } WdgM_ErrFlag[i] = WDGM_NO_ERROR; } } /* updata global status, may have fail SE */ WdgM_UpdateGlobalStatus(CoreId); WdgM_setWdgMode(); } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_MultiExecute * * Description: Called only in mainfuntion, need to synchronize Init/DeInit/SetMode/PerformReset * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(boolean, WDGM_CODE) WdgM_MultiExecute ( uint8 CoreId ) { boolean Executeflag = FALSE; if(WDGM_MULTI_REQUEST_INIT == WdgM_Multistate) { WDGM_GET_SPINLOCK(&WdgM_MultiMaskFalg); if((WdgM_MultiDeviceMask & (WdgM_MULT_DEVICE_MASK << CoreId)) != 0) { /* switch dog mode */ WdgM_setWdgMode(); WdgM_MultiDeviceMask &= (~(WdgM_MULT_DEVICE_MASK << CoreId)); } if(WdgM_MultiDeviceMask == (uint8)0) { WdgM_Multistate = WDGM_MULTI_NO_REQUEST; WdgM_InitStatus = STD_INITIALIZED; } WDGM_RELEASE_SPINLOCK(&WdgM_MultiMaskFalg); Executeflag = TRUE; } else if(WDGM_MULTI_REQUEST_UNINIT == WdgM_Multistate) { SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); WDGM_GET_SPINLOCK(&WdgM_MultiMaskFalg); if((WdgM_MultiDeviceMask & (WdgM_MULT_DEVICE_MASK << CoreId)) != 0) { /* switch dog mode */ WdgM_setTriggerValue(CoreId); WdgM_MultiDeviceMask &= (~(WdgM_MULT_DEVICE_MASK << CoreId)); } if(WdgM_MultiDeviceMask == (uint8)0) { WdgM_Multistate = WDGM_MULTI_NO_REQUEST; WdgM_InitStatus = STD_UNINITIALIZED; } WDGM_RELEASE_SPINLOCK(&WdgM_MultiMaskFalg); SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); Executeflag = TRUE; } else if(WDGM_MULTI_REQUEST_SET_MODE == WdgM_Multistate) { WDGM_GET_SPINLOCK(&WdgM_MultiMaskFalg); if((WdgM_MultiDeviceMask & (WdgM_MULT_DEVICE_MASK << CoreId)) != 0) { WdgM_ModeEffectStatus(); WdgM_MultiDeviceMask &= (~(WdgM_MULT_DEVICE_MASK << CoreId)); } if(WdgM_MultiDeviceMask == (uint8)0) { #if(WDGM_TOTAL_FLOW_NUM > 0) WdgM_ResetFlow(); #endif /* alive */ #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_ResetAliveMonitor(); #endif /* deadline */ #if(WDGM_TOTAL_DEADLINE_NUM > 0) WdgM_ResetDeadlineMonitor(); #endif WdgM_Multistate = WDGM_MULTI_NO_REQUEST; } WDGM_RELEASE_SPINLOCK(&WdgM_MultiMaskFalg); Executeflag = TRUE; } else if(WDGM_MULTI_REQUEST_PERFORMRESET == WdgM_Multistate) { WdgIf_SetTriggerCondition(CoreId, ((uint16)0)); /* SWS_WdgM_00233 reset global status, so that the condition value will not be updated anymore */ WdgM_ChangeGlobalMode(CoreId, WDGM_GLOBAL_STATUS_DEACTIVATED); WdgM_Multistate = WDGM_MULTI_NO_REQUEST; Executeflag = TRUE; } else { /*do nothing*/ } return Executeflag; } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_CheckSlaveRunStatus * * Description: Called only in mainfuntion, Check Slave running state * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if(STD_ON == WDGM_MASTER_RESET_ALL) STATIC FUNC(void, WDGM_CODE) WdgM_CheckSlaveRunStatus ( void ) { WdgM_MultiMask CoreId; uint8 Counter; for(CoreId = (WdgM_MultiMask)1; CoreId < (WdgM_MultiMask)WDGM_CORE_NUMBER; CoreId++) { WDGM_GET_SPINLOCK(&WdgMCoreCycleCountFlag[CoreId]); if((WdgMCoreCycleCount[CoreId] > ((uint8)WDGM_MAINFUNCTION_COUNT_MAX))\ || (WdgMCoreCycleCount[CoreId] < ((uint8)WDGM_MAINFUNCTION_COUNT_MIN))) { WdgM_ChangeGlobalMode(WDGM_CORE_MASTER_ID, WDGM_GLOBAL_STATUS_STOPPED); } WdgMCoreCycleCount[CoreId] = (uint8)0; WDGM_RELEASE_SPINLOCK(&WdgMCoreCycleCountFlag[CoreId]); } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_Init SWS_WdgM_00151 * * Description: Wdg Manager Init * * Inputs: ConfigPtr * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, WDGM_CODE) WdgM_Init ( P2CONST(WdgM_ConfigType, AUTOMATIC, WDGM_CONST) ConfigPtr ) { uint8 CoreIndex = ((uint8)0); WdgM_SupervisedEntityIdType i = ((WdgM_SupervisedEntityIdType)0); if(STD_UNINITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_INIT_APIID, WDGM_E_NO_DEINIT); } #if(WDGM_CORE_NUMBER > 1) else if(WDGM_CORE_MASTER_ID != WDGM_GET_CORE_ID()) { /*Multi-Core Support*/ /*WdgM_Init must be called by the main core*/ WDGM_DET_REPORT_ERROR(WDGM_INIT_APIID, WDGM_E_CORE_MISMATCH); } #endif #if(WDGM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD) else if(NULL_PTR == ConfigPtr) { WDGM_DET_REPORT_ERROR(WDGM_INIT_APIID, WDGM_E_NULL_POINTER); } #endif else { /*SWS_WdgM_00018*/ #if(WDGM_CONFIG_VARIANTS != STD_CONFIG_VARIANTS_POSTBUILD) (void) ConfigPtr; WdgM_runTimeConfig = &WdgM_Config[0]; #else WdgM_runTimeConfig = ConfigPtr; #endif /*SWS_WdgM_00010*/ if(WdgM_runTimeConfig->WdgMInitialMode >= WdgM_runTimeConfig->WdgMNumOfMode) { WDGM_DET_REPORT_ERROR(WDGM_INIT_APIID, WDGM_E_PARAM_CONFIG); } else { WdgM_runTimeModeIndex = WdgM_runTimeConfig->WdgMInitialMode; WdgM_runTimeMode = &WdgM_runTimeConfig->WdgMMode[WdgM_runTimeModeIndex]; #if(STD_OFF == WDGM_OFF_MODE_ENABLED) if(TRUE == WdgM_HasWdgOffMode(WdgM_runTimeModeIndex))/*SWS_WdgM_00030*/ { WDGM_DET_REPORT_ERROR(WDGM_INIT_APIID, WDGM_E_DISABLE_NOT_ALLOWED); } else #endif { /* first set all state to deactive, then set ok, this will cause mode indication to rte*/ for(i = ((WdgM_SupervisedEntityIdType)0); i < WDGM_TOTAL_SE_NUM; i++) { WdgM_LocalMonitoringStatus[i] = WDGM_LOCAL_STATUS_DEACTIVATED; } for(CoreIndex = (uint8)0; CoreIndex < (uint8)WDGM_CORE_NUMBER; CoreIndex++) { WdgM_GlobalMonitoringStatus[CoreIndex] = WDGM_GLOBAL_STATUS_DEACTIVATED; } /* SWS_WdgM_00269 reset all se's local status */ for(i = ((WdgM_SupervisedEntityIdType)0); i < WDGM_TOTAL_SE_NUM; i++) { if(TRUE == WdgM_IsSEActiveInCurrentMode(i)) { /* SWS_WdgM_00268 active se of init mode */ WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_OK); #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_LocalFailedCnt[i] = ((uint8)0); #endif } WdgM_ErrFlag[i] = WDGM_NO_ERROR; } /* global variable */ for(CoreIndex = (uint8)0; CoreIndex < (uint8)WDGM_CORE_NUMBER; CoreIndex++) { WdgM_GStatusExpired_Cnt[CoreIndex] = ((uint16)0); WdgM_ChangeGlobalMode(CoreIndex, WDGM_GLOBAL_STATUS_OK);/*SWS_WdgM_00285*/ #if(STD_ON == WDGM_MASTER_RESET_ALL) WdgMCoreCycleCountFlag[CoreIndex] = WDGM_FLAG_INIT_VALUE; #endif } #if(WDGM_TOTAL_FLOW_NUM > 0)/*SWS_WdgM_00296*/ #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) for(i = ((uint16)0); i < WDGM_USED_FLOW_NUM; i++) { WdgM_FlowSLockFalg[i] = WDGM_FLAG_INIT_VALUE; } #endif WdgM_ResetFlow(); #endif /* alive */ #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_ResetAliveMonitor(); #endif /* deadline SWS_WdgM_00298*/ #if(WDGM_TOTAL_DEADLINE_NUM > 0) WdgM_ResetDeadlineMonitor(); #endif /*SWS_WdgM_00370*/ WdgM_FirstExpSeId = ((WdgM_SupervisedEntityIdType)0); WdgM_FirstExpSeIdInv = ((WdgM_SupervisedEntityIdType)0); #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) WdgM_ModeLockFalg = WDGM_FLAG_INIT_VALUE; WdgM_MultiMaskFalg = WDGM_FLAG_INIT_VALUE; WDGM_GET_SPINLOCK(&WdgM_MultiMaskFalg); for(CoreIndex = (uint8)0; CoreIndex < WDGM_CORE_NUMBER; CoreIndex++) { WdgM_MultiDeviceMask |= (WdgM_MULT_DEVICE_MASK << CoreIndex); } WDGM_RELEASE_SPINLOCK(&WdgM_MultiMaskFalg); WdgM_Multistate = WDGM_MULTI_REQUEST_INIT; #else /* switch dog mode */ WdgM_setWdgMode(); WdgM_InitStatus = STD_INITIALIZED;/*SWS_WdgM_00135*/ #endif } } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_DeInit SWS_WdgM_00261 * * Description: Wdg Manager DeInit * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, WDGM_CODE) WdgM_DeInit(void) { uint8 CoreIndex; WdgM_SupervisedEntityIdType i; if(STD_INITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_DEINIT_APIID, WDGM_E_UNINIT); } #if(WDGM_CORE_NUMBER > 1) else if(WDGM_CORE_MASTER_ID != WDGM_GET_CORE_ID()) { /*Multi-Core Support*/ /*WdgM_DeInit must be called by the main core*/ WDGM_DET_REPORT_ERROR(WDGM_DEINIT_APIID, WDGM_E_CORE_MISMATCH); } #endif else { /*The AUTOSAR stipulates that updates the trigger conditions of all Watchdog Driver during DeInit.SWS_WdgM_00261*/ #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) for(CoreIndex = (uint8)0; CoreIndex < WDGM_CORE_NUMBER; CoreIndex++) { WdgM_MultiDeviceMask |= (WdgM_MULT_DEVICE_MASK << CoreIndex); } WdgM_Multistate = WDGM_MULTI_REQUEST_UNINIT; SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); #else SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); /*set all dog's trigger condition to configvalue, application may need time to do some jobs before dog reset see Asr Spec before SWS_WdgM_00288 */ WdgM_setTriggerValue(WDGM_CORE_MASTER_ID); WdgM_InitStatus = STD_UNINITIALIZED; #endif /* local se variable */ for(i = ((WdgM_SupervisedEntityIdType)0); i < WDGM_TOTAL_SE_NUM; i++) { WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_DEACTIVATED); WdgM_ErrFlag[0] = WDGM_NO_ERROR; } /* global variable */ for(CoreIndex = (uint8)0; CoreIndex < (uint8)WDGM_CORE_NUMBER; CoreIndex++) { WdgM_GStatusExpired_Cnt[CoreIndex] = ((uint16)0); WdgM_ChangeGlobalMode(CoreIndex, WDGM_GLOBAL_STATUS_DEACTIVATED);/*SWS_WdgM_00286*/ } WdgM_FirstExpSeId = ((WdgM_SupervisedEntityIdType)0); WdgM_FirstExpSeIdInv = ((WdgM_SupervisedEntityIdType)0); SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_SetMode SWS_WdgM_00154 * * Description: Sets the current mode of Watchdog Manager. * * Inputs: Mode, CallerID * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_SetMode ( WdgM_ModeType Mode, uint16 CallerID ) { Std_ReturnType ret = E_NOT_OK; WdgM_SupervisedEntityIdType i; #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) uint8 CoreIndex; boolean Setflag = TRUE; #endif /*SWS_WdgM_00020 21*/ if(STD_INITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_SETMODE_APIID, WDGM_E_UNINIT); } else if(Mode >= WdgM_runTimeConfig->WdgMNumOfMode) { WDGM_DET_REPORT_ERROR(WDGM_SETMODE_APIID, WDGM_E_PARAM_MODE); } #if(STD_OFF == WDGM_OFF_MODE_ENABLED) else if(TRUE == WdgM_HasWdgOffMode(Mode))/*SWS_WdgM_00031*/ { WDGM_DET_REPORT_ERROR(WDGM_SETMODE_APIID, WDGM_E_DISABLE_NOT_ALLOWED); } #endif else { (void)CallerID;/* obsolete SWS_WdgM_00245*/ SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) for(CoreIndex = (uint8)0; CoreIndex < WDGM_CORE_NUMBER; CoreIndex++) { if((WdgM_GlobalMonitoringStatus[CoreIndex] == WDGM_GLOBAL_STATUS_EXPIRED) || (WdgM_GlobalMonitoringStatus[CoreIndex] == WDGM_GLOBAL_STATUS_STOPPED)) /*SWS_WdgM_00145 316*/ { Setflag = FALSE; } } if(Setflag == TRUE) { WDGM_GET_SPINLOCK(&WdgM_ModeLockFalg); WdgM_runTimeModeIndex = Mode; WdgM_runTimeMode = &WdgM_runTimeConfig->WdgMMode[Mode]; WDGM_RELEASE_SPINLOCK(&WdgM_ModeLockFalg); WDGM_GET_SPINLOCK(&WdgM_MultiMaskFalg); for(CoreIndex = (uint8)0; CoreIndex < WDGM_CORE_NUMBER; CoreIndex++) { WdgM_MultiDeviceMask |= (WdgM_MULT_DEVICE_MASK << CoreIndex); } WDGM_RELEASE_SPINLOCK(&WdgM_MultiMaskFalg); WdgM_Multistate = WDGM_MULTI_REQUEST_SET_MODE; ret = E_OK; } #else if((WdgM_GlobalMonitoringStatus[WdgM_CoreId] == WDGM_GLOBAL_STATUS_OK) || (WdgM_GlobalMonitoringStatus[WdgM_CoreId] == WDGM_GLOBAL_STATUS_FAILED)) /*SWS_WdgM_00145 316*/ { WdgM_runTimeModeIndex = Mode; WdgM_runTimeMode = &WdgM_runTimeConfig->WdgMMode[Mode]; /*SWS_WdgM_00182:if SE is both actived in old and new mode, this SE's status cannot be changed only start a new monitor cycle */ for(i = ((WdgM_SupervisedEntityIdType)0); i < WDGM_TOTAL_SE_NUM; i++) { /*SWS_WdgM_00207 SWS_WdgM_00291, only ok or failed se canbe change to deactive expired will keep unchange */ if(FALSE == WdgM_IsSEActiveInCurrentMode(i)) { if(WdgM_LocalMonitoringStatus[i] < WDGM_LOCAL_STATUS_EXPIRED) { WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_DEACTIVATED); } } else { /*SWS_WdgM_00209 , if new mode has the se, se will be set ok, but if old state is expired, this will not change*/ if(WdgM_LocalMonitoringStatus[i] == WDGM_LOCAL_STATUS_DEACTIVATED) { WdgM_ChangeLocalMode(i, WDGM_LOCAL_STATUS_OK); } } WdgM_ErrFlag[i] = WDGM_NO_ERROR; } /* updata global status, may have fail SE */ WdgM_UpdateGlobalStatus(WdgM_CoreId); #if(WDGM_TOTAL_FLOW_NUM > 0) WdgM_ResetFlow(); #endif /* alive */ #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_ResetAliveMonitor(); #endif /* deadline */ #if(WDGM_TOTAL_DEADLINE_NUM > 0) WdgM_ResetDeadlineMonitor(); #endif WdgM_setWdgMode(); ret = E_OK; } #endif SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_GetMode SWS_WdgM_00168 * * Description: Returns the current mode of the Watchdog Manager. * * Inputs: Mode * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_GetMode ( P2VAR(WdgM_ModeType, AUTOMATIC, WDGM_APPL_DATA) Mode ) { Std_ReturnType ret = E_NOT_OK; /*SWS_WdgM_00253 SWS_WdgM_00254*/ if(STD_INITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_GETMODE_APIID, WDGM_E_UNINIT); } else if(NULL_PTR == Mode) { WDGM_DET_REPORT_ERROR(WDGM_GETMODE_APIID, WDGM_E_NULL_POINTER); } else { *Mode = WdgM_runTimeModeIndex ; /*SWS_WdgM_00170*/ ret = E_OK; } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_CheckpointReached * * Description: Indicates to the Watchdog Manager that a Checkpoint within a * Supervised Entity has been reached. * * Inputs: SEID CheckpointID * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_CheckpointReached ( WdgM_SupervisedEntityIdType SEID, WdgM_CheckpointIdType CheckpointID ) { Std_ReturnType ret = E_NOT_OK; P2CONST(WdgM_ModeCfgType, WDGM_VAR_NOINIT, WDGM_VAR) runTimeMode = WdgM_runTimeMode; #if(WDGM_CORE_NUMBER > 1) /*Multi-Core Support*/ uint8 WdgM_CoreId = WDGM_GET_CORE_ID(); #endif #if(WDGM_TOTAL_ALIVE_NUM > 0) uint16 aliveIndex; #endif P2CONST(WdgM_CheckPointInModeCfgType, AUTOMATIC, WDGM_CONST) cpModeCfg = NULL_PTR; if(STD_INITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_CPREACH_APIID, WDGM_E_UNINIT); } else if(SEID >= WDGM_TOTAL_SE_NUM) { WDGM_DET_REPORT_ERROR(WDGM_CPREACH_APIID, WDGM_E_PARAM_SEID); } else if(CheckpointID >= WDGM_TOTAL_CP_NUM) { WDGM_DET_REPORT_ERROR(WDGM_CPREACH_APIID, WDGM_E_CPID); } else if(WdgM_LocalMonitoringStatus[SEID] == WDGM_LOCAL_STATUS_DEACTIVATED)/*SWS_WdgM_00319*/ { WDGM_DET_REPORT_ERROR(WDGM_CPREACH_APIID, WDGM_E_SEDEACTIVATED); } #if(WDGM_CORE_NUMBER > 1) else if(WdgMSupervisedEntity[SEID].CoreId != WdgM_CoreId) { WDGM_DET_REPORT_ERROR(WDGM_CPREACH_APIID, WDGM_E_CORE_MISMATCH); } #endif else { SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); ret = E_OK; if((WdgM_GlobalMonitoringStatus[WdgM_CoreId] <= WDGM_GLOBAL_STATUS_FAILED) && (WdgM_LocalMonitoringStatus[SEID] <= WDGM_LOCAL_STATUS_FAILED)) /*SWS_WdgM_00208*/ { cpModeCfg = &runTimeMode->WdgCpInMode[CheckpointID]; #if(WDGM_TOTAL_FLOW_NUM > 0) /* Transition check */ WdgM_TransitionCheck(SEID, CheckpointID); #endif #if(WDGM_TOTAL_ALIVE_NUM > 0) /* Alive counter add */ aliveIndex = cpModeCfg->AliveIndex; /* check if this alive point is enabled in this mode */ if(WDGM_INVALID_ALIVE_INDEX != aliveIndex) { if(WdgM_AliveCnt[aliveIndex] < WDGM_INVALID_ALIVE_INDEX) { WdgM_AliveCnt[aliveIndex]++; } } #endif #if(WDGM_TOTAL_DEADLINE_NUM > 0) /*Transition has no error, cnt deadline */ if(NULL_PTR != cpModeCfg->DeadlinePtr) { WdgM_DeadlineCheck(SEID, CheckpointID); } #endif } SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_UpdateAliveCounter * * Description: BEWARE, this API is deprecated. Gives alive indications to * the Watchdog Manager * * Inputs: SEID * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_UpdateAliveCounter ( WdgM_SupervisedEntityIdType SEID ) { (void)SEID; return E_NOT_OK; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_GetLocalStatus SWS_WdgM_00169 * * Description: Returns the monitoring status of an individual Supervised Entity. * * Inputs: SEID Status * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_GetLocalStatus ( WdgM_SupervisedEntityIdType SEID, P2VAR(WdgM_LocalStatusType, AUTOMATIC, WDGM_APPL_DATA) Status ) { Std_ReturnType ret = E_NOT_OK; /* SWS_WdgM_00172 173 257 */ if(STD_UNINITIALIZED == WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_GETLOCALSTATUS_APIID, WDGM_E_UNINIT); } else if(NULL_PTR == Status) { WDGM_DET_REPORT_ERROR(WDGM_GETLOCALSTATUS_APIID, WDGM_E_NULL_POINTER); } else if(SEID >= WDGM_TOTAL_SE_NUM) { WDGM_DET_REPORT_ERROR(WDGM_GETLOCALSTATUS_APIID, WDGM_E_PARAM_SEID); } else { *Status = WdgM_LocalMonitoringStatus[SEID] ; /*SWS_WdgM_00171*/ ret = E_OK; } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_GetGlobalStatus SWS_WdgM_00175 * * Description: Returns the global monitoring status of the Watchdog Manager * * Inputs: Status * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_GetGlobalStatus ( P2VAR(WdgM_GlobalStatusType, AUTOMATIC, WDGM_APPL_DATA) Status ) { Std_ReturnType ret = E_NOT_OK; #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) uint8 WdgM_CoreId = WDGM_GET_CORE_ID(); #endif /* SWS_WdgM_00344 258 176 */ if(STD_INITIALIZED != WdgM_InitStatus) { WDGM_DET_REPORT_ERROR(WDGM_GETGLOBALSTATUS_APIID, WDGM_E_UNINIT); } else if(NULL_PTR == Status) { WDGM_DET_REPORT_ERROR(WDGM_GETGLOBALSTATUS_APIID, WDGM_E_NULL_POINTER); } else { *Status = WdgM_GlobalMonitoringStatus[WdgM_CoreId]; ret = E_OK; } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_PerformReset SWS_WdgM_00264 * * Description: Instructs the Watchdog Manager to cause a watchdog reset. * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, WDGM_CODE) WdgM_PerformReset(void) { uint8 i; uint8 CoreIndex; if(STD_INITIALIZED != WdgM_InitStatus)/*SWS_WdgM_00270*/ { WDGM_DET_REPORT_ERROR(WDGM_PERFORMRESET_APIID, WDGM_E_UNINIT); } else { /*SWS_WdgM_00232 set all dog's trigger condition to 0*/ #if(WDGM_CORE_NUMBER > 1) WdgM_Multistate = WDGM_MULTI_REQUEST_PERFORMRESET; #else for(i = ((uint8)0); i < (uint8)WDGM_WDG_DEVICE_NUM; i++) { WdgIf_SetTriggerCondition(WdgMWatchdog[i], ((uint16)0)); } for(CoreIndex = (uint8)0; CoreIndex < (uint8)WDGM_CORE_NUMBER; CoreIndex++) { /* SWS_WdgM_00233 reset global status, so that the condition value will not be updated anymore */ WdgM_ChangeGlobalMode(CoreIndex, WDGM_GLOBAL_STATUS_DEACTIVATED); } #endif } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_MainFunction SWS_WdgM_00159 * * Description: Performs the processing of the cyclic Watchdog Manager jobs. * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, WDGM_CODE) WdgM_MainFunction(void) { #if(STD_ON == WDGM_DEM_USED) boolean stopFlag = FALSE; #endif #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) /*Multi-Core Support*/ uint8 WdgM_CoreId = WDGM_GET_CORE_ID(); #endif #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) if(TRUE == WdgM_MultiExecute(WdgM_CoreId)) { /*need to synchronize Init/DeInit/SetMode/PerformReset*/ } else if(STD_UNINITIALIZED == WdgM_InitStatus) /*SWS_WdgM_00039*/ { WDGM_DET_REPORT_ERROR(WDGM_MAINFUNCTION_APIID, WDGM_E_UNINIT); } #else if(STD_UNINITIALIZED == WdgM_InitStatus) /*SWS_WdgM_00039*/ { WDGM_DET_REPORT_ERROR(WDGM_MAINFUNCTION_APIID, WDGM_E_UNINIT); } #endif else { SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); #if(STD_ON == WDGM_MASTER_RESET_ALL) WDGM_GET_SPINLOCK(&WdgMCoreCycleCountFlag[WdgM_CoreId]); WdgMCoreCycleCount[WdgM_CoreId]++; WDGM_RELEASE_SPINLOCK(&WdgMCoreCycleCountFlag[WdgM_CoreId]); if((WDGM_CORE_MASTER_ID == WdgM_CoreId)\ && ((WdgMCoreCycleCount[WDGM_CORE_MASTER_ID] % ((uint8)WDGM_MASTER_CHECK_CYCLE)) == (uint8)0)) { WdgM_CheckSlaveRunStatus(); WdgMCoreCycleCount[WDGM_CORE_MASTER_ID] = (uint8)0; } #endif /*SWS_WdgM_00063 221*/ if((WDGM_GLOBAL_STATUS_DEACTIVATED != WdgM_GlobalMonitoringStatus[WdgM_CoreId]) && (WDGM_GLOBAL_STATUS_STOPPED != WdgM_GlobalMonitoringStatus[WdgM_CoreId])) { /* if expired ,only wait and cnt until stop */ if(WDGM_GLOBAL_STATUS_EXPIRED != WdgM_GlobalMonitoringStatus[WdgM_CoreId]) { #if(WDGM_TOTAL_ALIVE_NUM > 0) WdgM_AliveMonitorMainFunction(WdgM_CoreId);/*SWS_WdgM_00324*/ #endif #if(STD_ON == WDGM_ENABLE_TIMEOUT_DETECTION) #if(WDGM_TOTAL_DEADLINE_NUM > 0) WdgM_DeadlineMonitorMainFunction(WdgM_CoreId); #endif #endif /*SWS_WdgM_00325 326 214*/ WdgM_UpdateLocalStatus(WdgM_CoreId); WdgM_UpdateGlobalStatus(WdgM_CoreId); } /*SWS_WdgM_00216 220*/ if(WDGM_GLOBAL_STATUS_EXPIRED == WdgM_GlobalMonitoringStatus[WdgM_CoreId]) { #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) WDGM_GET_SPINLOCK(&WdgM_ModeLockFalg); #endif if(WdgM_GStatusExpired_Cnt[WdgM_CoreId] == WdgM_runTimeMode->WdgMExpiredSupervisionCycleTol) { WdgM_ChangeGlobalMode(WdgM_CoreId, WDGM_GLOBAL_STATUS_STOPPED); WdgM_GStatusExpired_Cnt[WdgM_CoreId] = ((uint16)0); #if(STD_ON == WDGM_DEM_USED) stopFlag = TRUE; #endif } if(WdgM_GStatusExpired_Cnt[WdgM_CoreId] < WdgM_runTimeMode->WdgMExpiredSupervisionCycleTol) { WdgM_GStatusExpired_Cnt[WdgM_CoreId]++; } #if(STD_ON == WDGM_MULTI_CORE_SUPPORT) WDGM_RELEASE_SPINLOCK(&WdgM_ModeLockFalg); #endif } #if(STD_ON == WDGM_DEM_USED) if((WdgM_runTimeConfig->stopEventId) != WDGM_INVALID_DEM_EVENT)/*SWS_WdgM_00129*/ { if(TRUE == stopFlag) { WDGM_DEM_REPORT(WdgM_runTimeConfig->stopEventId, DEM_EVENT_STATUS_FAILED); } else { WDGM_DEM_REPORT(WdgM_runTimeConfig->stopEventId, DEM_EVENT_STATUS_PASSED); } } #endif } /* trigger every task cycle */ WdgM_setTriggerValue(WdgM_CoreId); SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_GetVersionInfo SWS_WdgM_00153 * * Description: get * * Inputs: VersionInfo * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ #if (STD_ON == WDGM_VERSION_INFO_API) FUNC(void, WDGM_CODE) WdgM_GetVersionInfo ( P2VAR(Std_VersionInfoType, AUTOMATIC, WDGM_APPL_DATA) VersionInfo ) { /*SWS_WdgM_00256*/ if(NULL_PTR == VersionInfo) { WDGM_DET_REPORT_ERROR(WDGM_GETVERSION_APIID, WDGM_E_NULL_POINTER); } else { /* Copy the vendor Id */ VersionInfo->vendorID = WDGM_VENDOR_ID_VALUE; /* Copy the module Id */ VersionInfo->moduleID = WDGM_MODULE_ID_VALUE; /* Copy Software Major Version */ VersionInfo->sw_major_version = ((uint8)WDGM_SW_MAJOR_VERSION); /* Copy Software Minor Version */ VersionInfo->sw_minor_version = ((uint8)WDGM_SW_MINOR_VERSION); /* Copy Software Patch Version */ VersionInfo->sw_patch_version = ((uint8)WDGM_SW_PATCH_VERSION); } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: WdgM_GetFirstExpiredSEID SWS_WdgM_00346 * * Description: get first FirstExpired se id * * Inputs: SEID * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, WDGM_CODE) WdgM_GetFirstExpiredSEID ( P2VAR(WdgM_SupervisedEntityIdType, AUTOMATIC, WDGM_APPL_DATA) SEID ) { Std_ReturnType ret = E_NOT_OK; WdgM_SupervisedEntityIdType FirstExpSeIdInv = ((WdgM_SupervisedEntityIdType)0); /*SWS_WdgM_00256*/ /*SWS_WdgM_00348 this api is available when uninit*/ if(NULL_PTR == SEID) { WDGM_DET_REPORT_ERROR(WDGM_GET1STEXPSEID_APIID, WDGM_E_NULL_POINTER); } else { /*SWS_WdgM_00349*/ SchM_Enter_WdgM_WDGM_EXCLUSIVE_AREA_0(); FirstExpSeIdInv = (WdgM_SupervisedEntityIdType)(~WdgM_FirstExpSeIdInv); if(WdgM_FirstExpSeId == FirstExpSeIdInv) { *SEID = WdgM_FirstExpSeId; ret = E_OK; } else { *SEID = ((WdgM_SupervisedEntityIdType)0); } SchM_Exit_WdgM_WDGM_EXCLUSIVE_AREA_0(); } return ret; } #define WDGM_STOP_SEC_CODE #include "WdgM_MemMap.h"