void LinSM_TimerTick()
{
uint8 channel;
for(channel=0;channel<LINIF_CONTROLLER_CNT;channel++){
// Check timers
if(ScheduleRequestTimer[channel] > 0){
ScheduleRequestTimer[channel]--;
if(ScheduleRequestTimer[channel]==0){
Det_ReportError(MODULE_ID_LINSM,0,LINSM_REQUEST_COM_MODE_SERVICE_ID,LINSM_E_CONFIRMATION_TIMEOUT);
LinSMChannelStatus[channel] = LINSM_NO_COM;
}
}
if(GoToSleepTimer[channel] > 0){
GoToSleepTimer[channel]--;
if(GoToSleepTimer[channel]==0){
Det_ReportError(MODULE_ID_LINSM,0,LINSM_REQUEST_COM_MODE_SERVICE_ID,LINSM_E_CONFIRMATION_TIMEOUT);
LinSMChannelStatus[channel] = LINSM_NO_COM;
}
}
if(WakeUpTimer[channel] > 0){
WakeUpTimer[channel]--;
if(WakeUpTimer[channel]==0){
Det_ReportError(MODULE_ID_LINSM,0,LINSM_REQUEST_COM_MODE_SERVICE_ID,LINSM_E_CONFIRMATION_TIMEOUT);
LinSMChannelStatus[channel] = LINSM_NO_COM;
}
}
}
}
/**
* Function that finds the Hoh( HardwareObjectHandle ) from a Hth
* A HTH may connect to one or several HOH's. Just find the first one.
*
* @param hth The transmit handle
* @returns Ptr to the Hoh
*/
LOCAL const Can_HardwareObjectType * Can_FindHoh( Can_Arc_HTHType hth , uint32* controller)
{
const Can_HardwareObjectType *hohObj;
const Can_ObjectHOHMapType *map;
const Can_ControllerConfigType *canHwConfig;
map = &Can_Global.CanHTHMap[hth];
#if(CAN_DEV_ERROR_DETECT == STD_ON)
// Verify that this is the correct map
if (map->CanHOHRef->CanObjectId != hth)
{
Det_ReportError(MODULE_ID_CAN, 0, CAN_WRITE_SERVICE_ID, CAN_E_PARAM_HANDLE);
}
#endif
canHwConfig= CAN_GET_CONTROLLER_CONFIG(Can_Global.channelMap[map->CanControllerRef]);
hohObj = map->CanHOHRef;
// Verify that this is the correct Hoh type
if ( hohObj->CanObjectType == CAN_OBJECT_TYPE_TRANSMIT)
{
*controller = map->CanControllerRef;
return hohObj;
}
#if(CAN_DEV_ERROR_DETECT == STD_ON)
Det_ReportError(MODULE_ID_CAN, 0, CAN_WRITE_SERVICE_ID, CAN_E_PARAM_HANDLE);
#endif
return NULL;
}
EXPORT Can_ReturnType Can_Write(Can_HwHandleType Hth,const Can_PduType* PduInfo)
{
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_WRITE_SERVICE_ID,CAN_E_UNINIT);
return CAN_NOT_OK;
}
if(NULL == PduInfo)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_WRITE_SERVICE_ID,CAN_E_PARAM_POINTER);
return CAN_NOT_OK;
}
if(PduInfo->length > 8)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_WRITE_SERVICE_ID,CAN_E_PARAM_DLC);
return CAN_NOT_OK;
}
if(Hth >= NUM_OF_HTHS)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_WRITE_SERVICE_ID,CAN_E_PARAM_HANDLE);
return CAN_NOT_OK;
}
#endif
return Can_Hw_Write(Hth,PduInfo);
}
EXPORT void Can_InitController(uint8 Controller,const Can_ControllerConfigType* Config)
{
Can_UnitType *canUnit;
StatusType ercd;
canUnit = CAN_GET_PRIVATE_DATA(Controller);
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_UNINIT);
return;
}
if(NULL == Config)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_PARAM_POINTER);
return;
}
if(Controller >= CAN_CONTROLLER_CNT)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_PARAM_CONTROLLER);
return;
}
if(canUnit->state!=CANIF_CS_STOPPED)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_TRANSITION);
return;
}
#endif
ercd = Can_Hw_InitController(Controller,Config);
if(ercd != E_OK)
{
return;
}
canUnit->state = CANIF_CS_STOPPED;
Can_EnableControllerInterrupts(Controller);
}
/* ####################### FUNCTIONs ########################### */
EXPORT void Can_Init(const Can_ConfigType* Config)
{
Can_UnitType *canUnit;
const Can_ControllerConfigType *canHwConfig;
const Can_HardwareObjectType* hoh;
uint8 ctlrId;
int configId;
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT != Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INIT_SERVICE_ID,CAN_E_TRANSITION);
return;
}
if(NULL == Config)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_INIT_SERVICE_ID,CAN_E_PARAM_POINTER);
return;
}
#endif
/* save config */
Can_Global.config = Config;
Can_Global.driverState = CAN_READY;
Can_Hw_Init(Config);
for (configId=0; configId < CAN_CTRL_CONFIG_CNT; configId++)
{
canHwConfig = CAN_GET_CONTROLLER_CONFIG(configId);
ctlrId = canHwConfig->CanControllerId;
// Assign the configuration channel used later..
Can_Global.channelMap[ctlrId] = configId;
Can_Global.configured |= (1<<ctlrId);
canUnit = CAN_GET_PRIVATE_DATA(ctlrId);
canUnit->state = CANIF_CS_STOPPED;
canUnit->lock_cnt = 0;
// Clear stats
memset(&canUnit->stats, 0, sizeof(Can_StatisticsType));
//This can be done by CanIf
//Can_InitController(ctlrId, canHwConfig);
// Loop through all Hohs and map them into the HTHMap
hoh = canHwConfig->Can_Hoh;
hoh--;
do
{
hoh++;
if (hoh->CanObjectType == CAN_OBJECT_TYPE_TRANSMIT)
{
Can_Global.CanHTHMap[hoh->CanObjectId].CanControllerRef = canHwConfig->CanControllerId;
Can_Global.CanHTHMap[hoh->CanObjectId].CanHOHRef = hoh;
}
} while (!hoh->Can_EOL);
}
}
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;
}
}
EXPORT void Can_DisableControllerInterrupts(uint8 Controller)
{
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_DISABLECONTROLLERINTERRUPTS_SERVICE_ID,CAN_E_UNINIT);
return;
}
if(Controller >= CAN_CONTROLLER_CNT)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_DISABLECONTROLLERINTERRUPTS_SERVICE_ID,CAN_E_PARAM_CONTROLLER);
return;
}
#endif
Can_Hw_DisableControllerInterrupts(Controller);
}
EXPORT Can_ReturnType Can_SetControllerMode(uint8 Controller,Can_StateTransitionType Transition)
{
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_SETCONTROLLERMODE_SERVICE_ID,CAN_E_UNINIT);
return CAN_NOT_OK;
}
if(Controller >= CAN_CONTROLLER_CNT)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_SETCONTROLLERMODE_SERVICE_ID,CAN_E_PARAM_CONTROLLER);
return CAN_NOT_OK;
}
#endif
return Can_Hw_SetControllerMode(Controller,Transition);
}
EXPORT void Can_MainFunction_Mode(void)
{
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_MAINFUNCTION_MODE_SERVICE_ID,CAN_E_UNINIT);
return;
}
#endif
}
EXPORT Can_ReturnType Can_CheckWakeup(uint8 Controller)
{
#if(CAN_DEV_ERROR_DETECT == STD_ON)
if(CAN_UNINIT == Can_Global.driverState)
{
Det_ReportError(MODULE_ID_CAN,0,CAN_CBK_CHECKWAKEUP_SERVICE_ID,CAN_E_UNINIT);
return CAN_NOT_OK;
}
#endif
}
static void Mcu_Arc_LossOfLock( void ) {
#if ( MCU_DEV_ERROR_DETECT == STD_ON )
/* Should report MCU_E_CLOCK_FAILURE with DEM here.... but
* we do the next best thing. Report with Det with API = 0
*/
Det_ReportError(MCU_MODULE_ID,0,0,MCU_E_PLL_NOT_LOCKED);
#endif
Mcu_Global.stats.lossOfLockCnt++;
// Clear interrupt
// FMPLL.SYNSR.B.LOLF = 1;
}
/**
*
* @param sources
*/
void EcuM_SetWakeupEvent(EcuM_WakeupSourceType sources) {
EcuM_WakeupSourceType wkSource;
DEBUG_ECUM_CALLIN_W_ARG("EcuM_SetWakeupEvent","0x%lx",(uint32)sources);
/* @req 3.1.5/EcuM2826 The function exists */
/* @req 3.1.5/EcuM2171 */
/* @req 4.0.3|.1.5/ECUM2565 Validate at once for pre-defined sources */
wkSource = (ECUM_WKSOURCE_POWER | ECUM_WKSOURCE_RESET
| ECUM_WKSOURCE_INTERNAL_RESET | ECUM_WKSOURCE_INTERNAL_WDG
| ECUM_WKSOURCE_EXTERNAL_WDG);
/* Sources that should be validated at once */
wkSource &= sources;
if (wkSource != 0) {
/* Move to validated */
EcuM_ValidateWakeupEvent(wkSource);
}
/* Don't add pre-defined source to PENDING */
sources ^= wkSource;
/* @req 3.1.5/EcuM2867 */
#if ( ECUM_DEV_ERROR_DETECT == STD_ON )
/* Get user defined sources */
wkSource = EcuM_World.config->EcuMSleepModeConfig[EcuM_World.sleep_mode].EcuMWakeupSourceMask;
/* Add always validated sources */
wkSource |= (ECUM_WKSOURCE_POWER|ECUM_WKSOURCE_RESET | ECUM_WKSOURCE_INTERNAL_RESET |
ECUM_WKSOURCE_INTERNAL_WDG | ECUM_WKSOURCE_EXTERNAL_WDG);
if( !((sources | wkSource) == wkSource))
{
Det_ReportError(MODULE_ID_ECUM, 0, ECUM_VALIDATE_WAKEUP_EVENT_ID, ECUM_E_UNKNOWN_WAKEUP_SOURCE );
return;
}
#endif
/* @req 3.1.5/EcuM1117 */
EcuM_World.wakeupEvents |= sources;
/* @req 3.1.5/EcuM2707 @req 3.1.5/EcuM2709*/
EcuM_World.validationTimer = ECUM_VALIDATION_TIMEOUT
/ ECUM_MAIN_FUNCTION_PERIOD;
}
