/* @req SWS_Ocu_00100 */ Ocu_ReturnType Ocu_SetRelativeThreshold(Ocu_ChannelType ChannelNumber,Ocu_ValueType RelativeValue) { Ocu_ValueType newAbsThreshld; Ocu_ValueType cntrval; uint8 cntrchnl; const volatile struct EMIOS_tag * emiosUnit; uint8 channelId; uint8 absChnlId; /* @req SWS_Ocu_00104 **/ VALIDATE_W_RV( (OcuDriverStatus != OCU_UNINIT), OCU_SETRELATIVETHRESHOLD_SERVICE_ID, OCU_E_UNINIT,OCU_CM_OUT_REF_INTERVAL ); /* @req SWS_Ocu_00105 **/ VALIDATE_W_RV( (ChannelNumber < OCU_MATCH_CHANNEL_COUNT), OCU_SETRELATIVETHRESHOLD_SERVICE_ID, OCU_E_PARAM_INVALID_CHANNEL,OCU_CM_OUT_REF_INTERVAL ); channelId = OcuConfigPtr->OcuChannelConfig[ChannelNumber].OcuChannelId; if (CHANNELS_PER_EMIOS_UNIT != 0) { emiosUnit = GET_EMIOS_UNIT(channelId/CHANNELS_PER_EMIOS_UNIT); } else { return OCU_CM_OUT_REF_INTERVAL; } absChnlId = GET_EMIOS_CHANNEL(channelId); cntrchnl = (absChnlId < UNIFIED_CHANNEL_D) ? UNIFIED_CHANNEL_C:UNIFIED_CHANNEL_D ; cntrval = (Ocu_ValueType)(emiosUnit->CH[cntrchnl].CCNTR.R - 1UL); /* @req SWS_Ocu_00101 */ newAbsThreshld = cntrval + RelativeValue; /* @req SWS_Ocu_00106 */ /* @req SWS_Ocu_00107 */ return setthrshld(ChannelNumber, cntrval, newAbsThreshld); }
Gpt_ValueType Gpt_GetTimeRemaining(Gpt_ChannelType channel) { VALIDATE_W_RV( (Gpt_Global.initRun == STD_ON), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_UNINIT, 0 ); VALIDATE_W_RV( VALID_CHANNEL(channel),GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_PARAM_CHANNEL, 0 ); Gpt_ValueType remaining = 0; /* @req SWS_Gpt_00301 */ /* @req SWS_Gpt_00305 */ if( (GPT_STATE_INITIALIZED == Gpt_Unit[channel].state) || (GPT_STATE_EXPIRED == Gpt_Unit[channel].state) || ((GPT_STATE_STOPPED == Gpt_Unit[channel].state) && (Gpt_Unit[channel].expiredWhenStopped)) ) { return 0; } if (channel <= GPT_CHANNEL_CNT) { uint32 *tval = (uint32 *)&(TimAddr[channel]->CNT); // Time remaining is the time until it hits 0, so just return the current timer value remaining = *tval; } return remaining; }
Gpt_ValueType Gpt_GetTimeElapsed(Gpt_ChannelType channel) { Gpt_ValueType timer = 0; VALIDATE_W_RV( (Gpt_Global.initRun == STD_ON), GPT_GETTIMEELAPSED_SERVICE_ID, GPT_E_UNINIT ,0 ); VALIDATE_W_RV( VALID_CHANNEL(channel),GPT_GETTIMEELAPSED_SERVICE_ID, GPT_E_PARAM_CHANNEL, 0 ); /* @req SWS_Gpt_00295 */ if(Gpt_Unit[channel].state == GPT_STATE_INITIALIZED) { return timer; } /* @req SWS_Gpt_00299 */ if( (GPT_STATE_EXPIRED == Gpt_Unit[channel].state) || ((GPT_STATE_STOPPED == Gpt_Unit[channel].state) && (Gpt_Unit[channel].expiredWhenStopped)) ) { return TimAddr[channel]->ARR; } // NOTE! // These little creatures count down if (channel <= GPT_CHANNEL_CNT) { uint32 *tlval = (uint32 *)&(TimAddr[channel]->ARR); uint32 *tval = (uint32 *)&(TimAddr[channel]->CNT); timer = *tlval - *tval; } return (timer); }
/* @req SWS_Ocu_00085 */ Ocu_ValueType Ocu_GetCounter(Ocu_ChannelType ChannelNumber) { vuint32_t cntr; uint8 cntrchnl; const volatile struct EMIOS_tag * emiosUnit; uint8 channelId; uint8 absChnlId; /* @req SWS_Ocu_00090 **/ VALIDATE_W_RV( (OcuDriverStatus != OCU_UNINIT), OCU_GETCOUNTER_SERVICE_ID, OCU_E_UNINIT,INVALID_COUNTERVALUE ); /* @req SWS_Ocu_00089 **/ VALIDATE_W_RV( (ChannelNumber < OCU_MATCH_CHANNEL_COUNT), OCU_GETCOUNTER_SERVICE_ID, OCU_E_PARAM_INVALID_CHANNEL,INVALID_COUNTERVALUE ); channelId = OcuConfigPtr->OcuChannelConfig[ChannelNumber].OcuChannelId; if (CHANNELS_PER_EMIOS_UNIT != 0) { emiosUnit = GET_EMIOS_UNIT(channelId/CHANNELS_PER_EMIOS_UNIT); } else { return INVALID_COUNTERVALUE; } absChnlId = GET_EMIOS_CHANNEL(channelId); // Get the unified channel section which drives the counter cntrchnl = (absChnlId < UNIFIED_CHANNEL_D) ? UNIFIED_CHANNEL_C:UNIFIED_CHANNEL_D ; /* @req SWS_Ocu_00086 */ cntr = emiosUnit->CH[cntrchnl].CCNTR.R -1UL; //In MCB mode CNTR is 1 based return (Ocu_ValueType)cntr; }
Lin_StatusType Lin_GetStatus( uint8 Channel, uint8** Lin_SduPtr ) { volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel); VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_UNINIT, LIN_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_CHANNEL_UNINIT, LIN_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_CHANNEL, LIN_NOT_OK); VALIDATE_W_RV( (Lin_SduPtr!=NULL), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_POINTER, LIN_NOT_OK); imask_t state; Irq_Save(state); Lin_StatusType res = LinChannelStatus[Channel]; /* We can only check for valid sdu ptr when LIN_RX_OK */ if(LinChannelStatus[Channel] == LIN_RX_OK || LinChannelStatus[Channel] == LIN_RX_ERROR){ CopyToBuffer(LinBufRx[Channel], LINFLEXHw); *Lin_SduPtr = LinBufRx[Channel]; if(LinChannelStatus[Channel] == LIN_RX_ERROR){ ResyncDriver(Channel); } LinChannelStatus[Channel]=LIN_CH_OPERATIONAL; } else if(LinChannelStatus[Channel] == LIN_TX_OK || LinChannelStatus[Channel] == LIN_TX_ERROR){ if(LinChannelStatus[Channel] == LIN_TX_ERROR){ ResyncDriver(Channel); } LinChannelStatus[Channel]=LIN_CH_OPERATIONAL; } Irq_Restore(state); return res; }
Std_ReturnType LinSM_RequestComMode(NetworkHandleType network,ComM_ModeType mode) { Std_ReturnType res = E_NOT_OK; VALIDATE_W_RV( (LinSMStatus != LINSM_UNINIT), LINSM_REQUEST_COM_MODE_SERVICE_ID, LINSM_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (network < LINIF_CONTROLLER_CNT), LINSM_REQUEST_COM_MODE_SERVICE_ID, LINSM_E_NOXEXISTENT_CHANNEL, E_NOT_OK); switch(mode) { case COMM_NO_COMMUNICATION: if (E_OK == LinIf_GotoSleep(network)){ LinSMChannelStatus[network] = LINSM_GOTO_SLEEP; GoToSleepTimer[network]=LINSM_GOTO_SLEEP_TIMEOUT; res = E_OK; } break; case COMM_SILENT_COMMUNICATION: // Standard say nothing about this case. break; case COMM_FULL_COMMUNICATION: WakeUpTimer[network]=LINSM_WAKEUP_TIMEOUT; //should be done here since some implementations will confirm immediatly if (E_OK == LinIf_WakeUp(network)){ res = E_OK; } else { WakeUpTimer[network]=0; } break; default: break; } return res; }
Std_ReturnType Lin_GoToSleepInternal( uint8 Channel ) { VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_GO_TO_SLEEP_INTERNAL_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK); Lin_GoToSleep(Channel); return E_OK; }
Std_ReturnType Mcu_InitRamSection(const Mcu_RamSectionType RamSection) { VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( RamSection <= Mcu_Global.config->McuRamSectors ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_PARAM_RAMSECTION, E_NOT_OK ); /* NOT SUPPORTED, reason: no support for external RAM */ return E_OK; }
/* !req SWS_Mcu_00056 */ Std_ReturnType Mcu_DistributePllClock(void) { /* @req SWS_Mcu_00125 */ /* !req SWS_Mcu_00122 */ VALIDATE_W_RV( ( TRUE == Mcu_Global.initRun ), MCU_DISTRIBUTEPLLCLOCK_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( zynq_GetPllStatus() == MCU_PLL_LOCKED), MCU_DISTRIBUTEPLLCLOCK_SERVICE_ID, MCU_E_PLL_NOT_LOCKED, E_NOT_OK); return E_OK; }
Std_ReturnType LinSM_ScheduleRequest(NetworkHandleType channel,LinIf_SchHandleType schedule) { VALIDATE_W_RV( (LinSMStatus != LINSM_UNINIT), LINSM_SCHEDULE_REQUEST_SERVICE_ID, LINSM_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (channel < LINIF_CONTROLLER_CNT), LINSM_SCHEDULE_REQUEST_SERVICE_ID, LINSM_E_NOXEXISTENT_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (LinSMChannelStatus[channel] == LINSM_RUN_SCHEDULE), LINSM_SCHEDULE_REQUEST_SERVICE_ID, LINSM_E_NOT_IN_RUN_SCHEDULE, E_NOT_OK); VALIDATE_W_RV( (schedule < LINIF_SCH_CNT), LINSM_SCHEDULE_REQUEST_SERVICE_ID, LINSM_E_PARAMETER, E_NOT_OK); ScheduleRequestTimer[channel]=LINSM_SCHEDULE_REQUEST_TIMEOUT; return LinIf_ScheduleRequest(channel, schedule); }
Std_ReturnType Lin_SendResponse( uint8 Channel, Lin_PduType* PduInfoPtr ) { VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK); VALIDATE_W_RV( (PduInfoPtr != NULL), LIN_SEND_RESPONSE_SERVICE_ID, LIN_E_INVALID_POINTER, E_NOT_OK); /* The response is sent from within the header in this implementation since this is a master only implementation */ return E_OK; }
Std_ReturnType Mcu_InitRamSection(Mcu_RamSectionType RamSection) { /* @req SWS_Mcu_00021 */ /* @req SWS_Mcu_00125 */ VALIDATE_W_RV( ( TRUE == Mcu_Global.initRun ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( RamSection <= Mcu_Global.config->McuRamSectors ), MCU_INITRAMSECTION_SERVICE_ID, MCU_E_PARAM_RAMSECTION, E_NOT_OK ); memset( (void *)Mcu_Global.config->McuRamSectorSettingConfig[RamSection].McuRamSectionBaseAddress, Mcu_Global.config->McuRamSectorSettingConfig[RamSection].McuRamDefaultValue, Mcu_Global.config->McuRamSectorSettingConfig[RamSection].McuRamSectionSize); return E_OK; }
/* @req SWS_Ocu_00091 */ Ocu_ReturnType Ocu_SetAbsoluteThreshold(Ocu_ChannelType ChannelNumber,Ocu_ValueType ReferenceValue,Ocu_ValueType AbsoluteValue) { /* @req SWS_Ocu_00095 **/ VALIDATE_W_RV( (OcuDriverStatus != OCU_UNINIT), OCU_SETABSOLUTETHRESHOLD_SERVICE_ID, OCU_E_UNINIT,OCU_CM_OUT_REF_INTERVAL ); /* @req SWS_Ocu_00096 **/ VALIDATE_W_RV( (ChannelNumber < OCU_MATCH_CHANNEL_COUNT), OCU_SETABSOLUTETHRESHOLD_SERVICE_ID, OCU_E_PARAM_INVALID_CHANNEL,OCU_CM_OUT_REF_INTERVAL ); /* @req SWS_Ocu_00098 */ return setthrshld(ChannelNumber,ReferenceValue,AbsoluteValue); }
Std_ReturnType Mcu_InitClock(const Mcu_ClockType ClockSetting) { const Mcu_ClockSettingConfigType *clockSettingsPtr; VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_INITCLOCK_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( ClockSetting < Mcu_Global.config->McuClockSettings ), MCU_INITCLOCK_SERVICE_ID, MCU_E_PARAM_CLOCK, E_NOT_OK ); Mcu_Global.clockSetting = ClockSetting; clockSettingsPtr = &Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting]; InitMcuClocks(clockSettingsPtr); InitPerClocks(clockSettingsPtr); return E_OK; }
RamTst_TestResultType RamTst_GetTestResultPerBlock( RamTst_NumberOfBlocksType BlockID ) { /* @req SWS_RamTst_00089 */ VALIDATE_W_RV( ( RamTst_Internal.InitStatus != RAMTST_UNINIT ), RAMTST_GETRESULTPERBLOCK_SERVICE_ID, RAMTST_E_UNINIT, RAMTST_RESULT_NOT_TESTED); /* Find the block */ const RamTst_BlockParamsType *blockParamPtr = NULL; const RamTst_AlgParamsType *algParams = NULL; for(RamTst_AlgParamsIdType i = 0; (i < RamTst_ConfigParams.RamTstNumberOfAlgParamSets) && (NULL == blockParamPtr); i++) { algParams = &RamTst_ConfigParams.RamTstAlgParams[i]; /* Run for all blocks */ for(RamTst_NumberOfBlocksType block = 0; (block < algParams->RamTstNumberOfBlocks) && (NULL == blockParamPtr); block++) { if(algParams->RamTstBlockParams[block].RamTstBlockId == BlockID) { blockParamPtr = &algParams->RamTstBlockParams[block]; } } } if(NULL != blockParamPtr) { /* @req SWS_RamTst_00038 */ return RamTst_Internal.RamTst_BlockResultBuffer[blockParamPtr->RamTstBlockIndex]; } else { /* Invalid block id */ #if ( RAMTST_DEV_ERROR_DETECT == STD_ON ) /* @req SWS_RamTst_00039 */ (void)Det_ReportError(MODULE_ID_RAMTST, 0, RAMTST_GETRESULTPERBLOCK_SERVICE_ID, RAMTST_E_OUT_OF_RANGE); #endif return RAMTST_RESULT_UNDEFINED; } }
RamTst_TestResultType RamTst_GetTestResult( void ) { /* @req SWS_RamTst_00089 */ VALIDATE_W_RV( ( RamTst_Internal.InitStatus != RAMTST_UNINIT ), RAMTST_GETTESTRESULT_SERVICE_ID, RAMTST_E_UNINIT, RAMTST_RESULT_NOT_TESTED); /* @req SWS_RamTst_00024 */ return RamTst_Internal.CurrentTestResult; }
Mcu_ResetType Mcu_GetResetReason(void) { Mcu_ResetType rv; VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_RESET_UNDEFINED ); #if defined(CFG_MPC560X) if( RGM.FES.B.F_SOFT ) { rv = MCU_SW_RESET; } else if( RGM.DES.B.F_SWT ) { rv = MCU_WATCHDOG_RESET; } else if( RGM.DES.B.F_POR ) { rv = MCU_POWER_ON_RESET; } else { rv = MCU_RESET_UNDEFINED; } #else if( SIU.RSR.B.SSRS ) { rv = MCU_SW_RESET; } else if( SIU.RSR.B.WDRS ) { rv = MCU_WATCHDOG_RESET; } else if( SIU.RSR.B.PORS || SIU.RSR.B.ERS ) { rv = MCU_POWER_ON_RESET; } else { rv = MCU_RESET_UNDEFINED; } #endif return rv; }
RamTst_AlgParamsIdType RamTst_GetAlgParams( void ) { /* @req SWS_RamTst_00089 */ VALIDATE_W_RV( ( RamTst_Internal.InitStatus != RAMTST_UNINIT ), RAMTST_GETALGPARAMS_SERVICE_ID, RAMTST_E_UNINIT, 0); return RamTst_Internal.ActiveAlgParamID; }
Std_ReturnType Lin_GoToSleep( uint8 Channel ) { volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel); VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_SLEEP), LIN_GO_TO_SLEEP_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK); LINFLEXHw->LINCR1.B.SLEEP = 1; LINFLEXHw->LINIER.B.WUIE = 1; /* enable wake-up irq */ LinChannelStatus[Channel]=LIN_CH_SLEEP; return E_OK; }
Std_ReturnType Lin_WakeUp( uint8 Channel ) { volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel); VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_WAKE_UP_SERVICE_ID, LIN_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_WAKE_UP_SERVICE_ID, LIN_E_CHANNEL_UNINIT, E_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_WAKE_UP_SERVICE_ID, LIN_E_INVALID_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] == LIN_CH_SLEEP), LIN_WAKE_UP_SERVICE_ID, LIN_E_STATE_TRANSITION, E_NOT_OK); /* Disable wake interrupt */ LINFLEXHw->LINIER.B.WUIE = 0; /* Clear sleep bit */ LINFLEXHw->LINCR1.B.SLEEP = 0; LinChannelStatus[Channel]=LIN_CH_OPERATIONAL; return E_OK; }
Std_ReturnType Mcu_InitClock(Mcu_ClockType ClockSetting) { const Mcu_ClockSettingConfigType *clockSettingsPtr; /* @req SWS_Mcu_00125 */ /* @req SWS_Mcu_00019 */ VALIDATE_W_RV( ( TRUE == Mcu_Global.initRun ), MCU_INITCLOCK_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( ClockSetting < Mcu_Global.config->McuClockSettings ), MCU_INITCLOCK_SERVICE_ID, MCU_E_PARAM_CLOCK, E_NOT_OK ); Mcu_Global.clockSetting = ClockSetting; clockSettingsPtr = &Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting]; zynq_InitPll(clockSettingsPtr); zynq_InitClocks(clockSettingsPtr); return E_OK; }
Std_ReturnType LinSM_GetCurrentComMode(NetworkHandleType network,ComM_ModeType* mode) { VALIDATE_W_RV( (LinSMStatus != LINSM_UNINIT), LINSM_GET_CURRENT_COM_MODE_SERVICE_ID, LINSM_E_UNINIT, E_NOT_OK); VALIDATE_W_RV( (network < LINIF_CONTROLLER_CNT), LINSM_GET_CURRENT_COM_MODE_SERVICE_ID, LINSM_E_NOXEXISTENT_CHANNEL, E_NOT_OK); VALIDATE_W_RV( (mode != NULL), LINSM_GET_CURRENT_COM_MODE_SERVICE_ID, LINSM_E_PARAMETER_POINTER, E_NOT_OK); switch (LinSMChannelStatus[network]) { case LINSM_RUN_SCHEDULE: *mode= COMM_FULL_COMMUNICATION; break; default: *mode= COMM_NO_COMMUNICATION; break; } return E_OK; }
Mcu_ResetType Mcu_GetResetReason(void) { /* @req SWS_Mcu_00133 */ /* @req SWS_Mcu_00125 */ /* @req SWS_Mcu_00005 */ VALIDATE_W_RV( ( TRUE == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_RESET_UNDEFINED ); return Mcu_Global.resetReason; }
/** * Read from flash memory * * @param SourceAddress * @param TargetAddressPtr * @param Length * @return */ Std_ReturnType Fls_Read( Fls_AddressType SourceAddress, uint8 *TargetAddressPtr, Fls_LengthType Length) { SourceAddress += FLS_BASE_ADDRESS; /** @req FLS256 */ /** @req FLS236 */ /** !req FLS239 TODO */ /** !req FLS240 Have no idea what the requirement means*/ /** @req FLS099 */ VALIDATE_W_RV(Fls_Global.status != MEMIF_UNINIT,FLS_READ_ID, FLS_E_UNINIT,E_NOT_OK ); /** @req FLS100 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_BUSY, FLS_READ_ID, FLS_E_BUSY, E_NOT_OK ); /** @req FLS158 */ VALIDATE_W_RV( TargetAddressPtr != NULL , FLS_READ_ID, FLS_E_PARAM_DATA, E_NOT_OK ); /** @req FLS097 */ VALIDATE_W_RV( E_OK == fls_CheckValidAddress(SourceAddress), FLS_READ_ID, FLS_E_PARAM_ADDRESS, E_NOT_OK ); /** @req FLS098 */ VALIDATE_W_RV( (Length != 0) && (E_OK == fls_CheckValidAddress(SourceAddress + Length)), FLS_READ_ID, FLS_E_PARAM_LENGTH, E_NOT_OK ); // Always check if status is not busy if (Fls_Global.status == MEMIF_BUSY) return E_NOT_OK; Fls_Global.status = MEMIF_BUSY; Fls_Global.jobResultType = MEMIF_JOB_PENDING; Fls_Global.jobType = FLS_JOB_READ; LOG_HEX2("Fls_Read() ",(uint32)TargetAddressPtr," ", Length); /** @req FLS237 */ Fls_Global.flashAddr = SourceAddress; Fls_Global.ramAddr = TargetAddressPtr; Fls_Global.length = Length; if( Fls_Global.mode == MEMIF_MODE_FAST ) { Fls_Global.readChunkSize = Fls_Global.config->FlsMaxReadFastMode; } else { Fls_Global.readChunkSize = Fls_Global.config->FlsMaxReadNormalMode; } return E_OK; }
Std_ReturnType Fls_Compare( Fls_AddressType SourceAddress, uint8 *TargetAddressPtr, Fls_LengthType Length ) { SourceAddress += FLS_BASE_ADDRESS; /** @req FLS257 */ /** @req FLS241 */ /** @req FLS186 */ /** @req FLS152 */ VALIDATE_W_RV(Fls_Global.status != MEMIF_UNINIT,FLS_COMPARE_ID, FLS_E_UNINIT,E_NOT_OK ); /** @req FLS153 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_BUSY, FLS_COMPARE_ID, FLS_E_BUSY, E_NOT_OK ); /** @req FLS273 */ VALIDATE_W_RV( TargetAddressPtr != NULL , FLS_COMPARE_ID, FLS_E_PARAM_DATA, E_NOT_OK ); /** @req FLS150 */ VALIDATE_W_RV( E_OK == fls_CheckValidAddress(SourceAddress), FLS_COMPARE_ID, FLS_E_PARAM_ADDRESS, E_NOT_OK ); /** @req FLS151 */ VALIDATE_W_RV( (Length != 0) && (E_OK == fls_CheckValidAddress(SourceAddress + Length)), FLS_COMPARE_ID, FLS_E_PARAM_LENGTH, E_NOT_OK ); // Always check if status is not busy if (Fls_Global.status == MEMIF_BUSY ) return E_NOT_OK; Fls_Global.status = MEMIF_BUSY; Fls_Global.jobResultType = MEMIF_JOB_PENDING; Fls_Global.jobType = FLS_JOB_COMPARE; if( Fls_Global.mode == MEMIF_MODE_FAST ) { Fls_Global.readChunkSize = Fls_Global.config->FlsMaxReadFastMode; } else { Fls_Global.readChunkSize = Fls_Global.config->FlsMaxReadNormalMode; } /* @req FLS242 */ Fls_Global.flashAddr = SourceAddress; Fls_Global.ramAddr = TargetAddressPtr; Fls_Global.length = Length; return E_OK; }
/** * Erase flash sectors * * @param TargetAddress Always from 0 to FLS_TOTAL_SIZE * @param Length * @return */ Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length) { #if FLS_BASE_ADDRESS > 0 /* Avoid compiler warning */ TargetAddress += FLS_BASE_ADDRESS; #endif /** @req SWS_Fls_00218 */ /** @req SWS_Fls_00220 */ /** @req SWS_Fls_00327 */ /** @req SWS_Fls_00065 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_UNINIT, FLS_ERASE_ID, FLS_E_UNINIT, E_NOT_OK ); /** @req SWS_Fls_00023 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_BUSY, FLS_ERASE_ID, FLS_E_BUSY, E_NOT_OK ); /** @req SWS_Fls_00020 */ VALIDATE_W_RV( E_OK == sectorAligned( TargetAddress ), FLS_ERASE_ID, FLS_E_PARAM_ADDRESS, E_NOT_OK ); /** @req SWS_Fls_00021 */ VALIDATE_W_RV( (Length != 0) && (EE_OK == sectorAligned( TargetAddress + Length)), FLS_ERASE_ID, FLS_E_PARAM_LENGTH, E_NOT_OK ); #if defined(CFG_MPC5777M) VALIDATE_W_RV((E_OK == checkValidChunk(TargetAddress, TargetAddress + Length - 1)), FLS_ERASE_ID, FLS_E_INVALID_AREA, E_NOT_OK); #endif Fls_Global.status = MEMIF_BUSY; /** @req SWS_Fls_00328 */ Fls_Global.jobResultType = MEMIF_JOB_PENDING; /** @req SWS_Fls_00329 */ Fls_Global.jobType = FLS_JOB_ERASE; Fls_Global.flashAddr = TargetAddress; Fls_Global.length = Length; LOG_HEX2("Fls_Erase() ",TargetAddress," ", Length); /* Unlock */ Flash_Lock(Fls_Global.config->FlsInfo,FLASH_OP_UNLOCK,TargetAddress, Length ); /** @req SWS_Fls_00145 */ if (EE_OK != Flash_Erase(Fls_Global.config->FlsInfo,TargetAddress, Length, NULL )) { return E_NOT_OK; } return E_OK; /** @req SWS_Fls_00330 */ }
Std_ReturnType Mcu_InitClock(const Mcu_ClockType ClockSetting) { const Mcu_ClockSettingConfigType *clockSettingsPtr; VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_INITCLOCK_SERVICE_ID, MCU_E_UNINIT, E_NOT_OK ); VALIDATE_W_RV( ( ClockSetting < Mcu_Global.config->McuClockSettings ), MCU_INITCLOCK_SERVICE_ID, MCU_E_PARAM_CLOCK, E_NOT_OK ); Mcu_Global.clockSetting = ClockSetting; clockSettingsPtr = &Mcu_Global.config->McuClockSettingConfig[Mcu_Global.clockSetting]; CLKSEL &= ~BM_PLLSEL; // Turn off PLL PLLCTL |= BM_PLLON+BM_AUTO; // Enable PLL module, Auto Mode REFDV = clockSettingsPtr->Pll1; // Set reference divider SYNR = clockSettingsPtr->Pll2; // Set synthesizer multiplier while (Mcu_GetPllStatus() != MCU_PLL_LOCKED) ; CLKSEL |= BM_PLLSEL; // Switch to PLL clock return E_OK; }
/** * Erase flash sectors * * @param TargetAddress Always from 0 to FLS_TOTAL_SIZE * @param Length * @return */ Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length) { TargetAddress += FLS_BASE_ADDRESS; /** @req FLS250 3.0/4.0 */ /** @req FLS218 3.0/4.0 */ /** @req FLS220 3.0/4.0 */ /** @req FLS327 4.0 */ /** @req FLS065 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_UNINIT, FLS_ERASE_ID, FLS_E_UNINIT, E_NOT_OK ); /** @req FLS023 */ VALIDATE_W_RV( Fls_Global.status != MEMIF_BUSY, FLS_ERASE_ID, FLS_E_BUSY, E_NOT_OK ); /** @req FLS020 3.0/4.0 */ VALIDATE_W_RV( E_OK == fls_SectorAligned( TargetAddress ), FLS_ERASE_ID, FLS_E_PARAM_ADDRESS, E_NOT_OK ); /** @req FLS021 3.0/4.0 */ VALIDATE_W_RV( (Length != 0) && (EE_OK == fls_SectorAligned( TargetAddress + Length)), FLS_ERASE_ID, FLS_E_PARAM_LENGTH, E_NOT_OK ); // Check if we trying to erase a partition that we are executing in #if 0 pc = fls_GetPc(); #endif Fls_Global.status = MEMIF_BUSY; /** @req FLS219 3.0 */ /** @req FLS328 4.0 */ Fls_Global.jobResultType = MEMIF_JOB_PENDING; /** @req FLS329 4.0 */ Fls_Global.jobType = FLS_JOB_ERASE; Fls_Global.flashAddr = TargetAddress; Fls_Global.length = Length; LOG_HEX2("Fls_Erase() ",TargetAddress," ", Length); /* Unlock */ Flash_Lock(Fls_Global.config->FlsInfo,FLASH_OP_UNLOCK,TargetAddress, Length ); /** @req FLS145 */ Flash_Erase(Fls_Global.config->FlsInfo,TargetAddress, Length, NULL ); return E_OK; /** @req FLS330 4.0 */ }
Mcu_RawResetType Mcu_GetResetRawValue(void) { VALIDATE_W_RV( ( 1 == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_GETRESETRAWVALUE_UNINIT_RV ); if (!Mcu_Global.initRun) { return MCU_GETRESETRAWVALUE_UNINIT_RV; } else { return (RCC->CSR) & (RCC_CSR_RMVF | RCC_CSR_PINRSTF | RCC_CSR_PORRSTF | RCC_CSR_SFTRSTF | RCC_CSR_IWDGRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_LPWRRSTF); } return 0; }
/* @req SWS_Mcu_00006 */ Mcu_RawResetType Mcu_GetResetRawValue(void) { /* @req SWS_Mcu_00135 */ /* @req SWS_Mcu_00125 */ VALIDATE_W_RV( ( TRUE == Mcu_Global.initRun ), MCU_GETRESETREASON_SERVICE_ID, MCU_E_UNINIT, MCU_GETRESETRAWVALUE_UNINIT_RV ); if( !Mcu_Global.initRun ) { return MCU_GETRESETRAWVALUE_UNINIT_RV; } return Mcu_Global.rawResetvalue; }