BufReq_ReturnType Com_CopyRxData(PduIdType PduId, const PduInfoType* PduInfoPtr, PduLengthType* RxBufferSizePtr) { /* !req COM782 */ /* If pdu group stopped -> return BUFREQ_E_NOT_OK */ imask_t state; BufReq_ReturnType r = BUFREQ_OK; uint8 remainingBytes; boolean sizeOk; boolean dirOk; boolean lockOk; if(COM_INIT != initStatus) { DET_REPORTERROR(COM_COPYRXDATA_ID, COM_E_UNINIT); return BUFREQ_NOT_OK; } Irq_Save(state); /* @req COM658 */ /* Interrupts disabled */ remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition; sizeOk = remainingBytes >= PduInfoPtr->SduLength; dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE; lockOk = isPduBufferLocked(PduId); if (dirOk && lockOk && sizeOk) { memcpy((void *)((uint8 *)GET_ArcIPdu(PduId)->ComIPduDataPtr+Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength); Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength; *RxBufferSizePtr = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition; } else { r = BUFREQ_NOT_OK; } Irq_Restore(state); return r; }
uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) { VALIDATE_SIGNAL(SignalId, 0x0a, E_NOT_OK); // Store pointer to signal for easier coding. const ComSignal_type * Signal = GET_Signal(SignalId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); if (isPduBufferLocked(getPduId(IPdu))) { return COM_BUSY; } //DEBUG(DEBUG_LOW, "Com_SendSignal: id %d, nBytes %d, BitPosition %d, intVal %d\n", SignalId, nBytes, signal->ComBitPosition, (uint32)*(uint8 *)SignalDataPtr); imask_t irq_state; Irq_Save(irq_state); Com_WriteSignalDataToPdu(Signal->ComHandleId, SignalDataPtr); // If the signal has an update bit. Set it! if (Signal->ComSignalArcUseUpdateBit) { SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } /* * If signal has triggered transmit property, trigger a transmission! */ if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } Irq_Restore(irq_state); return E_OK; }
/** * * @param PduId * @param PduInfoPtr * @param RetryInfoPtr not supported * @param TxDataCntPtr * @return */ BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, RetryInfoType* RetryInfoPtr, PduLengthType* TxDataCntPtr) { /* TODO: Validate PduId, etc? */ /* !req COM663*/ /* !req COM783*/ /* Do not copy any data and return BUFREQ_E_NOT_OK if pdu group stopped */ imask_t state; BufReq_ReturnType r = BUFREQ_OK; if(COM_INIT != initStatus) { DET_REPORTERROR(COM_COPYTXDATA_ID, COM_E_UNINIT); return BUFREQ_NOT_OK; } const ComIPdu_type *IPdu = GET_IPdu(PduId); boolean dirOk = ComConfig->ComIPdu[PduId].ComIPduDirection == SEND; boolean sizeOk; (void)RetryInfoPtr; // get rid of compiler warning Irq_Save(state); sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength; Com_BufferPduState[PduId].locked = true; if (dirOk && sizeOk) { void* source = (void *)GET_ArcIPdu(PduId)->ComIPduDataPtr; memcpy(PduInfoPtr->SduDataPtr,(uint8 *)source + Com_BufferPduState[PduId].currentPosition, PduInfoPtr->SduLength); Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength; *TxDataCntPtr = IPdu->ComIPduSize - Com_BufferPduState[PduId].currentPosition; } else { r = BUFREQ_NOT_OK; } Irq_Restore(state); return r; }
void Com_TpRxIndication(PduIdType PduId, NotifResultType Result) { PDU_ID_CHECK_NO_RETURN(PduId, 0x14); const ComIPdu_type *IPdu = GET_IPdu(PduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(PduId); imask_t state; Irq_Save(state); // If Ipdu is stopped if (!Arc_IPdu->Com_Arc_IpduStarted) { UnlockTpBuffer(getPduId(IPdu)); Irq_Restore(state); return; } if (Result == NTFRSLT_OK) { if (IPdu->ComIPduSignalProcessing == IMMEDIATE) { // irqs needs to be disabled until signal notifications have been called // Otherwise a new Tp session can start and fill up pdus UnlockTpBuffer(getPduId(IPdu)); } // In deferred mode, buffers are unlocked in mainfunction Com_RxProcessSignals(IPdu,Arc_IPdu); } else { UnlockTpBuffer(getPduId(IPdu)); } Irq_Restore(state); }
Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) { //#warning Com_SendSignalGroup should be performed atomically. Should we disable interrupts here? const ComSignal_type * Signal = GET_Signal(SignalGroupId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); if (isPduBufferLocked(getPduId(IPdu))) { return COM_BUSY; } // Copy shadow buffer to Ipdu data space imask_t irq_state; Irq_Save(irq_state); Com_CopySignalGroupDataFromShadowBufferToPdu(SignalGroupId); // If the signal has an update bit. Set it! if (Signal->ComSignalArcUseUpdateBit) { SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } // If signal has triggered transmit property, trigger a transmission! if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } Irq_Restore(irq_state); return E_OK; }
uint8 Com_ReceiveDynSignal(Com_SignalIdType SignalId, void* SignalDataPtr, uint16* Length) { const ComSignal_type * Signal = GET_Signal(SignalId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); imask_t state; uint8 startFromPduByte; uint8 r = E_OK; const void* pduDataPtr; Com_SignalType signalType = Signal->ComSignalType; if (signalType != UINT8_DYN) { return COM_SERVICE_NOT_AVAILABLE; } Irq_Save(state); if (*Length > Arc_IPdu->Com_Arc_DynSignalLength) { *Length = Arc_IPdu->Com_Arc_DynSignalLength; } startFromPduByte = (Signal->ComBitPosition) / 8; pduDataPtr = 0; if (IPdu->ComIPduSignalProcessing == DEFERRED && IPdu->ComIPduDirection == RECEIVE) { pduDataPtr = IPdu->ComIPduDeferredDataPtr; } else { if (isPduBufferLocked(getPduId(IPdu))) { r = COM_BUSY; } pduDataPtr = IPdu->ComIPduDataPtr; } memcpy((void*)SignalDataPtr, (void*)((uint8*)pduDataPtr + startFromPduByte), *Length); Irq_Restore(state); return r; }
//lint -esym(904, Com_RxIndication) //PC-Lint Exception of rule 14.7 void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) { PDU_ID_CHECK_NO_RETURN(ComRxPduId, 0x14); const ComIPdu_type *IPdu = GET_IPdu(ComRxPduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); imask_t state; Irq_Save(state); // If Ipdu is stopped if (!Arc_IPdu->Com_Arc_IpduStarted) { Irq_Restore(state); return; } // Check callout status if (IPdu->ComIPduCallout != NULL) { if (!IPdu->ComIPduCallout(ComRxPduId, PduInfoPtr->SduDataPtr)) { // TODO Report error to DET. // Det_ReportError(); Irq_Restore(state); return; } } // Copy IPDU data memcpy(IPdu->ComIPduDataPtr, PduInfoPtr->SduDataPtr, IPdu->ComIPduSize); Com_RxProcessSignals(IPdu,Arc_IPdu); Irq_Restore(state); return; }
BufReq_ReturnType Com_StartOfReception(PduIdType ComRxPduId, PduLengthType TpSduLength, PduLengthType* RxBufferSizePtr) { PduLengthType ComIPduSize; imask_t state; BufReq_ReturnType r = BUFREQ_OK; Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); Irq_Save(state); if (Arc_IPdu->Com_Arc_IpduStarted) { if (GET_IPdu(ComRxPduId)->ComIPduDirection == RECEIVE) { if (!Com_BufferPduState[ComRxPduId].locked) { ComIPduSize = GET_IPdu(ComRxPduId)->ComIPduSize; if (ComIPduSize >= TpSduLength) { Com_BufferPduState[ComRxPduId].locked = TRUE; *RxBufferSizePtr = ComIPduSize; Com_SetDynSignalLength(ComRxPduId,TpSduLength); } else { r = BUFREQ_OVFL; } } else { r = BUFREQ_BUSY; } } } else { r = BUFREQ_NOT_OK; } Irq_Restore(state); return r; }
Std_ReturnType Com_Internal_TriggerIPduSend(PduIdType ComTxPduId) { PDU_ID_CHECK(ComTxPduId, 0x17, E_NOT_OK); #if PDUR_COM_SUPPORT == STD_OFF return E_NOT_OK; #else const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComTxPduId); imask_t state; Irq_Save(state); if( isPduBufferLocked(ComTxPduId) ) { return E_NOT_OK; } // Is the IPdu ready for transmission? if (Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer == 0 && Arc_IPdu->Com_Arc_IpduStarted) { //lint --e(725) Suppress PC-Lint warning "Expected positive indentation...". What means? // Check callout status if (IPdu->ComIPduCallout != NULL) { if (!IPdu->ComIPduCallout(ComTxPduId, IPdu->ComIPduDataPtr)) { // TODO Report error to DET. // Det_ReportError(); Irq_Restore(state); return E_NOT_OK; } } PduInfoType PduInfoPackage; PduInfoPackage.SduDataPtr = (uint8 *)IPdu->ComIPduDataPtr; if (IPdu->ComIPduDynSignalRef != 0) { uint8 sizeWithoutDynSignal = IPdu->ComIPduSize - (IPdu->ComIPduDynSignalRef->ComBitSize/8); PduInfoPackage.SduLength = sizeWithoutDynSignal + Arc_IPdu->Com_Arc_DynSignalLength; } else { PduInfoPackage.SduLength = IPdu->ComIPduSize; } // Send IPdu! if (PduR_ComTransmit(IPdu->ArcIPduOutgoingId, &PduInfoPackage) == E_OK) { // Clear all update bits for the contained signals for (uint8 i = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[i] != NULL); i++) { if (IPdu->ComIPduSignalRef[i]->ComSignalArcUseUpdateBit) { CLEARBIT(IPdu->ComIPduDataPtr, IPdu->ComIPduSignalRef[i]->ComUpdateBitPosition); } } } else { UnlockTpBuffer(getPduId(IPdu)); return E_NOT_OK; } // Reset miminum delay timer. Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer = IPdu->ComTxIPdu.ComTxIPduMinimumDelayFactor; } else { return E_NOT_OK; } Irq_Restore(state); return E_OK; #endif }
static void Com_SetDynSignalLength(PduIdType ComRxPduId,PduLengthType TpSduLength) { const ComIPdu_type *IPdu = GET_IPdu(ComRxPduId); if (IPdu->ComIPduDynSignalRef == 0) { return; } { //to make hcs12 compiler happier const ComSignal_type * const dynSignal = IPdu->ComIPduDynSignalRef; Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); Arc_IPdu->Com_Arc_DynSignalLength = TpSduLength - (dynSignal->ComBitPosition/8); } return; }
static void Com_SetDynSignalLength(PduIdType ComRxPduId,PduLengthType TpSduLength) { const ComIPdu_type *IPdu = GET_IPdu(ComRxPduId); if (IPdu->ComIPduDynSignalRef == 0) { return; } const ComSignal_type * const dynSignal = IPdu->ComIPduDynSignalRef; Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); /* @req COM758 */ if( TpSduLength > (dynSignal->ComBitPosition/8) ) { Arc_IPdu->Com_Arc_DynSignalLength = TpSduLength - (dynSignal->ComBitPosition/8); } else { Arc_IPdu->Com_Arc_DynSignalLength = 0; } return; }
BufReq_ReturnType Com_StartOfReception(PduIdType ComRxPduId, PduLengthType TpSduLength, PduLengthType* RxBufferSizePtr) { /* TODO: Validate ComRxPduId? */ PduLengthType ComIPduSize; imask_t state; BufReq_ReturnType r = BUFREQ_OK; if(COM_INIT != initStatus) { DET_REPORTERROR(COM_STARTOFRECEPTION_ID, COM_E_UNINIT); return BUFREQ_NOT_OK; } Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); Irq_Save(state); if (Arc_IPdu->Com_Arc_IpduStarted) { if (GET_IPdu(ComRxPduId)->ComIPduDirection == RECEIVE) { /* !req COM657 */ if (!Com_BufferPduState[ComRxPduId].locked) { ComIPduSize = GET_IPdu(ComRxPduId)->ComIPduSize; if (ComIPduSize >= TpSduLength) { Com_BufferPduState[ComRxPduId].locked = true; *RxBufferSizePtr = ComIPduSize; /* @req COM656 */ Com_SetDynSignalLength(ComRxPduId,TpSduLength); } else { /* @req COM654 */ /* @req COM655 */ r = BUFREQ_OVFL; } } else { r = BUFREQ_BUSY; } } } else { /* @req COM721 */ r = BUFREQ_NOT_OK; } Irq_Restore(state); return r; }
uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, uint16 Length) { const ComSignal_type * Signal = GET_Signal(SignalId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); imask_t state; Com_SignalType signalType = Signal->ComSignalType; uint8 signalLength; Com_BitPositionType bitPosition; uint8 startFromPduByte; if (signalType != UINT8_DYN) { return COM_SERVICE_NOT_AVAILABLE; } if (isPduBufferLocked(getPduId(IPdu))) { return COM_BUSY; } signalLength = Signal->ComBitSize / 8; bitPosition = Signal->ComBitPosition; if (signalLength < Length) { return E_NOT_OK; } startFromPduByte = bitPosition / 8; Irq_Save(state); memcpy((void *)((uint8 *)IPdu->ComIPduDataPtr + startFromPduByte), SignalDataPtr, Length); Arc_IPdu->Com_Arc_DynSignalLength = Length; // If the signal has an update bit. Set it! if (Signal->ComSignalArcUseUpdateBit) { SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } // If signal has triggered transmit property, trigger a transmission! if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } Irq_Restore(state); return E_OK; }
void Com_Init(const Com_ConfigType *config ) { DEBUG(DEBUG_LOW, "--Initialization of COM--\n"); /* !req COM328 */ /* Shall not enable inter-ECU communication */ /* !req COM483 */ /* @req COM128 */ /* @req COM217 */ /* @req COM444 */ /* @req COM772 */ // If timeout set to 0 uint8 failure = 0; /* @req COM433 */ if( NULL == config ) { DET_REPORTERROR(COM_INIT_ID, COM_E_PARAM_POINTER); return; } ComConfig = config; uint32 firstTimeout; boolean dataChanged = FALSE; //lint --e(928) PC-Lint exception Misra 11.4, Must be like this. /tojo uint8 endiannessByte = *(const uint8 *)&endianness_test; if ( endiannessByte == 0xef ) { Com_SystemEndianness = COM_LITTLE_ENDIAN; } else if ( endiannessByte == 0xde ) { Com_SystemEndianness = COM_BIG_ENDIAN; } else { // No other endianness supported //lint --e(506) PC-Lint exception Misra 13.7, 14.1, Allow boolean to always be false. assert(0); } // Initialize each IPdu //ComIPdu_type *IPdu; //Com_Arc_IPdu_type *Arc_IPdu; const ComSignal_type *Signal; const ComGroupSignal_type *GroupSignal; uint16 bufferIndex = 0; for (uint16 i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { boolean pduHasGroupSignal = FALSE; const ComIPdu_type *IPdu = GET_IPdu(i); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(i); Arc_IPdu->Com_Arc_DynSignalLength = 0; if (i >= ComConfig->ComNofIPdus) { DET_REPORTERROR(COM_INIT_ID ,COM_E_TOO_MANY_IPDU); failure = 1; break; } /* Set the data ptr for this Pdu */ Arc_IPdu->ComIPduDataPtr = (void *)&Com_Arc_Buffer[bufferIndex]; bufferIndex += IPdu->ComIPduSize; // If this is a TX and cyclic IPdu, configure the first deadline. if ( (IPdu->ComIPduDirection == SEND) && ( (IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeMode == PERIODIC) || (IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeMode == MIXED) )) { //IPdu->Com_Arc_TxIPduTimers.ComTxModeTimePeriodTimer = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeTimeOffsetFactor; Arc_IPdu->Com_Arc_TxIPduTimers.ComTxModeTimePeriodTimer = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeTimeOffsetFactor; } // Reset firstTimeout. firstTimeout = 0xffffffffu; // Initialize the memory with the default value. /* @req COM015 */ if (IPdu->ComIPduDirection == SEND) { memset((void *)Arc_IPdu->ComIPduDataPtr, IPdu->ComTxIPdu.ComTxIPduUnusedAreasDefault, IPdu->ComIPduSize); } // For each signal in this PDU. //Arc_IPdu->NComIPduSignalRef = 0; for (uint16 j = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[j] != NULL) ; j++) { Signal = IPdu->ComIPduSignalRef[j]; Com_Arc_Signal_type * Arc_Signal = GET_ArcSignal(Signal->ComHandleId); // Configure signal deadline monitoring if used. /* @req COM333 */ // If timeout set to 0 if (Signal->ComTimeoutFactor > 0) { if (Signal->ComSignalArcUseUpdateBit) { // This signal uses an update bit, and hence has its own deadline monitoring. /* @req COM292 */ Arc_Signal->Com_Arc_DeadlineCounter = Signal->ComFirstTimeoutFactor; // Configure the deadline counter } else { // This signal does not use an update bit, and should therefore use per I-PDU deadline monitoring. if (firstTimeout > Signal->ComFirstTimeoutFactor) { firstTimeout = Signal->ComFirstTimeoutFactor; } } } // Clear update bits /* @req COM117 */ if (Signal->ComSignalArcUseUpdateBit) { CLEARBIT(Arc_IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } // If this signal is a signal group if (Signal->Com_Arc_IsSignalGroup) { pduHasGroupSignal = TRUE; Arc_Signal->Com_Arc_ShadowBuffer = (void *)&Com_Arc_Buffer[bufferIndex]; // For each group signal of this signal group. for(uint8 h = 0; Signal->ComGroupSignal[h] != NULL; h++) { GroupSignal = Signal->ComGroupSignal[h]; Com_Arc_GroupSignal_type *Arc_GroupSignal = GET_ArcGroupSignal(GroupSignal->ComHandleId); // Set pointer to shadow buffer Arc_GroupSignal->Com_Arc_ShadowBuffer = (void *)Arc_Signal->Com_Arc_ShadowBuffer; // Initialize shadowbuffer. /* @req COM484 */ Com_Internal_UpdateShadowSignal(GroupSignal->ComHandleId, GroupSignal->ComSignalInitValue); } // Initialize group signal data from shadowbuffer. /* @req COM098 */ Com_CopySignalGroupDataFromShadowBufferToPdu(Signal->ComHandleId, false, &dataChanged); } else { // Initialize signal data. /* @req COM098 */ Com_WriteSignalDataToPdu(Signal->ComHandleId, Signal->ComSignalInitValue, &dataChanged); } } if( pduHasGroupSignal ) { /* This pdu has includes group signals. Means that a shodow buffer was set up. * Increment index. */ bufferIndex += IPdu->ComIPduSize; } if (IPdu->ComIPduDirection == RECEIVE && IPdu->ComIPduSignalProcessing == DEFERRED) { /* Set pointer to the deferred buffer */ Arc_IPdu->ComIPduDeferredDataPtr = (void *)&Com_Arc_Buffer[bufferIndex]; bufferIndex += IPdu->ComIPduSize; // Copy the initialized pdu to deferred buffer memcpy(Arc_IPdu->ComIPduDeferredDataPtr,Arc_IPdu->ComIPduDataPtr,IPdu->ComIPduSize); } // Configure per I-PDU based deadline monitoring. for (uint16 j = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[j] != NULL); j++) { Signal = IPdu->ComIPduSignalRef[j]; Com_Arc_Signal_type * Arc_Signal = GET_ArcSignal(Signal->ComHandleId); /* @req COM333 */ // If timeout set to 0 if ( (Signal->ComTimeoutFactor > 0) && (!Signal->ComSignalArcUseUpdateBit) ) { /* @req COM290 */ Arc_Signal->Com_Arc_DeadlineCounter = firstTimeout; } } } for (uint16 i = 0; i < ComConfig->ComNofIPdus; i++) { Com_BufferPduState[i].currentPosition = 0; Com_BufferPduState[i].locked = false; } // An error occurred. if (failure) { DEBUG(DEBUG_LOW, "--Initialization of COM failed--\n"); //DET_REPORTERROR(COM_MODULE_ID, COM_INSTANCE_ID, 0x01, COM_E_INVALID_FILTER_CONFIGURATION); } else { initStatus = COM_INIT; DEBUG(DEBUG_LOW, "--Initialization of COM completed--\n"); } }
void Com_Init(const Com_ConfigType *config ) { uint8 failure = 0; uint32 firstTimeout; uint8 endiannessByte; uint16 i; uint16 j; //ComIPdu_type *IPdu; //Com_Arc_IPdu_type *Arc_IPdu; const ComSignal_type *Signal; const ComGroupSignal_type *GroupSignal; DEBUG_PRINT0(DEBUG_LOW, "--Initialization of COM--\n"); ComConfig = config; //lint --e(928) PC-Lint exception Misra 11.4, Must be like this. /tojo endiannessByte = *(const uint8 *)&endianness_test; if ( endiannessByte == 0xef ) { Com_SystemEndianness = COM_LITTLE_ENDIAN; } else if ( endiannessByte == 0xde ) { Com_SystemEndianness = COM_BIG_ENDIAN; } else { // No other endianness supported //lint --e(506) PC-Lint exception Misra 13.7, 14.1, Allow boolean to always be false. AR_ASSERT(0); } // Initialize each IPdu #if 0 //F*****g bad code as always need a dummy ComIPdu config with Com_Arc_EOL equal to TRUE. for (i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { #else /*So I changed it to ...*/ for(i = 0;i < COM_N_IPDUS;i++){ #endif const ComIPdu_type *IPdu = GET_IPdu(i); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(i); Arc_IPdu->Com_Arc_DynSignalLength = 0; if (i >= COM_N_IPDUS) { DET_REPORTERROR(COM_MODULE_ID, COM_INSTANCE_ID, 0x01, COM_E_TOO_MANY_IPDU); failure = 1; break; } // If this is a TX and cyclic IPdu, configure the first deadline. if ( (IPdu->ComIPduDirection == SEND) && ( (IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeMode == PERIODIC) || (IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeMode == MIXED) )) { //IPdu->Com_Arc_TxIPduTimers.ComTxModeTimePeriodTimer = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeTimeOffsetFactor; Arc_IPdu->Com_Arc_TxIPduTimers.ComTxModeTimePeriodTimer = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeTimeOffsetFactor; } // Reset firstTimeout. firstTimeout = 0xffffffffu; // Initialize the memory with the default value. if (IPdu->ComIPduDirection == SEND) { memset((void *)IPdu->ComIPduDataPtr, IPdu->ComTxIPdu.ComTxIPduUnusedAreasDefault, IPdu->ComIPduSize); } // For each signal in this PDU. //Arc_IPdu->NComIPduSignalRef = 0; for (j = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[j] != NULL) ; j++) { Com_Arc_Signal_type * Arc_Signal; Signal = IPdu->ComIPduSignalRef[j]; Arc_Signal = GET_ArcSignal(Signal->ComHandleId); // Configure signal deadline monitoring if used. if (Signal->ComTimeoutFactor > 0) { if (Signal->ComSignalArcUseUpdateBit) { // This signal uses an update bit, and hence has its own deadline monitoring. Arc_Signal->Com_Arc_DeadlineCounter = Signal->ComFirstTimeoutFactor; // Configure the deadline counter } else { // This signal does not use an update bit, and should therefore use per I-PDU deadline monitoring. if (firstTimeout > Signal->ComFirstTimeoutFactor) { firstTimeout = Signal->ComFirstTimeoutFactor; } } } // Clear update bits if (Signal->ComSignalArcUseUpdateBit) { CLEARBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } // If this signal is a signal group if (Signal->Com_Arc_IsSignalGroup) { uint8 h; // For each group signal of this signal group. for(h = 0; Signal->ComGroupSignal[h] != NULL; h++) { Com_Arc_GroupSignal_type *Arc_GroupSignal; GroupSignal = Signal->ComGroupSignal[h]; Arc_GroupSignal = GET_ArcGroupSignal(GroupSignal->ComHandleId); // Set pointer to shadow buffer Arc_GroupSignal->Com_Arc_ShadowBuffer = (void *)Signal->Com_Arc_ShadowBuffer; // Initialize group signal data. Com_WriteGroupSignalDataToPdu(Signal->ComHandleId, GroupSignal->ComHandleId, GroupSignal->ComSignalInitValue); } } else { // Initialize signal data. Com_WriteSignalDataToPdu(Signal->ComHandleId, Signal->ComSignalInitValue); } } if (IPdu->ComIPduDirection == RECEIVE && IPdu->ComIPduSignalProcessing == DEFERRED) { // Copy the initialized pdu to deferred buffer memcpy(IPdu->ComIPduDeferredDataPtr,IPdu->ComIPduDataPtr,IPdu->ComIPduSize); } // Configure per I-PDU based deadline monitoring. for (j = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[j] != NULL); j++) { Com_Arc_Signal_type * Arc_Signal; Signal = IPdu->ComIPduSignalRef[j]; Arc_Signal = GET_ArcSignal(Signal->ComHandleId); if ( (Signal->ComTimeoutFactor > 0) && (!Signal->ComSignalArcUseUpdateBit) ) { Arc_Signal->Com_Arc_DeadlineCounter = firstTimeout; } } } for (i = 0; i < COM_N_IPDUS; i++) { Com_BufferPduState[i].currentPosition = 0; Com_BufferPduState[i].locked = FALSE; } // An error occurred. if (failure) { DEBUG_PRINT0(DEBUG_LOW, "--Initialization of COM failed--\n"); //DET_REPORTERROR(COM_MODULE_ID, COM_INSTANCE_ID, 0x01, COM_E_INVALID_FILTER_CONFIGURATION); } else { DEBUG_PRINT0(DEBUG_LOW, "--Initialization of COM completed--\n"); } } void Com_DeInit( void ) { } void Com_IpduGroupStart(Com_PduGroupIdType IpduGroupId,boolean Initialize) { uint16 i; (void)Initialize; // Nothing to be done. This is just to avoid Lint warning. #if 0 for (i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { #else /*So I changed it to ...*/ for(i = 0;i < COM_N_IPDUS;i++){ #endif if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) { Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 1; } } } void Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId) { uint16 i; #if 0 for (i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { #else /*So I changed it to ...*/ for(i = 0;i < COM_N_IPDUS;i++){ #endif if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) { Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 0; } } } /** * * @param PduId * @param PduInfoPtr * @param RetryInfoPtr not supported * @param TxDataCntPtr * @return */ BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, RetryInfoType* RetryInfoPtr, PduLengthType* TxDataCntPtr) { imask_t state; BufReq_ReturnType r = BUFREQ_OK; const ComIPdu_type *IPdu = GET_IPdu(PduId); boolean dirOk = ComConfig->ComIPdu[PduId].ComIPduDirection == SEND; boolean sizeOk; (void)RetryInfoPtr; // get rid of compiler warning Irq_Save(state); sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength; Com_BufferPduState[PduId].locked = TRUE; if (dirOk && sizeOk) { void* source = (void *)(IPdu->ComIPduDataPtr); memcpy((void *)PduInfoPtr->SduDataPtr,(void *)((uint8*)source + Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduLength); Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength; *TxDataCntPtr = IPdu->ComIPduSize - Com_BufferPduState[PduId].currentPosition; } else { r = BUFREQ_NOT_OK; } Irq_Restore(state); return r; }