DATA_TLB_EXCEPTION,\r
INSTRUCTION_TLB_EXCEPTION,\r
DEBUG_EXCEPTION,\r
- NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS,\r
+ NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS\r
}IrqType;\r
\r
typedef enum {\r
PERIPHERAL_CLOCK_ESCI_G,\r
PERIPHERAL_CLOCK_ESCI_H,\r
PERIPHERAL_CLOCK_IIC_A,\r
- PERIPHERAL_CLOCK_MLB,\r
+ PERIPHERAL_CLOCK_MLB\r
} McuE_PeriperalClock_t;\r
\r
\r
\r
typedef enum {\r
CPU_CORE0,\r
- CPU_CORE1,\r
+ CPU_CORE1\r
} Cpu_t;\r
\r
#define IRQ_INTERRUPT_OFFSET 0\r
unsigned char *prev_heap_end;\r
\r
/* initialize */\r
- if( heap_end == 0 )\r
+ if( heap_end == 0 ){\r
heap_end = _heap;\r
-\r
- prev_heap_end = heap_end;\r
+ }\r
+ prev_heap_end = heap_end;\r
\r
if( heap_end + incr - _heap > HEAPSIZE ) {\r
/* heap overflow - announce on stderr */\r
\r
#include "Can.h"\r
#include "CanIf_Cbk.h"\r
-#include "string.h"\r
+#include <string.h>\r
\r
#include "debug.h"\r
#include "PduR.h"\r
do\r
{\r
hrhConfig++;\r
- if (hrhConfig->CanIfHrhIdSymRef == hrh)\r
+ if (hrhConfig->CanIfHrhIdSymRef == hrh){\r
return hrhConfig->CanIfCanControllerHrhIdRef;\r
+ }\r
} while(!hrhConfig->CanIf_Arc_EOL);\r
} while(!hohConfig->CanIf_Arc_EOL);\r
\r
switch (oldMode)\r
{\r
case CANIF_CS_SLEEP:\r
- if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;\r
break;\r
default:\r
}\r
\r
CanIf_SetPduMode(channel, CANIF_SET_ONLINE);\r
- if (Can_SetControllerMode(canControllerId, CAN_T_START) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_START) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STARTED;\r
}\r
break;\r
{\r
switch (oldMode) {\r
case CANIF_CS_STARTED:\r
- if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;\r
break;\r
default:\r
break;\r
}\r
\r
- if (Can_SetControllerMode(canControllerId, CAN_T_SLEEP) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_SLEEP) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_SLEEP;\r
}\r
\r
switch (oldMode)\r
{\r
case CANIF_CS_SLEEP:\r
- if (Can_SetControllerMode(canControllerId, CAN_T_WAKEUP) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_WAKEUP) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
break;\r
default:\r
// Just fall through for other cases\r
}\r
\r
CanIf_SetPduMode(channel, CANIF_SET_OFFLINE);\r
- if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)\r
+ if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;\r
+ break;\r
}\r
\r
case CANIF_CS_UNINIT:\r
CanIf_Arc_ChannelIdType channel = txEntry->CanIfCanTxPduHthRef->CanIfCanControllerIdRef;\r
\r
// Get and verify the controller mode\r
- if (CanIf_GetControllerMode(channel, &csMode) == E_NOT_OK)\r
+ if (CanIf_GetControllerMode(channel, &csMode) == E_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
\r
- if (csMode != CANIF_CS_STARTED) // CANIF_161\r
+ if (csMode != CANIF_CS_STARTED){ // CANIF_161\r
return E_NOT_OK;\r
+ }\r
\r
// Get and verify the PDU channel mode control\r
- if (CanIf_GetPduMode(channel, &pduMode) == E_NOT_OK)\r
+ if (CanIf_GetPduMode(channel, &pduMode) == E_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
\r
- if ((pduMode != CANIF_GET_TX_ONLINE) && (pduMode != CANIF_GET_ONLINE))\r
+ if ((pduMode != CANIF_GET_TX_ONLINE) && (pduMode != CANIF_GET_ONLINE)){\r
return E_NOT_OK;\r
+ }\r
\r
canPdu.id = txEntry->CanIfCanTxPduIdCanId;\r
\r
\r
Can_ReturnType rVal = Can_Write(txEntry->CanIfCanTxPduHthRef->CanIfHthIdSymRef, &canPdu);\r
\r
- if (rVal == CAN_NOT_OK)\r
+ if (rVal == CAN_NOT_OK){\r
return E_NOT_OK;\r
+ }\r
\r
if (rVal == CAN_BUSY) // CANIF 082, CANIF 161\r
{\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;\r
break;\r
case CANIF_SET_RX_OFFLINE:\r
- if (oldMode == CANIF_GET_RX_ONLINE)\r
+ if (oldMode == CANIF_GET_RX_ONLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;\r
- else if (oldMode == CANIF_GET_ONLINE)\r
+ } else if (oldMode == CANIF_GET_ONLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;\r
+ }\r
\r
// Other oldmodes don't care\r
break;\r
case CANIF_SET_RX_ONLINE:\r
- if (oldMode == CANIF_GET_OFFLINE)\r
+ if (oldMode == CANIF_GET_OFFLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;\r
- else if (oldMode == CANIF_GET_TX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_TX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;\r
+ }\r
\r
// Other oldmodes don't care\r
break;\r
case CANIF_SET_TX_OFFLINE:\r
- if (oldMode == CANIF_GET_TX_ONLINE)\r
+ if (oldMode == CANIF_GET_TX_ONLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;\r
- else if (oldMode == CANIF_GET_ONLINE)\r
+ } else if (oldMode == CANIF_GET_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;\r
+ }\r
\r
// Other oldmodes don't care\r
break;\r
case CANIF_SET_TX_ONLINE:\r
- if (oldMode == CANIF_GET_OFFLINE)\r
+ if (oldMode == CANIF_GET_OFFLINE){\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;\r
- else if (oldMode == CANIF_GET_RX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_RX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;\r
- else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;\r
+ }\r
\r
// Other oldmodes don't care\r
break;\r
break;\r
\r
case CANIF_SET_TX_OFFLINE_ACTIVE:\r
- if (oldMode == CANIF_GET_OFFLINE)\r
+ if (oldMode == CANIF_GET_OFFLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;\r
- else if (oldMode == CANIF_GET_RX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_RX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;\r
- else if (oldMode == CANIF_GET_TX_ONLINE)\r
+ } else if (oldMode == CANIF_GET_TX_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;\r
- else if (oldMode == CANIF_GET_ONLINE)\r
+ } else if (oldMode == CANIF_GET_ONLINE) {\r
CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;\r
+ }\r
\r
// Other oldmodes don't care\r
break;\r
}\r
\r
// Check that this is an extended or standard id\r
- if (((CanId & 0x80000000) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_29)) ||\r
- (((CanId & 0x80000000) == 0) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_11)))\r
+ if (((CanId & U0x80000000) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_29)) ||\r
+ (((CanId & U0x80000000) == 0) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_11)))\r
{\r
// Update the CanID\r
//txEntry->CanIfCanTxPduIdCanId = CanId; // TODO How do we fix this from a const pointer\r
\r
if (CanIf_GetPduMode(channel, &mode) == E_OK)\r
{\r
- if (mode == CANIF_GET_OFFLINE || mode == CANIF_GET_TX_ONLINE ||\r
- mode == CANIF_GET_OFFLINE_ACTIVE)\r
+ if ( (mode == CANIF_GET_OFFLINE) || (mode == CANIF_GET_TX_ONLINE) ||\r
+ (mode == CANIF_GET_OFFLINE_ACTIVE) )\r
{\r
// Receiver path is disabled so just drop it\r
return;\r
break;\r
case FIRST_FRAME:\r
// Parse the data length form the first frame.\r
- res = CanTpRxPduPtr->SduDataPtr[tpci_offset + 1] + (PduLengthType)((CanTpRxPduPtr->SduDataPtr[tpci_offset]) & 0xf << 8);\r
+ res = CanTpRxPduPtr->SduDataPtr[tpci_offset + 1] + ((PduLengthType)((CanTpRxPduPtr->SduDataPtr[tpci_offset]) & 0xf) << 8);\r
break;\r
default:\r
res = 0; // TODO: maybe we should have an error code here.\r
boolean error = FALSE;\r
*bytesWrittenSuccessfully = 0;\r
\r
- while ((*bytesWrittenSuccessfully < segmentSize) && error == FALSE) {\r
+ while ((*bytesWrittenSuccessfully < segmentSize) && (!error)) {\r
// Copy the data that resides in the buffer.\r
if (rxRuntime->pdurBuffer != NULL) {\r
while ((*bytesWrittenSuccessfully < segmentSize ) && (rxRuntime->pdurBuffer->SduLength > rxRuntime->pdurBufferCount)) {\r
break;\r
}\r
}\r
- return ret;\r
+ return ret; // 438 PC-lint: Sista värde på error används inte. OK. hittar inget fel.\r
}\r
\r
// - - - - - - - - - - - - - -\r
// - - - - - - - - - - - - - -\r
\r
static INLINE void sendFlowControlFrame(const CanTp_RxNSduType *rxConfig, CanTp_ChannelPrivateType *rxRuntime, BufReq_ReturnType flowStatus) {\r
- int indexCount = 0;\r
+ uint8 indexCount = 0;\r
Std_ReturnType ret = E_NOT_OK;\r
PduInfoType pduInfo;\r
uint8 sduData[8]; // Note that buffer in declared on the stack.\r
sduData[indexCount++] = ISO15765_TPCI_FC | ISO15765_FLOW_CONTROL_STATUS_CTS;\r
spaceFreePduRBuffer = rxRuntime->pdurBuffer->SduLength - rxRuntime->pdurBufferCount;\r
if (rxConfig->CanTpAddressingFormant == CANTP_EXTENDED) { /** @req CANTP094 *//** @req CANTP095 */\r
- computedBs = spaceFreePduRBuffer / MAX_PAYLOAD_SF_EXT_ADDR + 1; // + 1 is for local buffer.\r
+ computedBs = (spaceFreePduRBuffer / MAX_PAYLOAD_SF_EXT_ADDR) + 1; // + 1 is for local buffer.\r
} else {\r
- computedBs = spaceFreePduRBuffer / MAX_PAYLOAD_SF_STD_ADDR + 1; // + 1 is for local buffer.\r
+ computedBs = (spaceFreePduRBuffer / MAX_PAYLOAD_SF_STD_ADDR) + 1; // + 1 is for local buffer.\r
}\r
if (computedBs > rxConfig->CanTpBs) { // /** @req CANTP091 *//** @req CANTP084 */\r
computedBs = rxConfig->CanTpBs;\r
}\r
DEBUG( DEBUG_MEDIUM, "computedBs:%d\n", computedBs);\r
- sduData[indexCount++] = computedBs;\r
+ sduData[indexCount++] = computedBs; // 734 PC-lint: Okej att casta till uint8?\r
sduData[indexCount++] = (uint8) rxConfig->CanTpSTmin;\r
rxRuntime->iso15765.nextFlowControlCount = computedBs;\r
pduInfo.SduLength = indexCount;\r
\r
static INLINE void handleConsecutiveFrame(const CanTp_RxNSduType *rxConfig,\r
CanTp_ChannelPrivateType *rxRuntime, const PduInfoType *rxPduData) {\r
- int indexCount = 0;\r
+ uint8 indexCount = 0;\r
uint8 segmentNumber = 0;\r
uint8 extendedAddress = 0;\r
PduLengthType bytesLeftToCopy = 0;\r
DEBUG( DEBUG_MEDIUM, "Unexpected error, could not copy 'unaligned leftover' " "data to local buffer!\n");\r
}\r
}\r
- if ( dataCopyFailure == FALSE ) {\r
+ if ( !dataCopyFailure ) {\r
rxRuntime->iso15765.framesHandledCount++;\r
rxRuntime->iso15765.stateTimeoutCount = CANTP_CONVERT_MS_TO_MAIN_CYCLES(rxConfig->CanTpNbr);\r
rxRuntime->iso15765.state = RX_WAIT_SDU_BUFFER;\r
}\r
}\r
}\r
-}\r
+} // 438, 550 PC-lint: extendAdress används inte. EN BUG? Behöver fixas\r
\r
// - - - - - - - - - - - - - -\r
\r
PduLengthType consecutiveFrameActualPayload = 0;\r
PduLengthType remaningSduDataSize = 0;\r
PduInfoType pduInfo;\r
- int copyCount = 0;\r
- int indexCount = 0;\r
+ uint16 copyCount = 0;\r
+ uint16 indexCount = 0;\r
\r
if (txConfig->CanTpAddressingMode == CANTP_EXTENDED) { /** @req CANTP094 *//** @req CANTP095 */\r
sduData[indexCount++] = (uint8) txConfig->CanTpNTa->CanTpNTa; // Target address.\r
case ISO15765_FLOW_CONTROL_STATUS_CTS:\r
#if 1\r
{ // This construction is added to make the hcs12 compiler happy.\r
- const uint16 bs = txPduData->SduDataPtr[indexCount++];\r
+ const uint8 bs = txPduData->SduDataPtr[indexCount++];\r
txRuntime->iso15765.BS = bs;\r
txRuntime->iso15765.nextFlowControlCount = bs;\r
}\r
} else {\r
DEBUG( DEBUG_MEDIUM, "Ignoring flow control, we do not expect it!");\r
}\r
-}\r
+} // 438, 550 PC-lint: extendAdress används inte. EN BUG? Behöver fixas\r
\r
\r
// - - - - - - - - - - - - - -\r
// Validate that that there is a reason for using the segmented transfers and\r
// if not simply skip (single frame should have been used).\r
if (rxConfig->CanTpAddressingFormant == CANTP_STANDARD) { /** @req CANTP094 *//** @req CANTP095 */\r
- if (pduLength <= MAX_PAYLOAD_SF_STD_ADDR)\r
+ if (pduLength <= MAX_PAYLOAD_SF_STD_ADDR){\r
return;\r
+ }\r
} else {\r
- if (pduLength <= MAX_PAYLOAD_SF_EXT_ADDR)\r
+ if (pduLength <= MAX_PAYLOAD_SF_EXT_ADDR){\r
return;\r
+ }\r
}\r
// Validate that the SDU is full length in this first frame.\r
if (rxPduData->SduLength < CANIF_PDU_MAX_LENGTH) {\r
static INLINE Std_ReturnType sendSingleFrame(const CanTp_TxNSduType *txConfig,\r
CanTp_ChannelPrivateType *txRuntime) {\r
Std_ReturnType ret;\r
- int indexCount = 0;\r
+ uint16 indexCount = 0;\r
PduInfoType pduInfo;\r
uint8 sduData[CANIF_PDU_MAX_LENGTH];\r
\r
if (txConfig->CanTpAddressingMode == CANTP_EXTENDED) { /** @req CANTP094 *//** @req CANTP095 */\r
sduData[indexCount++] = (uint8) txConfig->CanTpNTa->CanTpNTa; // Target address.\r
}\r
- sduData[indexCount++] = ISO15765_TPCI_SF | txRuntime->transferTotal;\r
+ sduData[indexCount++] = ISO15765_TPCI_SF | txRuntime->transferTotal; // 734 PC-lint: Okej att casta till uint8?\r
for (int i = 0; i < txRuntime->transferTotal; i++) {\r
sduData[indexCount++] = txRuntime->pdurBuffer->SduDataPtr[i];\r
}\r
static INLINE Std_ReturnType sendFirstFrame(const CanTp_TxNSduType *txConfig,\r
CanTp_ChannelPrivateType *txRuntime) {\r
Std_ReturnType ret;\r
- int indexCount = 0;\r
- int i = 0;\r
+ uint8 indexCount = 0;\r
+ uint8 i = 0;\r
PduInfoType pduInfo;\r
uint8 sduData[CANIF_PDU_MAX_LENGTH];\r
\r
// - - - - - - - - - - - - - -\r
\r
\r
-void CanTp_Init()\r
+void CanTp_Init(void)\r
{\r
CanTp_ChannelPrivateType *runtimeData;\r
const CanTp_TxNSduType *txConfigParams;\r
DEBUG( DEBUG_MEDIUM, "calling handleSingleFrame!\n");\r
handleSingleFrame(rxConfigParams, runtimeParams, CanTpRxPduPtr);\r
}\r
- else\r
+ else{\r
DEBUG( DEBUG_MEDIUM, "Single frame received on ISO15765-Tx - is ignored!\n");\r
+ }\r
break;\r
}\r
case FIRST_FRAME: {\r
if (rxConfigParams != NULL) {\r
DEBUG( DEBUG_MEDIUM, "calling handleFirstFrame!\n");\r
handleFirstFrame(rxConfigParams, runtimeParams, CanTpRxPduPtr);\r
- } else\r
+ }else{\r
DEBUG( DEBUG_MEDIUM, "First frame received on ISO15765-Tx - is ignored!\n");\r
+ }\r
break;\r
}\r
case CONSECUTIVE_FRAME: {\r
if (rxConfigParams != NULL) {\r
DEBUG( DEBUG_MEDIUM, "calling handleConsecutiveFrame!\n");\r
handleConsecutiveFrame(rxConfigParams, runtimeParams, CanTpRxPduPtr);\r
- } else\r
+ } else {\r
DEBUG( DEBUG_MEDIUM, "Consecutive frame received on ISO15765-Tx - is ignored!\n");\r
+ }\r
break;\r
}\r
case FLOW_CONTROL_CTS_FRAME: {\r
if (txConfigParams != NULL) {\r
DEBUG( DEBUG_MEDIUM, "calling handleFlowControlFrame!\n");\r
handleFlowControlFrame(txConfigParams, runtimeParams, CanTpRxPduPtr);\r
- } else\r
+ } else {\r
DEBUG( DEBUG_MEDIUM, "Flow control frame received on ISO15765-Rx - is ignored!\n");\r
+ }\r
break;\r
}\r
case INVALID_FRAME: {\r
\r
// - - - - - - - - - - - - - -\r
\r
-void CanTp_TxConfirmation(PduIdType PduId) /** @req CANTP076 */\r
+void CanTp_TxConfirmation(PduIdType CanTpTxPduId) /** @req CANTP076 */\r
{\r
const CanTp_RxNSduType *rxConfigParams = NULL;\r
const CanTp_TxNSduType *txConfigParams = NULL;\r
\r
VALIDATE_NO_RV( CanTpRunTimeData.internalState == CANTP_ON,\r
SERVICE_ID_CANTP_TX_CONFIRMATION, CANTP_E_UNINIT ); /** @req CANTP031 */\r
- VALIDATE_NO_RV( PduId < CANTP_NSDU_CONFIG_LIST_SIZE,\r
+ VALIDATE_NO_RV( CanTpTxPduId < CANTP_NSDU_CONFIG_LIST_SIZE,\r
SERVICE_ID_CANTP_TX_CONFIRMATION, CANTP_E_INVALID_TX_ID ); /** @req CANTP158 */\r
\r
/** @req CANTP236 */\r
- if ( CanTpConfig.CanTpNSduList[PduId].direction == IS015765_TRANSMIT ) {\r
- txConfigParams = (CanTp_TxNSduType*)&CanTpConfig.CanTpNSduList[PduId].configData;\r
+ if ( CanTpConfig.CanTpNSduList[CanTpTxPduId].direction == IS015765_TRANSMIT ) {\r
+ txConfigParams = (CanTp_TxNSduType*)&CanTpConfig.CanTpNSduList[CanTpTxPduId].configData;\r
CanTpRunTimeData.runtimeDataList[txConfigParams->CanTpTxChannel].iso15765.NasNarPending = FALSE;\r
#if (CANTP_IMMEDIATE_TX_CONFIRMATION == STD_OFF)\r
CanTpRunTimeData.runtimeDataList[txConfigParams->CanTpTxChannel].iso15765.txConfirmed = TRUE;\r
#endif\r
} else {\r
- rxConfigParams = (CanTp_RxNSduType*)&CanTpConfig.CanTpNSduList[PduId].configData;\r
+ rxConfigParams = (CanTp_RxNSduType*)&CanTpConfig.CanTpNSduList[CanTpTxPduId].configData;\r
CanTpRunTimeData.runtimeDataList[rxConfigParams->CanTpRxChannel].iso15765.NasNarPending = FALSE;\r
}\r
}\r
\r
// - - - - - - - - - - - - - -\r
\r
-void CanTp_Shutdown() /** @req CANTP202 *//** @req CANTP200 *//** @req CANTP010 */\r
+void CanTp_Shutdown(void) /** @req CANTP202 *//** @req CANTP200 *//** @req CANTP010 */\r
{\r
VALIDATE_NO_RV( CanTpRunTimeData.internalState == CANTP_ON,\r
SERVICE_ID_CANTP_SHUTDOWN, CANTP_E_UNINIT ); /** @req CANTP031 */\r
// - - - - - - - - - - - - - -\r
\r
\r
-void CanTp_MainFunction()\r
+void CanTp_MainFunction(void)\r
{\r
BufReq_ReturnType ret;\r
CanTpFifoQueueItem item;\r
case TX_WAIT_CAN_TP_TRANSMIT_CAN_TP_PROVIDE_TX_BUFFER:\r
{\r
TIMER_DECREMENT(txRuntimeListItem->iso15765.stateTimeoutCount); /** @req CANTP185 */\r
- if (txRuntimeListItem->iso15765.stateTimeoutCount == 0)\r
+ if (txRuntimeListItem->iso15765.stateTimeoutCount == 0){\r
PduR_CanTpTxConfirmation(txConfigListItem->PduR_PduId, NTFRSLT_E_NOT_OK); /** @req CANTP204 *//** @req CANTP185 */\r
+ }\r
txRuntimeListItem->iso15765.state = IDLE;\r
txRuntimeListItem->mode = CANTP_TX_WAIT;\r
break;\r
// Diagnostic Communication Manager Callbacks\r
// ------------------------------------------\r
\r
-void ComM_DCM_ActiveDiagnostic(){\r
+void ComM_DCM_ActiveDiagnostic(void){\r
COMM_VALIDATE_INIT(COMM_SERVICEID_DCM_ACTIVEDIAGNOSTIC);\r
}\r
\r
-void ComM_DCM_InactiveDiagnostic(){\r
+void ComM_DCM_InactiveDiagnostic(void){\r
COMM_VALIDATE_INIT(COMM_SERVICEID_DCM_INACTIVEDIAGNOSTIC);\r
}\r
\r
/*\r
* The state of the PDU router.\r
*/\r
-PduR_StateType PduRState = PDUR_UNINIT;\r
+PduR_StateType PduRState = PDUR_UNINIT; // 960, 31 PC-Lint: Borde åtgärdas\r
\r
const PduR_PBConfigType * PduRConfig;\r
\r
\r
// Initialize buffers.\r
int bufferNr = 0;\r
- int i = 0;\r
PduRRoutingPath_type *path;\r
PduRConfig->PduRRoutingTable->NRoutingPaths = 0;\r
- for (i = 0; !PduRConfig->PduRRoutingTable->PduRRoutingPath[i].PduR_Arc_EOL && !failed; i++) {\r
+ for (int i = 0; (!PduRConfig->PduRRoutingTable->PduRRoutingPath[i].PduR_Arc_EOL) && (!failed); i++) {\r
PduRConfig->PduRRoutingTable->NRoutingPaths++;\r
path = &PduRConfig->PduRRoutingTable->PduRRoutingPath[i];\r
\r
(*ptr) = (*ptr) + Buffer->Length;\r
\r
// TODO make more efficient without multiplication.\r
- if (*ptr >= Buffer->Buffer + Buffer->Depth * Buffer->Length) {\r
+ if ( *ptr >= ( Buffer->Buffer + (Buffer->Depth * Buffer->Length) ) ) {\r
*ptr = Buffer->Buffer;\r
}\r
//*val = (*val + 1) % Buffer->Depth;\r
\r
uint8 PduR_BufferIsFull(PduRTxBuffer_type *Buffer) {\r
imask_t state = McuE_EnterCriticalSection();\r
+ uint8 rv = 0;\r
if (Buffer->NrItems < Buffer->Depth) {\r
- return 0;\r
+ rv = 0;\r
} else {\r
- return 1;\r
+ rv = 1;\r
}\r
McuE_ExitCriticalSection(state);\r
+ return rv;\r
}\r
\r
\r
route->FctPtrs.TargetIndicationFctPtr(route->PduRDestPdu.DestPduId, SduPtr); // Send PDU to next receptor.\r
\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_NO_PROVISION) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_NO_PROVISION) ) {\r
// This is a gateway request, but without any data provision (buffer usage).\r
PduInfoType PduInfo = {\r
- .SduDataPtr = (uint8 *)SduPtr,\r
+ .SduDataPtr = (uint8 *)SduPtr, // 926, 960 PC-Lint: Beror på att funktion PduR_LoIfRxIndication(...) fel-definerad TICKET 130\r
.SduLength = route->SduLength\r
};\r
route->FctPtrs.TargetTransmitFctPtr(route->PduRDestPdu.DestPduId, &PduInfo); // Send PDU to next receptor.\r
\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) ) {\r
// Ths is a gateway request which uses trigger transmit data provision. PDUR255\r
DEBUG(DEBUG_LOW,"\tUsing gateway mode with trigger transmit provision\n");\r
\r
}\r
}\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_DIRECT) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_DIRECT) ) {\r
// This is a gateway request using a direct data provision fifo. PDUR258\r
DEBUG(DEBUG_LOW,"\tUsing gateway mode with direct provision\n");\r
\r
// This is an ordinary request.\r
route->FctPtrs.TargetConfirmationFctPtr(route->PduRDestPdu.DestPduId); // Forward confirmation\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_NO_PROVISION) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_NO_PROVISION) ) {\r
// A gateway request without provision. Just forward confirmation.\r
route->FctPtrs.TargetConfirmationFctPtr(route->PduRDestPdu.DestPduId); // Forward confirmation\r
\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) ) {\r
// The route is using gateway mode and trigger transmit data provision. PDUR256\r
DEBUG(DEBUG_LOW,"\tUsing gateway mode with trigger transmit data provision.\n", PduId);\r
\r
}\r
\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_DIRECT) {\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_DIRECT) ) {\r
// The route is using a direct data provision fifo. PDUR259\r
DEBUG(DEBUG_LOW,"\tUsing gateway mode with direct data provision.\n", PduId);\r
\r
if (route->PduR_GatewayMode == 0) { // This is an ordinary trigger.\r
route->FctPtrs.TargetTriggerTransmitFctPtr(route->PduRDestPdu.DestPduId, SduPtr);\r
\r
- } else if (route->PduR_GatewayMode == 1 && route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) { // The route is using a trigger transmit fifo. PDUR256\r
+ } else if ( (route->PduR_GatewayMode == 1) && (route->PduRDestPdu.DataProvision == PDUR_TRIGGER_TRANSMIT) ) { // The route is using a trigger transmit fifo. PDUR256\r
DEBUG(DEBUG_LOW,"\tUsing gateway mode with trigger transmit data provision.\n", PduId);\r
memcpy((void *)SduPtr, (void *)route->PduRDestPdu.TxBufferRef->First, sizeof(uint8) * route->SduLength);\r
\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
\r
-\r
+// 904 PC-Lint: OK. Allow VALIDATE, VALIDATE_RV and VALIDATE_NO_RV to return value.\r
+//lint -emacro(904,VALIDATE_RV,VALIDATE_NO_RV,VALIDATE)\r
\r
\r
/*\r
*/\r
\r
\r
-static boolean askApplicationForServicePermission(uint8 *requestData, uint16 dataSize)\r
+static Std_ReturnType askApplicationForServicePermission(uint8 *requestData, uint16 dataSize)\r
{\r
Std_ReturnType returnCode = E_OK;\r
const Dcm_DslServiceRequestIndicationType *serviceRequestIndication = DCM_Config.Dsl->DslServiceRequestIndication;\r
Std_ReturnType result;\r
\r
- while (!serviceRequestIndication->Arc_EOL && (returnCode != E_REQUEST_NOT_ACCEPTED)) {\r
+ while ((!serviceRequestIndication->Arc_EOL) && (returnCode != E_REQUEST_NOT_ACCEPTED)) {\r
if (serviceRequestIndication->Indication != NULL) {\r
result = serviceRequestIndication->Indication(requestData, dataSize);\r
- if (result != E_OK)\r
+ if (result != E_OK){\r
returnCode = result;\r
+ }\r
}\r
serviceRequestIndication++;\r
}\r
boolean returnStatus = TRUE;\r
const Dcm_DsdServiceType *service = msgData.serviceTable->DsdService;\r
\r
- while ((service->DsdSidTabServiceId != sid) && !service->Arc_EOL) {\r
+ while ((service->DsdSidTabServiceId != sid) && (!service->Arc_EOL)) {\r
service++;\r
}\r
\r
currentSid = msgData.pduRxData->SduDataPtr[0]; /** @req DCM198 */\r
\r
/** @req DCM178 */\r
- if (DCM_RESPOND_ALL_REQUEST || ((currentSid & 0x7F) < 0x40)) { /** @req DCM084 */\r
+ if ((DCM_RESPOND_ALL_REQUEST == STD_ON) || ((currentSid & 0x7Fu) < 0x40)) { /** @req DCM084 */\r
if (lookupSid(currentSid, &sidConfPtr)) { /** @req DCM192 */ /** @req DCM193 */ /** @req DCM196 */\r
// SID found!\r
if (DspCheckSessionLevel(sidConfPtr->DsdSidTabSessionLevelRef)) { /** @req DCM211 */\r
if (DspCheckSecurityLevel(sidConfPtr->DsdSidTabSecurityLevelRef)) { /** @req DCM217 */\r
- if (DCM_REQUEST_INDICATION_ENABLED) { /** @req DCM218 */\r
+ if (DCM_REQUEST_INDICATION_ENABLED == STD_ON) { /** @req DCM218 */\r
result = askApplicationForServicePermission(msgData.pduRxData->SduDataPtr, msgData.pduRxData->SduLength);\r
+ } else {\r
+ result = E_OK;\r
}\r
- if (!DCM_REQUEST_INDICATION_ENABLED || result == E_OK) {\r
+ if (result == E_OK) {\r
// Yes! All conditions met!\r
// Check if response shall be suppressed\r
- if (sidConfPtr->DsdSidTabSubfuncAvail && (msgData.pduRxData->SduDataPtr[1] & SUPPRESS_POS_RESP_BIT)) { /** @req DCM204 */\r
+ if ( (sidConfPtr->DsdSidTabSubfuncAvail) && (msgData.pduRxData->SduDataPtr[1] & SUPPRESS_POS_RESP_BIT) ) { /** @req DCM204 */\r
suppressPosRspMsg = TRUE; /** @req DCM202 */\r
msgData.pduRxData->SduDataPtr[1] &= ~SUPPRESS_POS_RESP_BIT; /** @req DCM201 */\r
}\r
}\r
\r
\r
+\r
void DsdDspProcessingDone(Dcm_NegativeResponseCodeType responseCode)\r
{\r
if (responseCode == DCM_E_POSITIVERESPONSE) {\r
//#define USE_DEBUG_PRINTF\r
#include "debug.h"\r
\r
-#define DECREMENT(timer) { if (timer > 0) timer--; }\r
+#define DECREMENT(timer) { if (timer > 0){timer--;} }\r
#define DCM_CONVERT_MS_TO_MAIN_CYCLES(x) ((x)/DCM_MAIN_FUNCTION_PERIOD_TIME_MS)\r
\r
\r
\r
// - - - - - - - - - - -\r
\r
-void DslResetSessionTimeoutTimer() {\r
+void DslResetSessionTimeoutTimer(void) {\r
const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
static boolean isTesterPresentCommand(const PduInfoType *rxPdu) {\r
boolean ret = FALSE;\r
if ((rxPdu->SduDataPtr[0] == SID_TESTER_PRESENT) && (rxPdu->SduDataPtr[1] & SUPPRESS_POS_RESP_BIT)) {\r
- return TRUE;\r
+ ret = TRUE;\r
}\r
return ret;\r
}\r
const Dcm_DslProtocolRowType *protocolRowEntry = NULL;\r
const Dcm_DslProtocolTimingRowType *timeParams = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
- int debug_count = 0;\r
\r
protocolRowEntry = DCM_Config.Dsl->DslProtocol->DslProtocolRowList;\r
while (protocolRowEntry->Arc_EOL == FALSE) {\r
}\r
}\r
protocolRowEntry++;\r
- debug_count++;\r
}\r
}\r
\r
default:\r
break;\r
}\r
- if (externalBufferReleased == FALSE) {\r
+ if (!externalBufferReleased) {\r
switch (runtime->localTxBuffer.status) { // ### LOCAL TX BUFFER ###\r
case PROVIDED_TO_PDUR:\r
DEBUG( DEBUG_MEDIUM, "Released local buffer buffer OK!\n");\r
* Macros\r
*/\r
#define BYTES_TO_DTC(hb, mb, lb) (((uint32)(hb) << 16) | ((uint32)(mb) << 8) | (uint32)(lb))\r
-#define DTC_HIGH_BYTE(dtc) (((uint32)(dtc) >> 16) & 0xFF)\r
-#define DTC_MID_BYTE(dtc) (((uint32)(dtc) >> 8) & 0xFF)\r
-#define DTC_LOW_BYTE(dtc) ((uint32)(dtc) & 0xFF)\r
+#define DTC_HIGH_BYTE(dtc) (((uint32)(dtc) >> 16) & 0xFFu)\r
+#define DTC_MID_BYTE(dtc) (((uint32)(dtc) >> 8) & 0xFFu)\r
+#define DTC_LOW_BYTE(dtc) ((uint32)(dtc) & 0xFFu)\r
\r
\r
typedef struct {\r
Dcm_SesCtrlType currentSession;\r
\r
DslGetSesCtrlType(¤tSession);\r
- while (((*sessionLevelRefTable)->DspSessionLevel != currentSession) && !(*sessionLevelRefTable)->Arc_EOL) {\r
+ while ( ((*sessionLevelRefTable)->DspSessionLevel != currentSession) && (!(*sessionLevelRefTable)->Arc_EOL) ) {\r
sessionLevelRefTable++;\r
}\r
\r
Dcm_SecLevelType currentSecurityLevel;\r
\r
DslGetSecurityLevel(¤tSecurityLevel);\r
- while (((*securityLevelRefTable)->DspSecurityLevel != currentSecurityLevel) && !(*securityLevelRefTable)->Arc_EOL) {\r
+ while ( ((*securityLevelRefTable)->DspSecurityLevel != currentSecurityLevel) && (!(*securityLevelRefTable)->Arc_EOL) ) {\r
securityLevelRefTable++;\r
}\r
if ((*securityLevelRefTable)->Arc_EOL) {\r
Dcm_SesCtrlType currentSessionLevel;\r
Std_ReturnType result;\r
\r
- while (!sesControl->Arc_EOL && (returnCode != E_SESSION_NOT_ALLOWED)) {\r
+ while ( (!sesControl->Arc_EOL) && (returnCode != E_SESSION_NOT_ALLOWED)) {\r
if (sesControl->GetSesChgPermission != NULL) {\r
- Dcm_GetSesCtrlType(¤tSessionLevel);\r
- result = sesControl->GetSesChgPermission(currentSessionLevel ,newSessionLevel);\r
- if (result != E_OK) {\r
- returnCode = result;\r
+ result = Dcm_GetSesCtrlType(¤tSessionLevel);\r
+ if (result == E_OK) {\r
+ result = sesControl->GetSesChgPermission(currentSessionLevel ,newSessionLevel);\r
+ if (result != E_OK) {\r
+ returnCode = result;\r
+ }\r
+ } else {\r
+ returnCode = E_NOT_OK;\r
}\r
}\r
sesControl++;\r
if (pduRxData->SduLength == 2) {\r
reqSessionType = pduRxData->SduDataPtr[1];\r
// Check if type exist in session table\r
- while ((sessionRow->DspSessionLevel != reqSessionType) && !sessionRow->Arc_EOL) {\r
+ while ((sessionRow->DspSessionLevel != reqSessionType) && (!sessionRow->Arc_EOL) ) {\r
sessionRow++;\r
}\r
\r
}\r
\r
if (setDtcFilterResult == DEM_FILTER_ACCEPTED) {\r
+ Std_ReturnType result;\r
+ Dem_ReturnGetNumberOfFilteredDTCType getNumerResult;\r
uint16 numberOfFilteredDtc;\r
uint8 dtcStatusMask;\r
TxDataType *txData = (TxDataType*)pduTxData->SduDataPtr;\r
\r
/** @req DCM376 */\r
- Dem_GetNumberOfFilteredDtc(&numberOfFilteredDtc);\r
- Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
-\r
- // Create positive response (ISO 14229-1 table 251)\r
- txData->reportType = pduRxData->SduDataPtr[1]; // reportType\r
- txData->dtcStatusAvailabilityMask = dtcStatusMask; // DTCStatusAvailabilityMask\r
- txData->dtcFormatIdentifier = Dem_GetTranslationType(); // DTCFormatIdentifier\r
- txData->dtcCountHighByte = (numberOfFilteredDtc >> 8); // DTCCount high byte\r
- txData->dtcCountLowByte = (numberOfFilteredDtc & 0xFF); // DTCCount low byte\r
- pduTxData->SduLength = 6;\r
+ getNumerResult = Dem_GetNumberOfFilteredDtc(&numberOfFilteredDtc);\r
+ if (getNumerResult == DEM_NUMBER_OK) {\r
+ result = Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
+ if (result != E_OK) {\r
+ dtcStatusMask = 0;\r
+ }\r
+\r
+ // Create positive response (ISO 14229-1 table 251)\r
+ txData->reportType = pduRxData->SduDataPtr[1]; // reportType\r
+ txData->dtcStatusAvailabilityMask = dtcStatusMask; // DTCStatusAvailabilityMask\r
+ txData->dtcFormatIdentifier = Dem_GetTranslationType(); // DTCFormatIdentifier\r
+ txData->dtcCountHighByte = (numberOfFilteredDtc >> 8); // DTCCount high byte\r
+ txData->dtcCountLowByte = (numberOfFilteredDtc & 0xFFu); // DTCCount low byte\r
+ pduTxData->SduLength = 6;\r
+ } else {\r
+ // TODO: What to do?\r
+ responseCode = DCM_E_GENERALREJECT;\r
+ }\r
}\r
else {\r
responseCode = DCM_E_REQUESTOUTOFRANGE;\r
uint32 dtc;\r
Dem_EventStatusExtendedType dtcStatus;\r
uint16 nrOfDtcs = 0;\r
+ Std_ReturnType result;\r
\r
/** @req DCM377 */\r
- Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
+ result = Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
+ if (result != E_OK) {\r
+ dtcStatusMask = 0;\r
+ }\r
\r
// Create positive response (ISO 14229-1 table 252)\r
txData->reportType = pduRxData->SduDataPtr[1];\r
responseCode = DCM_E_REQUESTOUTOFRANGE;\r
}\r
}\r
- pduTxData->SduLength = 3 + nrOfDtcs * sizeof(dtcAndStatusRecordType);\r
+ pduTxData->SduLength = 3 + (nrOfDtcs * sizeof(dtcAndStatusRecordType));\r
}\r
else {\r
responseCode = DCM_E_REQUESTOUTOFRANGE;\r
return responseCode;\r
}\r
\r
-\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x08(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x09(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x06_0x10(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
if (getStatusOfDtcResult == DEM_STATUS_OK) {\r
Dem_ReturnGetExtendedDataRecordByDTCType getExtendedDataRecordByDtcResult;\r
uint16 recNum;\r
- uint8 recLength;\r
+ uint16 recLength;\r
uint16 txIndex = 6;\r
\r
/** @req DCM297 */ /** @req DCM474 */ /** @req DCM386 */\r
pduTxData->SduDataPtr[4] = DTC_LOW_BYTE(dtc); // DTC low byte\r
pduTxData->SduDataPtr[5] = statusOfDtc; // DTC status\r
for (recNum = startRecNum; recNum <= endRecNum; recNum++) {\r
- recLength = pduTxData->SduLength - txIndex -1; // Calculate what's left in buffer\r
+ recLength = pduTxData->SduLength - (txIndex + 1); // Calculate what's left in buffer\r
/** @req DCM296 */ /** @req DCM476 */ /** @req DCM382 */\r
getExtendedDataRecordByDtcResult = Dem_GetExtendedDataRecordByDTC(dtc, DEM_DTC_KIND_ALL_DTCS, dtcOrigin, recNum, &pduTxData->SduDataPtr[txIndex+1], &recLength);\r
if (getExtendedDataRecordByDtcResult == DEM_RECORD_OK) {\r
}\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x03(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x04(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x05(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x0B_0x0C_0x0D_0x0E(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x14(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
{\r
Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
\r
return responseCode;\r
}\r
+//lint -restore\r
\r
\r
void DspUdsReadDtcInformation(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
const Dcm_DspDidType *dspDid = DCM_Config.Dsp->DspDid;\r
boolean didFound = FALSE;\r
\r
- while ((dspDid->DspDidIdentifier != didNr) && !dspDid->Arc_EOL) {\r
+ while ((dspDid->DspDidIdentifier != didNr) && (!dspDid->Arc_EOL)) {\r
dspDid++;\r
}\r
\r
Dcm_NegativeResponseCodeType errorCode;\r
result = didPtr->DspDidConditionCheckReadFnc(&errorCode);\r
if ((result == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) { /** @req DCM439 */\r
- uint16 didLen;\r
+ uint16 didLen = 0;\r
result = E_NOT_OK;\r
if (didPtr->DspDidInfoRef->DspDidFixedLength) { /** @req DCM436 */\r
didLen = didPtr->DspDidSize;\r
if (result == E_OK) {\r
// Now ready for reading the data!\r
if ((*txPos + didLen + 2) <= pduTxData->SduLength) {\r
- pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFF;\r
+ pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFFu;\r
(*txPos)++;\r
- pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 0) & 0xFF;\r
+ pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 0) & 0xFFu;\r
(*txPos)++;\r
result = didPtr->DspDidReadDataFnc(&pduTxData->SduDataPtr[*txPos]); /** @req DCM437 */\r
*txPos += didLen;\r
uint16 txPos = 1;\r
uint16 i;\r
\r
- if ((pduRxData->SduLength - 1) % 2 == 0 ) {\r
+ if ( ((pduRxData->SduLength - 1) % 2) == 0 ) {\r
nrOfDids = (pduRxData->SduLength - 1) / 2;\r
\r
for (i = 0; (i < nrOfDids) && (responseCode == DCM_E_POSITIVERESPONSE); i++) {\r
- didNr = (pduRxData->SduDataPtr[1+i*2] << 8) + pduRxData->SduDataPtr[2+i*2];\r
+ didNr = (uint16)((uint16)pduRxData->SduDataPtr[1+(i*2)] << 8) + pduRxData->SduDataPtr[2+(i*2)];\r
if (lookupDid(didNr, &didPtr)) { /** @req DCM438 */\r
responseCode = readDidData(didPtr, pduTxData, &txPos);\r
}\r
Std_ReturnType result;\r
Dcm_NegativeResponseCodeType errorCode;\r
\r
- pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFF;\r
+ pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFFu;\r
(*txPos)++;\r
- pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 0) & 0xFF;\r
+ pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 0) & 0xFFu;\r
(*txPos)++;\r
result = didPtr->DspDidGetScalingInfoFnc(&pduTxData->SduDataPtr[*txPos], &errorCode); /** @req DCM394 */\r
*txPos += scalingInfoLen;\r
uint16 txPos = 1;\r
\r
if (pduRxData->SduLength == 3) {\r
- didNr = (pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
+ didNr = (uint16)((uint16)pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
if (lookupDid(didNr, &didPtr)) {\r
responseCode = readDidScalingData(didPtr, pduTxData, &txPos);\r
}\r
Dcm_NegativeResponseCodeType errorCode;\r
result = didPtr->DspDidConditionCheckWriteFnc(&errorCode); /** @req DCM471 */\r
if ((result == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {\r
- uint16 didLen;\r
+ uint16 didLen = 0;\r
result = E_NOT_OK;\r
if (didPtr->DspDidInfoRef->DspDidFixedLength) { /** @req DCM472 */\r
didLen = didPtr->DspDidSize;\r
else {\r
if (didPtr->DspDidReadDataLengthFnc != NULL) {\r
result = didPtr->DspDidReadDataLengthFnc(&didLen);\r
- }\r
- }\r
+ } }\r
\r
if (result == E_OK) {\r
if (didLen == writeDidLen) { /** @req DCM473 */\r
uint16 didDataLength;\r
\r
didDataLength = pduRxData->SduLength - 3;\r
- didNr = (pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
+ didNr = (uint16)((uint16)pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
if (lookupDid(didNr, &didPtr)) { /** @req DCM467 */\r
responseCode = writeDidData(didPtr, pduRxData, didDataLength);\r
}\r
\r
if (responseCode == DCM_E_POSITIVERESPONSE) {\r
pduTxData->SduLength = 3;\r
- pduTxData->SduDataPtr[1] = (didNr >> 8) & 0xFF;\r
- pduTxData->SduDataPtr[2] = (didNr >> 0) & 0xFF;\r
+ pduTxData->SduDataPtr[1] = (didNr >> 8) & 0xFFu;\r
+ pduTxData->SduDataPtr[2] = (didNr >> 0) & 0xFFu;\r
}\r
\r
DsdDspProcessingDone(responseCode);\r
\r
// Check sub function range (0x01 to 0x42)\r
if ((pduRxData->SduDataPtr[1] >= 0x01) && (pduRxData->SduDataPtr[1] <= 0x42)) {\r
- boolean isRequestSeed = pduRxData->SduDataPtr[1] & 0x01;\r
+ boolean isRequestSeed = pduRxData->SduDataPtr[1] & 0x01u;\r
Dcm_SecLevelType requestedSecurityLevel = (pduRxData->SduDataPtr[1]-1)/2;\r
Dcm_NegativeResponseCodeType getSeedErrorCode;\r
\r
// requestSeed message\r
// Check if type exist in security table\r
const Dcm_DspSecurityRowType *securityRow = &DCM_Config.Dsp->DspSecurity->DspSecurityRow[0];\r
- while ((securityRow->DspSecurityLevel != requestedSecurityLevel) && !securityRow->Arc_EOL) {\r
+ while ((securityRow->DspSecurityLevel != requestedSecurityLevel) && (!securityRow->Arc_EOL)) {\r
securityRow++;\r
}\r
if (!securityRow->Arc_EOL) {\r
// Check length\r
if (pduRxData->SduLength == (2 + securityRow->DspSecurityADRSize)) { /** @req DCM321.RequestSeed */\r
Dcm_SecLevelType activeSecLevel;\r
- Dcm_GetSecurityLevel(&activeSecLevel);\r
- if (requestedSecurityLevel == activeSecLevel) { /** @req DCM323 */\r
- pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
- // If same level set the seed to zeroes\r
- memset(&pduTxData->SduDataPtr[2], 0, securityRow->DspSecuritySeedSize);\r
- pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
- }\r
- else {\r
- // New security level ask for seed\r
- if (securityRow->GetSeed != NULL) {\r
- Std_ReturnType getSeedResult;\r
- getSeedResult = securityRow->GetSeed(&pduRxData->SduDataPtr[2], &pduTxData->SduDataPtr[2], &getSeedErrorCode); /** @req DCM324.RequestSeed */\r
- if ((getSeedResult == E_OK) && (getSeedErrorCode == E_OK)) {\r
- // Everything ok add sub function to tx message and send it.\r
- pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
- pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
-\r
- dspUdsSecurityAccesData.reqSecLevel = requestedSecurityLevel;\r
- dspUdsSecurityAccesData.reqSecLevelRef = securityRow;\r
- dspUdsSecurityAccesData.reqInProgress = TRUE;\r
- }\r
- else {\r
- // GetSeed returned not ok\r
+ Std_ReturnType result;\r
+ result = Dcm_GetSecurityLevel(&activeSecLevel);\r
+ if (result == E_OK) {\r
+ if (requestedSecurityLevel == activeSecLevel) { /** @req DCM323 */\r
+ pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
+ // If same level set the seed to zeroes\r
+ memset(&pduTxData->SduDataPtr[2], 0, securityRow->DspSecuritySeedSize);\r
+ pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
+ } else {\r
+ // New security level ask for seed\r
+ if (securityRow->GetSeed != NULL) {\r
+ Std_ReturnType getSeedResult;\r
+ getSeedResult = securityRow->GetSeed(&pduRxData->SduDataPtr[2], &pduTxData->SduDataPtr[2], &getSeedErrorCode); /** @req DCM324.RequestSeed */\r
+ if ((getSeedResult == E_OK) && (getSeedErrorCode == E_OK)) {\r
+ // Everything ok add sub function to tx message and send it.\r
+ pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
+ pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
+\r
+ dspUdsSecurityAccesData.reqSecLevel = requestedSecurityLevel;\r
+ dspUdsSecurityAccesData.reqSecLevelRef = securityRow;\r
+ dspUdsSecurityAccesData.reqInProgress = TRUE;\r
+ }\r
+ else {\r
+ // GetSeed returned not ok\r
+ responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
+ }\r
+ } else {\r
responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
}\r
- } else {\r
- responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
}\r
+ } else {\r
+ // TODO: What to do?\r
+ responseCode = DCM_E_GENERALREJECT;\r
}\r
+\r
}\r
else {\r
// Length not ok\r
Std_ReturnType DslGetActiveProtocol(Dcm_ProtocolType *protocolId);\r
void DslSetSecurityLevel(Dcm_SecLevelType secLevel);\r
Std_ReturnType DslGetSecurityLevel(Dcm_SecLevelType *secLevel);\r
-void DslSetSesCtrlType(Dcm_SesCtrlType sesCtrlType);\r
+void DslSetSesCtrlType(Dcm_SesCtrlType sesCtrl);\r
Std_ReturnType DslGetSesCtrlType(Dcm_SesCtrlType *sesCtrlType);\r
BufReq_ReturnType DslProvideTxBuffer(PduIdType dcmTxPduId, const PduInfoType **pduInfoPtr, PduLengthType length);\r
void DslTxConfirmation(PduIdType dcmTxPduId, NotifResultType result);\r
} Dcm_DspDidInfoType; /** @req DCM607 */\r
\r
// 10.2.22\r
-typedef struct _Dcm_DspDidType {\r
+typedef struct Dcm_DspDidType {\r
boolean DspDidUsePort; // (1)\r
uint16 DspDidIdentifier; // (1) /** @req DCM602 */\r
const Dcm_DspDidInfoType *DspDidInfoRef; // (1) /** @req DCM604 */\r
- const struct _Dcm_DspDidType **DspDidRef; // (0..*) /** @req DCM606 */\r
+ const struct Dcm_DspDidType **DspDidRef; // (0..*) /** @req DCM606 */\r
uint16 DspDidSize; // (1) /** @req DCM605 */\r
Dcm_CallbackReadDataLengthFncType DspDidReadDataLengthFnc; // (0..1) /** @req DCM671 */\r
Dcm_CallbackConditionCheckReadFncType DspDidConditionCheckReadFnc; // (0..1) /** @req DCM677 */\r
typedef enum\r
{\r
BUFFER_AVAILABLE,\r
- BUFFER_BUSY,\r
+ BUFFER_BUSY\r
}Dcm_DslBufferStatusType;\r
\r
\r
* for more details.\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
-\r
+// 904 PC-Lint: OK. Allow VALIDATE, VALIDATE_RV and VALIDATE_NO_RV to return value.\r
+//lint -emacro(904,VALIDATE_RV,VALIDATE_NO_RV,VALIDATE)\r
\r
\r
\r
#if ( DEM_DEV_ERROR_DETECT == STD_ON )\r
#include "Det.h"\r
/** @req DEM117 */\r
-#define VALIDATE(_exp,_api,_err ) \\r
- if( !(_exp) ) { \\r
- Det_ReportError(MODULE_ID_DEM, 0, _api, _err); \\r
- return E_NOT_OK; \\r
- }\r
-\r
#define VALIDATE_RV(_exp,_api,_err,_rv ) \\r
if( !(_exp) ) { \\r
Det_ReportError(MODULE_ID_DEM, 0, _api, _err); \\r
#define DET_REPORTERROR(_x,_y,_z,_q) Det_ReportError(_x, _y, _z, _q)\r
\r
#else\r
-#define VALIDATE(_exp,_api,_err )\r
#define VALIDATE_RV(_exp,_api,_err,_rv )\r
#define VALIDATE_NO_RV(_exp,_api,_err )\r
#define DET_REPORTERROR(_x,_y,_z,_q)\r
* Procedure: zeroPriMemBuffers\r
* Description: Fill the primary buffers with zeroes\r
*/\r
-void demZeroPriMemBuffers(void)\r
+void demZeroPriMemBuffers(void) // 957 PC-Lint (MISRA 8.1): OK. Used only by DemTest\r
{\r
memset(priMemEventBuffer, 0, sizeof(priMemEventBuffer));\r
memset(priMemFreezeFrameBuffer, 0, sizeof(priMemFreezeFrameBuffer));\r
static ChecksumType calcChecksum(void *data, uint16 nrOfBytes)\r
{\r
uint16 i;\r
- uint8 *ptr = (uint8*)data;\r
+ uint8 *byte = (uint8*)data;\r
ChecksumType sum = 0;\r
\r
- for (i = 0; i < nrOfBytes; i++)\r
- sum += *ptr++;\r
- sum ^= 0xaaaa;\r
+ for (i = 0; i < nrOfBytes; i++) {\r
+ sum += byte[i];\r
+ }\r
+ sum ^= 0xaaaau;\r
return sum;\r
}\r
\r
-\r
/*\r
* Procedure: checkDtcKind\r
* Description: Return TRUE if "dtcKind" match the events DTCKind or "dtcKind"\r
static boolean checkDtcOrigin(Dem_DTCOriginType dtcOrigin, const Dem_EventParameterType *eventParam)\r
{\r
boolean result = FALSE;\r
+ boolean dtcOriginFound = FALSE;\r
uint16 i;\r
\r
- for (i = 0; (eventParam->EventClass->EventDestination[i] != dtcOrigin) && (i < DEM_MAX_NR_OF_EVENT_DESTINATION); i++);\r
+ for (i = 0;(i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (!dtcOriginFound); i++){\r
+ dtcOriginFound = (eventParam->EventClass->EventDestination[i] == dtcOrigin);\r
+ }\r
\r
- if (i < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
+ if (dtcOriginFound) {\r
result = TRUE;\r
}\r
\r
return result;\r
}\r
\r
-\r
/*\r
* Procedure: checkDtcSeverityMask\r
* Description: Return TRUE if "dtcSeverityMask" match any of the events DTC severity otherwise FALSE.\r
*/\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static boolean checkDtcSeverityMask(Dem_DTCSeverityType dtcSeverityMask, const Dem_EventParameterType *eventParam)\r
{\r
boolean result = TRUE;\r
\r
return result;\r
}\r
+//lint -restore\r
\r
\r
/*\r
* Procedure: checkDtcFaultDetectionCounterMask\r
* Description: TBD.\r
*/\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static boolean checkDtcFaultDetectionCounter(const Dem_EventParameterType *eventParam)\r
{\r
boolean result = TRUE;\r
\r
return result;\r
}\r
-\r
+//lint -restore\r
\r
/*\r
* Procedure: lookupEventStatusRec\r
*/\r
static void lookupEventStatusRec(Dem_EventIdType eventId, EventStatusRecType **const eventStatusRec)\r
{\r
- EventStatusRecType *eventStatusRecPtr = eventStatusBuffer;\r
+ uint8 i;\r
+ boolean eventIdFound = FALSE;\r
\r
- while ((eventStatusRecPtr->eventId != eventId) && (eventStatusRecPtr < &eventStatusBuffer[DEM_MAX_NUMBER_EVENT])) {\r
- eventStatusRecPtr++;\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && (!eventIdFound); i++) {\r
+ eventIdFound = (eventStatusBuffer[i].eventId == eventId);\r
}\r
\r
- if (eventStatusRecPtr < &eventStatusBuffer[DEM_MAX_NUMBER_EVENT]) {\r
- *eventStatusRec = eventStatusRecPtr;\r
+ if (eventIdFound) {\r
+ *eventStatusRec = &eventStatusBuffer[i-1];\r
} else {\r
*eventStatusRec = NULL;\r
}\r
*/\r
static void lookupEventIdParameter(Dem_EventIdType eventId, const Dem_EventParameterType **const eventIdParam)\r
{\r
- const Dem_EventParameterType *EventIdParamPtr = configSet->EventParameter;\r
+ const Dem_EventParameterType *EventIdParamList = configSet->EventParameter;\r
\r
// Lookup the correct event id parameters\r
- while ((EventIdParamPtr->EventID != eventId) && !EventIdParamPtr->Arc_EOL) {\r
- EventIdParamPtr++;\r
+ uint16 i=0;\r
+ while ((EventIdParamList[i].EventID != eventId) && (!EventIdParamList[i].Arc_EOL)) {\r
+ i++;\r
}\r
\r
- if (!EventIdParamPtr->Arc_EOL) {\r
- *eventIdParam = EventIdParamPtr;\r
+ if (!EventIdParamList[i].Arc_EOL) {\r
+ *eventIdParam = &EventIdParamList[i];\r
} else {\r
*eventIdParam = NULL;\r
}\r
* Procedure: preDebounceNone\r
* Description: Returns the result of the debouncing.\r
*/\r
-static Dem_EventStatusType preDebounceNone(Dem_EventStatusType reportedStatus, EventStatusRecType* statusRecord) {\r
+static Dem_EventStatusType preDebounceNone(const Dem_EventStatusType reportedStatus, const EventStatusRecType* statusRecord) {\r
Dem_EventStatusType returnCode;\r
+ (void)statusRecord; // Just to get rid of PC-Lint warnings\r
\r
switch (reportedStatus) {\r
case DEM_EVENT_STATUS_FAILED: /** @req DEM091.NoneFailed */\r
switch (reportedStatus) {\r
case DEM_EVENT_STATUS_PREFAILED:\r
if (statusRecord->faultDetectionCounter < DEBOUNCE_FDC_TEST_FAILED) {\r
- if (pdVars->JumpUp && (statusRecord->faultDetectionCounter < 0)) {\r
+ if ((pdVars->JumpUp) && (statusRecord->faultDetectionCounter < 0)) {\r
statusRecord->faultDetectionCounter = 0;\r
} else {\r
- if (((sint16)statusRecord->faultDetectionCounter + pdVars->CountInStepSize) < DEBOUNCE_FDC_TEST_FAILED) {\r
- statusRecord->faultDetectionCounter += pdVars->CountInStepSize;\r
+ if (((sint16)statusRecord->faultDetectionCounter + (sint8)pdVars->CountInStepSize) < DEBOUNCE_FDC_TEST_FAILED) {\r
+ statusRecord->faultDetectionCounter += (sint8)pdVars->CountInStepSize;\r
} else {\r
statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_FAILED;\r
}\r
\r
case DEM_EVENT_STATUS_PREPASSED:\r
if (statusRecord->faultDetectionCounter > DEBOUNCE_FDC_TEST_PASSED) {\r
- if (pdVars->JumpDown && (statusRecord->faultDetectionCounter > 0)) {\r
+ if ((pdVars->JumpDown) && (statusRecord->faultDetectionCounter > 0)) {\r
statusRecord->faultDetectionCounter = 0;\r
} else {\r
- if (((sint16)statusRecord->faultDetectionCounter - pdVars->CountOutStepSize) > DEBOUNCE_FDC_TEST_PASSED) {\r
- statusRecord->faultDetectionCounter -= pdVars->CountOutStepSize;\r
+ if (((sint16)statusRecord->faultDetectionCounter - (sint8)pdVars->CountOutStepSize) > DEBOUNCE_FDC_TEST_PASSED) {\r
+ statusRecord->faultDetectionCounter -= (sint8)pdVars->CountOutStepSize;\r
} else {\r
statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_PASSED;\r
}\r
}\r
/** @req DEM036 */ /** @req DEM379.PendingSet */\r
eventStatusRecPtr->eventStatusExtended |= (DEM_TEST_FAILED | DEM_TEST_FAILED_THIS_OPERATION_CYCLE | DEM_TEST_FAILED_SINCE_LAST_CLEAR | DEM_PENDING_DTC);\r
- eventStatusRecPtr->eventStatusExtended &= ~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
+ eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
}\r
\r
// Check test passed\r
eventStatusRecPtr->errorStatusChanged = TRUE;\r
}\r
/** @req DEM036 */\r
- eventStatusRecPtr->eventStatusExtended &= ~DEM_TEST_FAILED;\r
- eventStatusRecPtr->eventStatusExtended &= ~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
+ eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED;\r
+ eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
}\r
\r
// Copy the record\r
else {\r
// Copy an empty record to return data\r
eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
- eventStatusRecPtr->faultDetectionCounter = 0;\r
+ eventStatusRec->faultDetectionCounter = 0;\r
eventStatusRec->occurrence = 0;\r
eventStatusRec->eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
eventStatusRec->errorStatusChanged = FALSE;\r
* Procedure: mergeEventStatusRec\r
* Description: Update the occurrence counter of status, if not exist a new record is created\r
*/\r
-static void mergeEventStatusRec(EventRecType *eventRec)\r
+static void mergeEventStatusRec(const EventRecType *eventRec)\r
{\r
EventStatusRecType *eventStatusRecPtr;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
*eventStatusRec = NULL;\r
\r
- for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && !dtcFound; i++) {\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && (!dtcFound); i++) {\r
if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
if (eventStatusBuffer[i].eventParamRef->DTCClassRef != NULL) {\r
\r
\r
// Check severity\r
if ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
- || ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES) && checkDtcSeverityMask(dtcFilter.dtcSeverityMask, eventRec->eventParamRef))) {\r
+ || ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES) && (checkDtcSeverityMask(dtcFilter.dtcSeverityMask, eventRec->eventParamRef)))) {\r
\r
// Check fault detection counter\r
if ((dtcFilter.filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_NO)\r
- || ((dtcFilter.filterWithSeverity == DEM_FILTER_FOR_FDC_YES) && checkDtcFaultDetectionCounter(eventRec->eventParamRef))) {\r
+ || ((dtcFilter.filterWithSeverity == DEM_FILTER_FOR_FDC_YES) && (checkDtcFaultDetectionCounter(eventRec->eventParamRef)))) {\r
dtcMatch = TRUE;\r
}\r
}\r
}\r
\r
\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static void getFreezeFrameData(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
{\r
// TODO: Fill out\r
freezeFrame->eventId = DEM_EVENT_ID_NULL; // Not supported yet\r
}\r
+//lint -restore\r
\r
-\r
-static void storeFreezeFrameDataPreInit(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
+static void storeFreezeFrameDataPreInit(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
{\r
// TODO: Fill out\r
}\r
+//lint -restore\r
\r
-\r
-static void updateFreezeFrameOccurrencePreInit(EventRecType *EventBuffer)\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
+static void updateFreezeFrameOccurrencePreInit(const EventRecType *EventBuffer)\r
{\r
// TODO: Fill out\r
}\r
-\r
+//lint -restore // PC-lint: Restore to original error-setting.\r
\r
/*\r
* Procedure: getExtendedData\r
callbackReturnCode = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->CallbackGetExtDataRecord(&extData->data[storeIndex]); /** @req DEM282 */\r
if (callbackReturnCode != E_OK) {\r
// Callback data currently not available, clear space.\r
- memset(&extData->data[storeIndex], 0xFF, recordSize);\r
+ memset(&extData->data[storeIndex], 0xFF, recordSize); // PC-Lint OK\r
}\r
storeIndex += recordSize;\r
}\r
* Description: Store the extended data pointed by "extendedData" to the "preInitExtDataBuffer",\r
* if non existent a new entry is created.\r
*/\r
-static void storeExtendedDataPreInit(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData)\r
+static void storeExtendedDataPreInit(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData)\r
{\r
+ boolean eventIdFound = FALSE;\r
+ boolean eventIdFreePositionFound=FALSE;\r
uint16 i;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
// Check if already stored\r
- for (i = 0; (preInitExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT); i++);\r
+ for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) && (!eventIdFound); i++){\r
+ eventIdFound = (preInitExtDataBuffer[i].eventId == eventParam->EventID);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) {\r
+ if(eventIdFound){\r
// Yes, overwrite existing\r
- memcpy(&preInitExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
+ /*lint -esym(669,memcpy) -e826 */ /* supress lintwarning 669 and 826 locally. */\r
+ memcpy(&preInitExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType)); // 826,669 PC-Lint: OK. TA BORT ERROR! Lint does not recognise the size of the preInitExtDataBuffer record correctly.\r
}\r
- else {\r
+ else{\r
// No, lookup first free position\r
- for (i = 0; (preInitExtDataBuffer[i].eventId !=0) && (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT); i++);\r
+ for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) && (!eventIdFreePositionFound); i++){\r
+ if(preInitExtDataBuffer[i].eventId ==0){\r
+ eventIdFreePositionFound=TRUE;\r
+ }\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) {\r
- memcpy(&preInitExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
+ if (eventIdFreePositionFound) {\r
+ memcpy(&preInitExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
}\r
else {\r
// Error: Pre init extended data buffer full\r
McuE_ExitCriticalSection(state);\r
}\r
\r
-\r
/*\r
* Procedure: storeEventPriMem\r
* Description: Store the event data of "eventStatus->eventId" in "priMemEventBuffer",\r
* if non existent a new entry is created.\r
*/\r
-static void storeEventPriMem(const Dem_EventParameterType *eventParam, EventStatusRecType *eventStatus)\r
+static void storeEventPriMem(const Dem_EventParameterType *eventParam, const EventStatusRecType *eventStatus)\r
{\r
+ boolean eventIdFound = FALSE;\r
+ boolean eventIdFreePositionFound=FALSE;\r
uint16 i;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
-\r
// Lookup event ID\r
- for (i = 0; (priMemEventBuffer[i].eventId != eventStatus->eventId) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFound); i++){\r
+ eventIdFound = (priMemEventBuffer[i].eventId == eventStatus->eventId);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
+ if (eventIdFound) {\r
// Update event found\r
- priMemEventBuffer[i].occurrence = eventStatus->occurrence;\r
- priMemEventBuffer[i].checksum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
+ priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
+ priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
}\r
else {\r
// Search for free position\r
- for (i=0; (priMemEventBuffer[i].eventId != DEM_EVENT_ID_NULL) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
+ for (i=0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFreePositionFound); i++){\r
+ eventIdFreePositionFound = (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
+ }\r
+\r
\r
- if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
- priMemEventBuffer[i].eventId = eventStatus->eventId;\r
- priMemEventBuffer[i].occurrence = eventStatus->occurrence;\r
- priMemEventBuffer[i].checksum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
+ if (eventIdFreePositionFound) {\r
+ priMemEventBuffer[i-1].eventId = eventStatus->eventId;\r
+ priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
+ priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
}\r
else {\r
// Error: Pri mem event buffer full\r
McuE_ExitCriticalSection(state);\r
}\r
\r
-\r
/*\r
* Procedure: deleteEventPriMem\r
* Description: Delete the event data of "eventParam->eventId" from "priMemEventBuffer".\r
*/\r
static void deleteEventPriMem(const Dem_EventParameterType *eventParam)\r
{\r
+ boolean eventIdFound = FALSE;\r
uint16 i;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
\r
// Lookup event ID\r
- for (i = 0; (priMemEventBuffer[i].eventId != eventParam->EventID) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFound); i++){\r
+ eventIdFound = (priMemEventBuffer[i].eventId == eventParam->EventID);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
+ if (eventIdFound) {\r
// Delete event found\r
- memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
+ memset(&priMemEventBuffer[i-1], 0, sizeof(EventRecType));\r
}\r
\r
McuE_ExitCriticalSection(state);\r
}\r
\r
-\r
/*\r
* Procedure: storeEventEvtMem\r
* Description: Store the event data of "eventStatus->eventId" in event memory according to\r
* "eventParam" destination option.\r
*/\r
-static void storeEventEvtMem(const Dem_EventParameterType *eventParam, EventStatusRecType *eventStatus)\r
+static void storeEventEvtMem(const Dem_EventParameterType *eventParam, const EventStatusRecType *eventStatus)\r
{\r
uint16 i;\r
\r
* Description: Store the extended data pointed by "extendedData" to the "priMemExtDataBuffer",\r
* if non existent a new entry is created.\r
*/\r
-static void storeExtendedDataPriMem(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData) /** @req DEM041 */\r
+static void storeExtendedDataPriMem(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData) /** @req DEM041 */\r
{\r
+ boolean eventIdFound = FALSE;\r
+ boolean eventIdFreePositionFound=FALSE;\r
uint16 i;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
// Check if already stored\r
- for (i = 0; (priMemExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
+ for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++){\r
+ eventIdFound = (priMemExtDataBuffer[i].eventId == eventParam->EventID);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
+ if (eventIdFound) {\r
// Yes, overwrite existing\r
- memcpy(&priMemExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
+ memcpy(&priMemExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
}\r
else {\r
// No, lookup first free position\r
- for (i = 0; (priMemExtDataBuffer[i].eventId != DEM_EVENT_ID_NULL) && (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
- memcpy(&priMemExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFreePositionFound); i++){\r
+ eventIdFreePositionFound = (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
+ }\r
+ if (eventIdFreePositionFound) {\r
+ memcpy(&priMemExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
}\r
else {\r
// Error: Pri mem extended data buffer full\r
McuE_ExitCriticalSection(state);\r
}\r
\r
-\r
/*\r
* Procedure: deleteExtendedDataPriMem\r
* Description: Delete the extended data of "eventParam->eventId" from "priMemExtDataBuffer".\r
*/\r
static void deleteExtendedDataPriMem(const Dem_EventParameterType *eventParam)\r
{\r
+ boolean eventIdFound = FALSE;\r
uint16 i;\r
imask_t state = McuE_EnterCriticalSection();\r
\r
// Check if already stored\r
- for (i = 0; (priMemExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
+ for (i = 0;(i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++){\r
+ eventIdFound = (priMemExtDataBuffer[i].eventId == eventParam->EventID);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
+ if (eventIdFound) {\r
// Yes, clear record\r
- memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
+ memset(&priMemExtDataBuffer[i-1], 0, sizeof(ExtDataRecType));\r
}\r
\r
McuE_ExitCriticalSection(state);\r
}\r
\r
-\r
/*\r
* Procedure: storeExtendedDataEvtMem\r
* Description: Store the extended data in event memory according to\r
* "eventParam" destination option\r
*/\r
-static void storeExtendedDataEvtMem(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData)\r
+static void storeExtendedDataEvtMem(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData)\r
{\r
uint16 i;\r
\r
* Description: Returns TRUE if the requested extended data number was found among the configured records for the event.\r
* "extDataRecClassPtr" returns a pointer to the record class, "posInExtData" returns the position in stored extended data.\r
*/\r
-static boolean lookupExtendedDataRecNumParam(uint8 extendedDataNumber, const Dem_EventParameterType *eventParam, Dem_ExtendedDataRecordClassType const **extDataRecClassPtr, uint8 *posInExtData)\r
+static boolean lookupExtendedDataRecNumParam(uint8 extendedDataNumber, const Dem_EventParameterType *eventParam, Dem_ExtendedDataRecordClassType const **extDataRecClassPtr, uint16 *posInExtData)\r
{\r
boolean recNumFound = FALSE;\r
\r
uint16 i;\r
\r
// Request extended data and copy it to the buffer\r
- for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (extDataRecClassRefList[i] != NULL) && !recNumFound; i++) {\r
+ for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (extDataRecClassRefList[i] != NULL) && (!recNumFound); i++) {\r
if (extDataRecClassRefList[i]->RecordNumber == extendedDataNumber) {\r
*extDataRecClassPtr = extDataRecClassRefList[i];\r
*posInExtData = byteCnt;\r
static boolean lookupExtendedDataPriMem(Dem_EventIdType eventId, ExtDataRecType **extData)\r
{\r
boolean eventIdFound = FALSE;\r
- uint16 i;\r
+ sint16 i;\r
\r
// Lookup corresponding extended data\r
- for (i = 0; (priMemExtDataBuffer[i].eventId != eventId) && (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
+ for (i = 0; (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++) {\r
+ eventIdFound = (priMemExtDataBuffer[i].eventId == eventId);\r
+ }\r
\r
- if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
+ if (eventIdFound) {\r
// Yes, return pointer\r
- *extData = &priMemExtDataBuffer[i];\r
- eventIdFound = TRUE;\r
+ *extData = &priMemExtDataBuffer[i-1];\r
}\r
\r
return eventIdFound;\r
}\r
\r
-\r
-static void storeFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
+static void storeFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
{\r
// TODO: Fill out\r
}\r
+//lint -restore\r
\r
-\r
+// PC-Lint (715 etc): Remove errors until function is filled.\r
+//lint -save -e*\r
static void deleteFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam)\r
{\r
// TODO: Fill out\r
}\r
+//lint -restore\r
\r
\r
/*\r
* Description: Store the freeze frame data in event memory according to\r
* "eventParam" destination option\r
*/\r
-static void storeFreezeFrameDataEvtMem(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
+static void storeFreezeFrameDataEvtMem(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
{\r
uint16 i;\r
\r
if (eventParam != NULL) {\r
if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
- if (!(disableDtcStorage.storageDisabled && checkDtcGroup(disableDtcStorage.dtcGroup, eventParam) && checkDtcKind(disableDtcStorage.dtcKind, eventParam))) {\r
+ if ((!((disableDtcStorage.storageDisabled) && (checkDtcGroup(disableDtcStorage.dtcGroup, eventParam)) && (checkDtcKind(disableDtcStorage.dtcKind, eventParam))))) {\r
updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
if (eventStatusLocal.errorStatusChanged) {\r
if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
\r
lookupEventStatusRec(eventId, &eventStatusRecPtr);\r
if (eventStatusRecPtr != NULL) {\r
- eventStatusRecPtr->eventStatusExtended &= ~DEM_TEST_FAILED; /** @req DEM187 */\r
+ eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED; /** @req DEM187 */\r
}\r
\r
McuE_ExitCriticalSection(state);\r
// Lookup event ID\r
for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
- eventStatusBuffer[i].eventStatusExtended &= ~DEM_TEST_FAILED_THIS_OPERATION_CYCLE;\r
+ eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED_THIS_OPERATION_CYCLE;\r
eventStatusBuffer[i].eventStatusExtended |= DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE;\r
}\r
}\r
// Lookup event ID\r
for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
- if (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED_THIS_OPERATION_CYCLE) && !(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE)) {\r
- eventStatusBuffer[i].eventStatusExtended &= ~DEM_PENDING_DTC; // Clear pendingDTC bit /** @req DEM379.PendingClear\r
+ if ((!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED_THIS_OPERATION_CYCLE)) && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE))) {\r
+ eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_PENDING_DTC; // Clear pendingDTC bit /** @req DEM379.PendingClear\r
}\r
}\r
}\r
void Dem_PreInit(void)\r
{\r
/** @req DEM180 */\r
- int i, j;\r
+ uint16 i, j;\r
\r
VALIDATE_NO_RV(DEM_Config.ConfigSet != NULL, DEM_PREINIT_ID, DEM_E_CONFIG_PTR_INVALID);\r
\r
preInitFreezeFrameBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
preInitFreezeFrameBuffer[i].occurrence = 0;\r
preInitFreezeFrameBuffer[i].dataSize = 0;\r
- for (j = 0; j < DEM_MAX_SIZE_FF_DATA;j++)\r
+ for (j = 0; j < DEM_MAX_SIZE_FF_DATA;j++){\r
preInitFreezeFrameBuffer[i].data[j] = 0;\r
+ }\r
}\r
\r
for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
preInitExtDataBuffer[i].checksum = 0;\r
preInitExtDataBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
preInitExtDataBuffer[i].dataSize = 0;\r
- for (j = 0; j < DEM_MAX_SIZE_EXT_DATA;j++)\r
+ for (j = 0; j < DEM_MAX_SIZE_EXT_DATA;j++){\r
preInitExtDataBuffer[i].data[j] = 0;\r
+ }\r
}\r
\r
disableDtcStorage.storageDisabled = FALSE;\r
\r
- setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START); /** @req DEM047 */\r
+ (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START); /** @req DEM047 */\r
\r
demState = DEM_PREINITIALIZED;\r
}\r
// Validate event records stored in primary memory\r
for (i = 0; i < DEM_MAX_NUMBER_EVENT_PRI_MEM; i++) {\r
cSum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
- if ((cSum != priMemEventBuffer[i].checksum) || priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL) {\r
+ if ((cSum != priMemEventBuffer[i].checksum) || (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
// Unlegal record, clear the record\r
memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
}\r
// Validate extended data records stored in primary memory\r
for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM; i++) {\r
cSum = calcChecksum(&priMemExtDataBuffer[i], sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
- if ((cSum != priMemExtDataBuffer[i].checksum) || priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL) {\r
+ if ((cSum != priMemExtDataBuffer[i].checksum) || (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
// Unlegal record, clear the record\r
memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
}\r
*/\r
void Dem_Shutdown(void)\r
{\r
- setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_END); /** @req DEM047 */\r
+ (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_END); /** @req DEM047 */\r
\r
demState = DEM_UNINITIALIZED; /** @req DEM368 */\r
}\r
// Check filterWithSeverity and dtcSeverityMask parameter\r
VALIDATE_RV(((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
|| ((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES)\r
- && !(dtcSeverityMask & ~(DEM_SEVERITY_MAINTENANCE_ONLY | DEM_SEVERITY_CHECK_AT_NEXT_FALT | DEM_SEVERITY_CHECK_IMMEDIATELY)))), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
+ && (!(dtcSeverityMask & (Dem_DTCSeverityType)~(DEM_SEVERITY_MAINTENANCE_ONLY | DEM_SEVERITY_CHECK_AT_NEXT_FALT | DEM_SEVERITY_CHECK_IMMEDIATELY))))), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
\r
// Check filterForFaultDetectionCounter parameter\r
VALIDATE_RV((filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_YES) || (filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_NO), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
\r
if (demState == DEM_INITIALIZED) {\r
// TODO: This job should be done in an more advanced way according to Dem217\r
- while (!dtcFound && (dtcFilter.faultIndex != 0)) {\r
+ while ((!dtcFound) && (dtcFilter.faultIndex != 0)) {\r
dtcFilter.faultIndex--;\r
if (eventStatusBuffer[dtcFilter.faultIndex].eventId != DEM_EVENT_ID_NULL) {\r
if (matchEventWithDtcFilter(&eventStatusBuffer[dtcFilter.faultIndex])) {\r
if (eventId != DEM_EVENT_ID_NULL) {\r
eventParam = eventStatusBuffer[i].eventParamRef;\r
if (eventParam != NULL) {\r
- if (DEM_CLEAR_ALL_EVENTS | (eventParam->DTCClassRef != NULL)) {\r
+ if ((DEM_CLEAR_ALL_EVENTS == STD_ON) || (eventParam->DTCClassRef != NULL)) {\r
if (checkDtcKind(dtcKind, eventParam)) {\r
if (checkDtcGroup(dtc, eventParam)) {\r
- for (j = 0; (j < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[j] != dtcOrigin); j++);\r
- if (j < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
+ boolean dtcOriginFound = FALSE;\r
+ for (j = 0; (j < DEM_MAX_NR_OF_EVENT_DESTINATION) && (!dtcOriginFound) ; j++){\r
+ dtcOriginFound =(eventParam->EventClass->EventDestination[j] == dtcOrigin);\r
+ }\r
+ //if (j-1 < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
+ if (dtcOriginFound) {\r
// Yes! All conditions met.\r
switch (dtcOrigin)\r
{\r
\r
if (demState == DEM_INITIALIZED) {\r
// TODO: Behavior is not defined if group or kind do not match active settings, therefore the filter is just switched off.\r
+ (void)dtcGroup; (void)dtcKind; // Just to make get rid of PC-Lint warnings\r
disableDtcStorage.storageDisabled = FALSE; /** @req DEM080 */\r
} else {\r
DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_ENABLEDTCSTORAGE_ID, DEM_E_UNINIT);\r
* Procedure: Dem_GetExtendedDataRecordByDTC\r
* Reentrant: No\r
*/\r
-Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint8 *bufSize)\r
+Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint16 *bufSize)\r
{\r
Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_RECORD_WRONG_DTC;\r
EventStatusRecType *eventRec;\r
Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
ExtDataRecType *extData;\r
- uint8 posInExtData = 0;\r
+ uint16 posInExtData = 0;\r
\r
if (demState == DEM_INITIALIZED) {\r
if (lookupDtcEvent(dtc, &eventRec)) {\r
case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
if (lookupExtendedDataPriMem(eventRec->eventId, &extData)) {\r
// Yes all conditions met, copy the extended data record to destination buffer.\r
- memcpy(destBuffer, &extData->data[posInExtData], extendedDataRecordClass->DataSize); /** @req DEM075 */\r
+ memcpy(destBuffer, &extData->data[posInExtData], extendedDataRecordClass->DataSize); /** @req DEM075 */ // 960 PC-Lint OK\r
*bufSize = extendedDataRecordClass->DataSize;\r
returnCode = DEM_RECORD_OK;\r
}\r
Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTC;\r
EventStatusRecType *eventRec;\r
Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
- uint8 posInExtData;\r
+ uint16 posInExtData;\r
\r
if (demState == DEM_INITIALIZED) {\r
if (lookupDtcEvent(dtc, &eventRec)) {\r
// 10.2.20\r
typedef struct {\r
Dem_PreDebounceNameType PreDebounceName; // (1)\r
- union {\r
+ union { // 960 PC-lint: 18.4 Unions shall not be used. Ta upp på möte!\r
const Dem_PreDebounceMonitorInternalType *PreDebounceMonitorInternal; // (0..1)\r
const Dem_PreDebounceCounterBasedType *PreDebounceCounterBased; // (0..1)\r
const Dem_PreDebounceFrequencyBasedType *PreDebounceFrequencyBased; // (0..1)\r
* DTC storage types\r
*/\r
typedef uint8 Dem_ReturnTypeOfDtcSupportedType;\r
-#define DEM_ISO15031_6 0x00\r
-#define DEM_ISO14229_1 0x01\r
-#define DEM_SAEJ1939_73 0x02\r
-#define DEM_ISO_11992_4 0x03\r
+#define DEM_ISO15031_6 (Dem_ReturnTypeOfDtcSupportedType)0x00\r
+#define DEM_ISO14229_1 (Dem_ReturnTypeOfDtcSupportedType)0x01\r
+#define DEM_SAEJ1939_73 (Dem_ReturnTypeOfDtcSupportedType)0x02\r
+#define DEM_ISO_11992_4 (Dem_ReturnTypeOfDtcSupportedType)0x03\r
\r
/*\r
* Dem_EventIdType\r
* Dem_DTCGroupType\r
*/\r
typedef uint32 Dem_DTCGroupType;\r
-#define DEM_DTC_GROUP_ALL_DTCS 0xffffff\r
+#define DEM_DTC_GROUP_ALL_DTCS (Dem_DTCGroupType)0xffffff\r
\r
/*\r
* Dem status type\r
*/\r
-#define DEM_DTC_STATUS_MASK_ALL 0x00\r
+#define DEM_DTC_STATUS_MASK_ALL (uint8)0x00\r
\r
\r
/*\r
* DemDTCKindType\r
*/\r
typedef uint8 Dem_DTCKindType;\r
-#define DEM_DTC_KIND_ALL_DTCS 0x01\r
-#define DEM_DTC_KIND_EMISSION_REL_DTCS 0x02\r
+#define DEM_DTC_KIND_ALL_DTCS (Dem_DTCKindType)0x01\r
+#define DEM_DTC_KIND_EMISSION_REL_DTCS (Dem_DTCKindType)0x02\r
\r
/*\r
* DemDTCOriginType\r
*/\r
typedef uint8 Dem_DTCOriginType;\r
-#define DEM_DTC_ORIGIN_SECONDARY_MEMORY 0x01\r
-#define DEM_DTC_ORIGIN_PRIMARY_MEMORY 0x02\r
-#define DEM_DTC_ORIGIN_PERMANENT_MEMORY 0x03\r
-#define DEM_DTC_ORIGIN_MIRROR_MEMORY 0x04\r
+#define DEM_DTC_ORIGIN_SECONDARY_MEMORY (Dem_DTCOriginType)0x01\r
+#define DEM_DTC_ORIGIN_PRIMARY_MEMORY (Dem_DTCOriginType)0x02\r
+#define DEM_DTC_ORIGIN_PERMANENT_MEMORY (Dem_DTCOriginType)0x03\r
+#define DEM_DTC_ORIGIN_MIRROR_MEMORY (Dem_DTCOriginType)0x04\r
\r
/*\r
* DemEventStatusExtendedType\r
*/\r
typedef uint8 Dem_EventStatusExtendedType;\r
-#define DEM_TEST_FAILED 0x01\r
-#define DEM_TEST_FAILED_THIS_OPERATION_CYCLE 0x02\r
-#define DEM_PENDING_DTC 0x04\r
-#define DEM_CONFIRMED_DTC 0x08\r
-#define DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR 0x10\r
-#define DEM_TEST_FAILED_SINCE_LAST_CLEAR 0x20\r
-#define DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE 0x40\r
-#define DEM_WARNING_INDICATOR_REQUESTED 0x80\r
+#define DEM_TEST_FAILED (Dem_EventStatusExtendedType)0x01\r
+#define DEM_TEST_FAILED_THIS_OPERATION_CYCLE (Dem_EventStatusExtendedType)0x02\r
+#define DEM_PENDING_DTC (Dem_EventStatusExtendedType)0x04\r
+#define DEM_CONFIRMED_DTC (Dem_EventStatusExtendedType)0x08\r
+#define DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR (Dem_EventStatusExtendedType)0x10\r
+#define DEM_TEST_FAILED_SINCE_LAST_CLEAR (Dem_EventStatusExtendedType)0x20\r
+#define DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE (Dem_EventStatusExtendedType)0x40\r
+#define DEM_WARNING_INDICATOR_REQUESTED (Dem_EventStatusExtendedType)0x80\r
\r
/*\r
* DemOperationCycleType\r
* Dem_OperationCycleStateType\r
*/\r
typedef uint8 Dem_OperationCycleStateType;\r
-#define DEM_CYCLE_STATE_START 1\r
-#define DEM_CYCLE_STATE_END 2\r
+#define DEM_CYCLE_STATE_START (Dem_OperationCycleStateType)1\r
+#define DEM_CYCLE_STATE_END (Dem_OperationCycleStateType)2\r
\r
/*\r
* Dem_FreezeFrameKindType\r
*/\r
typedef uint8 Dem_FreezeFrameKindType; // TODO: Check type and values\r
-#define DEM_FREEZE_FRAME_NON_OBD 0x01\r
-#define DEM_FREEZE_FRAME_OBD 0x02\r
+#define DEM_FREEZE_FRAME_NON_OBD (Dem_FreezeFrameKindType)0x01\r
+#define DEM_FREEZE_FRAME_OBD (Dem_FreezeFrameKindType)0x02\r
\r
/*\r
* Dem_EventKindType\r
*/\r
typedef uint8 Dem_EventKindType; // TODO: Check type and values\r
-#define DEM_EVENT_KIND_BSW 0x01\r
-#define DEM_EVENT_KIND_SWC 0x02\r
+#define DEM_EVENT_KIND_BSW (Dem_EventKindType)0x01\r
+#define DEM_EVENT_KIND_SWC (Dem_EventKindType)0x02\r
\r
/*\r
* Dem_EventStatusType\r
*/\r
typedef uint8 Dem_EventStatusType;\r
-#define DEM_EVENT_STATUS_PASSED 0\r
-#define DEM_EVENT_STATUS_FAILED 1\r
-#define DEM_EVENT_STATUS_PREPASSED 2\r
-#define DEM_EVENT_STATUS_PREFAILED 3\r
+#define DEM_EVENT_STATUS_PASSED (Dem_EventStatusType)0\r
+#define DEM_EVENT_STATUS_FAILED (Dem_EventStatusType)1\r
+#define DEM_EVENT_STATUS_PREPASSED (Dem_EventStatusType)2\r
+#define DEM_EVENT_STATUS_PREFAILED (Dem_EventStatusType)3\r
\r
/*\r
* Dem_DTCType\r
* Dem_InitMonitorKindType\r
*/\r
typedef uint8 Dem_InitMonitorKindType;\r
-#define DEM_INIT_MONITOR_CLEAR 1\r
-#define DEM_INIT_MONITOR_RESTART 2\r
+#define DEM_INIT_MONITOR_CLEAR (Dem_InitMonitorKindType)1\r
+#define DEM_INIT_MONITOR_RESTART (Dem_InitMonitorKindType)2\r
\r
/*\r
* Dem_IndicatorStatusType\r
*/\r
typedef uint8 Dem_IndicatorStatusType;\r
-#define DEM_INDICATOR_OFF 0\r
-#define DEM_INDICATOR_CONTINUOUS 1\r
-#define DEM_INDICATOR_BLINKING 2\r
-#define DEM_INDICATOR_BLINK_CONT 3\r
+#define DEM_INDICATOR_OFF (Dem_IndicatorStatusType)0\r
+#define DEM_INDICATOR_CONTINUOUS (Dem_IndicatorStatusType)1\r
+#define DEM_INDICATOR_BLINKING (Dem_IndicatorStatusType)2\r
+#define DEM_INDICATOR_BLINK_CONT (Dem_IndicatorStatusType)3\r
\r
/*\r
* Dem_FaultDetectionCpunterType\r
* Dem_FilterWithSeverityType\r
*/\r
typedef uint8 Dem_FilterWithSeverityType;\r
-#define DEM_FILTER_WITH_SEVERITY_YES 0x00\r
-#define DEM_FILTER_WITH_SEVERITY_NO 0x01\r
+#define DEM_FILTER_WITH_SEVERITY_YES (Dem_FilterWithSeverityType)0x00\r
+#define DEM_FILTER_WITH_SEVERITY_NO (Dem_FilterWithSeverityType)0x01\r
\r
/*\r
* Dem_FilterForFDCType\r
*/\r
typedef uint8 Dem_FilterForFDCType;\r
-#define DEM_FILTER_FOR_FDC_YES 0x00\r
-#define DEM_FILTER_FOR_FDC_NO 0x01\r
+#define DEM_FILTER_FOR_FDC_YES (Dem_FilterForFDCType)0x00\r
+#define DEM_FILTER_FOR_FDC_NO (Dem_FilterForFDCType)0x01\r
\r
/*\r
* Dem_DTCSeverityType\r
*/\r
typedef uint8 Dem_DTCSeverityType;\r
-#define DEM_SEVERITY_NO_SEVERITY 0x00 // No severity information available\r
-#define DEM_SEVERITY_MAINTENANCE_ONLY 0x20\r
-#define DEM_SEVERITY_CHECK_AT_NEXT_FALT 0x40\r
-#define DEM_SEVERITY_CHECK_IMMEDIATELY 0x80\r
+#define DEM_SEVERITY_NO_SEVERITY (Dem_DTCSeverityType)0x00 // No severity information available\r
+#define DEM_SEVERITY_MAINTENANCE_ONLY (Dem_DTCSeverityType)0x20\r
+#define DEM_SEVERITY_CHECK_AT_NEXT_FALT (Dem_DTCSeverityType)0x40\r
+#define DEM_SEVERITY_CHECK_IMMEDIATELY (Dem_DTCSeverityType)0x80\r
\r
/*\r
* Dem_ReturnSetDTCFilterType\r
*/\r
typedef uint8 Dem_ReturnSetDTCFilterType;\r
-#define DEM_FILTER_ACCEPTED 0x00\r
-#define DEM_WRONG_FILTER 0x01\r
+#define DEM_FILTER_ACCEPTED (Dem_ReturnSetDTCFilterType)0x00\r
+#define DEM_WRONG_FILTER (Dem_ReturnSetDTCFilterType)0x01\r
\r
/*\r
* Dem_ReturnGetStatusOfDTCType\r
*/\r
typedef uint8 Dem_ReturnGetStatusOfDTCType;\r
-#define DEM_STATUS_OK 0x00\r
-#define DEM_STATUS_WRONG_DTC 0x01\r
-#define DEM_STATUS_WRONG_DTCORIGIN 0x02\r
-#define DEM_STATUS_FAILED 0x04\r
-#define DEM_STATUS_WRONG_DTCKIND 0x03\r
+#define DEM_STATUS_OK (Dem_ReturnGetStatusOfDTCType)0x00\r
+#define DEM_STATUS_WRONG_DTC (Dem_ReturnGetStatusOfDTCType)0x01\r
+#define DEM_STATUS_WRONG_DTCORIGIN (Dem_ReturnGetStatusOfDTCType)0x02\r
+#define DEM_STATUS_FAILED (Dem_ReturnGetStatusOfDTCType)0x04\r
+#define DEM_STATUS_WRONG_DTCKIND (Dem_ReturnGetStatusOfDTCType)0x03\r
\r
/*\r
* Dem_ReturnGetNextFilteredDTCType\r
*/\r
typedef uint8 Dem_ReturnGetNextFilteredDTCType;\r
-#define DEM_FILTERED_OK 0x00\r
-#define DEM_FILTERED_NO_MATCHING_DTC 0x01\r
-#define DEM_FILTERED_WRONG_DTCKIND 0x02\r
-#define DEM_FILTERED_PENDING 0x03\r
+#define DEM_FILTERED_OK (Dem_ReturnGetNextFilteredDTCType)0x00\r
+#define DEM_FILTERED_NO_MATCHING_DTC (Dem_ReturnGetNextFilteredDTCType)0x01\r
+#define DEM_FILTERED_WRONG_DTCKIND (Dem_ReturnGetNextFilteredDTCType)0x02\r
+#define DEM_FILTERED_PENDING (Dem_ReturnGetNextFilteredDTCType)0x03\r
\r
/*\r
* Dem_ReturnGetNumberOfFilteredDTCType\r
*/\r
typedef uint8 Dem_ReturnGetNumberOfFilteredDTCType;\r
-#define DEM_NUMBER_OK 0x00\r
-#define DEM_NUMBER_FAILED 0x01\r
-#define DEM_NUMBER_PENDING 0x02\r
+#define DEM_NUMBER_OK (Dem_ReturnGetNumberOfFilteredDTCType)0x00\r
+#define DEM_NUMBER_FAILED (Dem_ReturnGetNumberOfFilteredDTCType)0x01\r
+#define DEM_NUMBER_PENDING (Dem_ReturnGetNumberOfFilteredDTCType)0x02\r
\r
/*\r
* Dem_ReturnClearDTCType\r
*/\r
typedef uint8 Dem_ReturnClearDTCType;\r
-#define DEM_CLEAR_OK 0x00\r
-#define DEM_CLEAR_WRONG_DTC 0x01\r
-#define DEM_CLEAR_WRONG_DTCORIGIN 0x02\r
-#define DEM_CLEAR_WRONG_DTCKIND 0x03\r
-#define DEM_CLEAR_FAILED 0x04\r
-#define DEM_DTC_PENDING 0x05\r
+#define DEM_CLEAR_OK (Dem_ReturnClearDTCType)0x00\r
+#define DEM_CLEAR_WRONG_DTC (Dem_ReturnClearDTCType)0x01\r
+#define DEM_CLEAR_WRONG_DTCORIGIN (Dem_ReturnClearDTCType)0x02\r
+#define DEM_CLEAR_WRONG_DTCKIND (Dem_ReturnClearDTCType)0x03\r
+#define DEM_CLEAR_FAILED (Dem_ReturnClearDTCType)0x04\r
+#define DEM_DTC_PENDING (Dem_ReturnClearDTCType)0x05\r
\r
/*\r
* Dem_ReturnControlDTCStorageType\r
*/\r
typedef uint8 Dem_ReturnControlDTCStorageType;\r
-#define DEM_CONTROL_DTC_STORAGE_OK 0x00\r
-#define DEM_CONTROL_DTC_STORAGE_N_OK 0x01\r
-#define DEM_CONTROL_DTC_WRONG_DTCGROUP 0x02\r
+#define DEM_CONTROL_DTC_STORAGE_OK (Dem_ReturnControlDTCStorageType)0x00\r
+#define DEM_CONTROL_DTC_STORAGE_N_OK (Dem_ReturnControlDTCStorageType)0x01\r
+#define DEM_CONTROL_DTC_WRONG_DTCGROUP (Dem_ReturnControlDTCStorageType)0x02\r
\r
/*\r
* Dem_ReturnControlEventUpdateType\r
*/\r
typedef uint8 Dem_ReturnControlEventUpdateType;\r
-#define DEM_CONTROL_EVENT_UPDATE_OK 0x00\r
-#define DEM_CONTROL_EVENT_N_OK 0x01\r
-#define DEM_CONTROL_EVENT_WRONG_DTCGROUP 0x02\r
+#define DEM_CONTROL_EVENT_UPDATE_OK (Dem_ReturnControlEventUpdateType)0x00\r
+#define DEM_CONTROL_EVENT_N_OK (Dem_ReturnControlEventUpdateType)0x01\r
+#define DEM_CONTROL_EVENT_WRONG_DTCGROUP (Dem_ReturnControlEventUpdateType)0x02\r
\r
/*\r
* Dem_ReturnGetDTCOfFreezeframeRecordType\r
*/\r
typedef uint8 Dem_ReturnGetDTCOfFreezeframeRecordType;\r
-#define DEM_GET_DTCOFFF_OK 0x00\r
-#define DEM_GET_DTCOFFF_WRONG_RECORD 0x01\r
-#define DEM_GET_DTCOFFF_NO_DTC_FOR_RECORD 0x02\r
-#define DEM_GET_DTCOFFF_WRONG_DTCKIND 0x03\r
+#define DEM_GET_DTCOFFF_OK (Dem_ReturnGetDTCOfFreezeframeRecordType)0x00\r
+#define DEM_GET_DTCOFFF_WRONG_RECORD (Dem_ReturnGetDTCOfFreezeframeRecordType)0x01\r
+#define DEM_GET_DTCOFFF_NO_DTC_FOR_RECORD (Dem_ReturnGetDTCOfFreezeframeRecordType)0x02\r
+#define DEM_GET_DTCOFFF_WRONG_DTCKIND (Dem_ReturnGetDTCOfFreezeframeRecordType)0x03\r
\r
/*\r
* Dem_GetFreezeFameDataIdentifierByDTCType\r
*/\r
typedef uint8 Dem_GetFreezeFameDataIdentifierByDTCType;\r
-#define DEM_GET_ID_OK 0x00\r
-#define DEM_GET_ID_WRONG_DTC 0x01\r
-#define DEM_GET_ID_WRONG_DTCORIGIN 0x02\r
-#define DEM_GET_ID_WRONG_DTCKIND 0x03\r
-#define DEM_GET_ID_WRONG_FF_TYPE 0x04\r
+#define DEM_GET_ID_OK (Dem_GetFreezeFameDataIdentifierByDTCType)0x00\r
+#define DEM_GET_ID_WRONG_DTC (Dem_GetFreezeFameDataIdentifierByDTCType)0x01\r
+#define DEM_GET_ID_WRONG_DTCORIGIN (Dem_GetFreezeFameDataIdentifierByDTCType)0x02\r
+#define DEM_GET_ID_WRONG_DTCKIND (Dem_GetFreezeFameDataIdentifierByDTCType)0x03\r
+#define DEM_GET_ID_WRONG_FF_TYPE (Dem_GetFreezeFameDataIdentifierByDTCType)0x04\r
\r
/*\r
* Dem_ReturnGetExtendedDataRecordByDTCType\r
*/\r
typedef uint8 Dem_ReturnGetExtendedDataRecordByDTCType;\r
-#define DEM_RECORD_OK 0x00\r
-#define DEM_RECORD_WRONG_DTC 0x01\r
-#define DEM_RECORD_WRONG_DTCORIGIN 0x02\r
-#define DEM_RECORD_DTCKIND 0x03\r
-#define DEM_RECORD_NUMBER 0x04\r
-#define DEM_RECORD_BUFFERSIZE 0x05\r
-#define DEM_RECORD_PENDING 0x06\r
+#define DEM_RECORD_OK (Dem_ReturnGetExtendedDataRecordByDTCType)0x00\r
+#define DEM_RECORD_WRONG_DTC (Dem_ReturnGetExtendedDataRecordByDTCType)0x01\r
+#define DEM_RECORD_WRONG_DTCORIGIN (Dem_ReturnGetExtendedDataRecordByDTCType)0x02\r
+#define DEM_RECORD_DTCKIND (Dem_ReturnGetExtendedDataRecordByDTCType)0x03\r
+#define DEM_RECORD_NUMBER (Dem_ReturnGetExtendedDataRecordByDTCType)0x04\r
+#define DEM_RECORD_BUFFERSIZE (Dem_ReturnGetExtendedDataRecordByDTCType)0x05\r
+#define DEM_RECORD_PENDING (Dem_ReturnGetExtendedDataRecordByDTCType)0x06\r
\r
/*\r
* Dem_ReturnGetDTCByOccurenceTimeType\r
*/\r
typedef uint8 Dem_ReturnGetDTCByOccurenceTimeType;\r
-#define DEM_OCCURR_OK 0x00\r
-#define DEM_OCCURR_WRONG_DTCKIND 0x01\r
-#define DEM_OCCURR_FAILED 0x02\r
+#define DEM_OCCURR_OK (Dem_ReturnGetDTCByOccurenceTimeType)0x00\r
+#define DEM_OCCURR_WRONG_DTCKIND (Dem_ReturnGetDTCByOccurenceTimeType)0x01\r
+#define DEM_OCCURR_FAILED (Dem_ReturnGetDTCByOccurenceTimeType)0x02\r
\r
/*\r
* Dem_ReturnGetFreezeFrameDataByDTCType\r
*/\r
typedef uint8 Dem_ReturnGetFreezeFrameDataByDTCType;\r
-#define DEM_GET_FFDATABYDTC_OK 0x00\r
-#define DEM_GET_FFDATABYDTC_WRONG_DTC 0x01\r
-#define DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN 0x02\r
-#define DEM_GET_FFDATABYDTC_WRONG_DTCKIND 0x03\r
-#define DEM_GET_FFDATABYDTC_RECORDNUMBER 0x04\r
-#define DEM_GET_FFDATABYDTC_WRONG_DATAID 0x05\r
-#define DEM_GET_FFDATABYDTC_BUFFERSIZE 0x06\r
-#define DEM_GET_ID_PENDING 0x07\r
+#define DEM_GET_FFDATABYDTC_OK (Dem_ReturnGetFreezeFrameDataByDTCType)0x00\r
+#define DEM_GET_FFDATABYDTC_WRONG_DTC (Dem_ReturnGetFreezeFrameDataByDTCType)0x01\r
+#define DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN (Dem_ReturnGetFreezeFrameDataByDTCType)0x02\r
+#define DEM_GET_FFDATABYDTC_WRONG_DTCKIND (Dem_ReturnGetFreezeFrameDataByDTCType)0x03\r
+#define DEM_GET_FFDATABYDTC_RECORDNUMBER (Dem_ReturnGetFreezeFrameDataByDTCType)0x04\r
+#define DEM_GET_FFDATABYDTC_WRONG_DATAID (Dem_ReturnGetFreezeFrameDataByDTCType)0x05\r
+#define DEM_GET_FFDATABYDTC_BUFFERSIZE (Dem_ReturnGetFreezeFrameDataByDTCType)0x06\r
+#define DEM_GET_ID_PENDING (Dem_ReturnGetFreezeFrameDataByDTCType)0x07\r
\r
/*\r
* Dem_ReturnGetSizeOfExtendedDataRecordByDTCType\r
*/\r
typedef uint8 Dem_ReturnGetSizeOfExtendedDataRecordByDTCType;\r
-#define DEM_GET_SIZEOFEDRBYDTC_OK 0x00\r
-#define DEM_GET_SIZEOFEDRBYDTC_W_DTC 0x01\r
-#define DEM_GET_SIZEOFEDRBYDTC_W_DTCOR 0x02\r
-#define DEM_GET_SIZEOFEDRBYDTC_W_DTCKI 0x03\r
-#define DEM_GET_SIZEOFEDRBYDTC_W_RNUM 0x04\r
-#define DEM_GET_SIZEOFEDRBYDTC_PENDING 0x05\r
+#define DEM_GET_SIZEOFEDRBYDTC_OK (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x00\r
+#define DEM_GET_SIZEOFEDRBYDTC_W_DTC (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x01\r
+#define DEM_GET_SIZEOFEDRBYDTC_W_DTCOR (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x02\r
+#define DEM_GET_SIZEOFEDRBYDTC_W_DTCKI (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x03\r
+#define DEM_GET_SIZEOFEDRBYDTC_W_RNUM (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x04\r
+#define DEM_GET_SIZEOFEDRBYDTC_PENDING (Dem_ReturnGetSizeOfExtendedDataRecordByDTCType)0x05\r
\r
/*\r
* Dem_ReturnGetSizeOfFreezeFrameType\r
*/\r
typedef uint8 Dem_ReturnGetSizeOfFreezeFrameType;\r
-#define DEM_GET_SIZEOFFF_OK 0x00\r
-#define DEM_GET_SIZEOFFF_WRONG_DTC 0x01\r
-#define DEM_GET_SIZEOFFF_WRONG_DTCOR 0x02\r
-#define DEM_GET_SIZEOFFF_WRONG_DTCKIND 0x03\r
-#define DEM_GET_SIZEOFFF_WRONG_RNUM 0x04\r
-#define DEM_GET_SIZEOFFF_PENDING 0x05\r
+#define DEM_GET_SIZEOFFF_OK (Dem_ReturnGetSizeOfFreezeFrameType)0x00\r
+#define DEM_GET_SIZEOFFF_WRONG_DTC (Dem_ReturnGetSizeOfFreezeFrameType)0x01\r
+#define DEM_GET_SIZEOFFF_WRONG_DTCOR (Dem_ReturnGetSizeOfFreezeFrameType)0x02\r
+#define DEM_GET_SIZEOFFF_WRONG_DTCKIND (Dem_ReturnGetSizeOfFreezeFrameType)0x03\r
+#define DEM_GET_SIZEOFFF_WRONG_RNUM (Dem_ReturnGetSizeOfFreezeFrameType)0x04\r
+#define DEM_GET_SIZEOFFF_PENDING (Dem_ReturnGetSizeOfFreezeFrameType)0x05\r
\r
/*\r
* Dem_ReturnGetSeverityOfDTCType\r
*/\r
typedef uint8 Dem_ReturnGetSeverityOfDTCType;\r
-#define DEM_GET_SEVERITYOFDTC_OK 0x00\r
-#define DEM_GET_SEVERITYOFDTC_WRONG_DTC 0x01\r
-#define DEM_GET_SEVERITYOFDTC_WRONG_ORIGIN 0x02\r
-#define DEM_GET_SEVERITYOFDTC_NOSEVERITY 0x03\r
+#define DEM_GET_SEVERITYOFDTC_OK (Dem_ReturnGetSeverityOfDTCType)0x00\r
+#define DEM_GET_SEVERITYOFDTC_WRONG_DTC (Dem_ReturnGetSeverityOfDTCType)0x01\r
+#define DEM_GET_SEVERITYOFDTC_WRONG_ORIGIN (Dem_ReturnGetSeverityOfDTCType)0x02\r
+#define DEM_GET_SEVERITYOFDTC_NOSEVERITY (Dem_ReturnGetSeverityOfDTCType)0x03\r
\r
\r
\r
DET_STARTED\r
} Det_StateType;\r
\r
-static Det_StateType _detState = DET_UNINITIALIZED;\r
+static Det_StateType detState = DET_UNINITIALIZED;\r
\r
#if ( DET_USE_RAMLOG == STD_ON )\r
// Ram log variables in uninitialized memory\r
uint32 Det_RamlogIndex __attribute__ ((section (".ramlog")));\r
+/*lint -esym(552,Det_RamLog)*/ /* PC-Lint OK. supress lintwarning about Det_Ramlog not being accessed */\r
Det_EntryType Det_RamLog[DET_RAMLOG_SIZE] __attribute__ ((section (".ramlog")));\r
#endif\r
\r
\r
uint8 Det_AddCbk(detCbk_t detCbk)\r
{\r
- if (_detState != DET_UNINITIALIZED)\r
+ uint8 rv=0xFFu;\r
+ if (detState != DET_UNINITIALIZED)\r
{\r
- for (uint32 i=0; i<DET_NUMBER_OF_CALLBACKS; i++)\r
+ for (uint8 i=0; i<DET_NUMBER_OF_CALLBACKS; i++)\r
{\r
if (NULL==detCbk_List[i])\r
{\r
detCbk_List[i]=detCbk;\r
- return i;\r
+ rv = i;\r
}\r
}\r
}\r
\r
Det_ReportError(DET_MODULE_ID, 0, DET_CALLBACK_API, DET_E_CBK_REGISTRATION_FAILED);\r
- return (0xFF); // Return 0xff to indicate that the registration failed\r
+ return rv; // Return 0xff to indicate that the registration failed\r
}\r
\r
void Det_RemoveCbk(uint8 detCbkIndex)\r
{\r
// Validate the index\r
if (detCbkIndex >= DET_NUMBER_OF_CALLBACKS)\r
+ {\r
Det_ReportError(DET_MODULE_ID, 0, DET_CALLBACK_API, DET_E_INDEX_OUT_OF_RANGE);\r
-\r
- detCbk_List[detCbkIndex]=NULL;\r
+ }\r
+ else\r
+ {\r
+ detCbk_List[detCbkIndex]=NULL;\r
+ }\r
}\r
#endif\r
\r
\r
void Det_Init(void)\r
{\r
+\r
// Implements DET000\r
#if ( DET_ENABLE_CALLBACKS == STD_ON )\r
for (uint32 i=0; i<DET_NUMBER_OF_CALLBACKS; i++)\r
Det_RamlogIndex = 0;\r
#endif\r
\r
- _detState = DET_INITIALIZED;\r
+ detState = DET_INITIALIZED;\r
}\r
\r
#if DET_DEINIT_API == STD_ON\r
void Det_DeInit( void )\r
{\r
- _detState = DET_UNINITIALIZED;\r
+ detState = DET_UNINITIALIZED;\r
}\r
#endif\r
\r
void Det_ReportError(uint16 ModuleId, uint8 InstanceId, uint8 ApiId, uint8 ErrorId)\r
{\r
- if (_detState == DET_STARTED) // No action is taken if the module is not started\r
+ if (detState == DET_STARTED) // No action is taken if the module is not started\r
{\r
#if ( DET_ENABLE_CALLBACKS == STD_ON )\r
- long old1;\r
+ uint32 old1; // 586 PC-Lint OK: fattar inte att den används i macrot.\r
Irq_Save(old1);\r
+\r
for (uint32 i=0; i<DET_NUMBER_OF_CALLBACKS; i++)\r
{\r
if (NULL!=detCbk_List[i])\r
Irq_Restore(old1);\r
#endif\r
\r
+\r
#if ( DET_USE_RAMLOG == STD_ON )\r
- long old2;\r
+ uint32 old2;\r
Irq_Save(old2);\r
if (Det_RamlogIndex < DET_RAMLOG_SIZE)\r
{\r
Det_RamLog[Det_RamlogIndex].errorId = ErrorId;\r
Det_RamlogIndex++;\r
#if ( DET_WRAP_RAMLOG == STD_ON )\r
- if (Det_RamlogIndex == DET_RAMLOG_SIZE)\r
+ if (Det_RamlogIndex == DET_RAMLOG_SIZE){\r
Det_RamlogIndex = 0;\r
+ }\r
#endif\r
}\r
Irq_Restore(old2);\r
\r
void Det_Start(void)\r
{\r
- _detState = DET_STARTED;\r
+ detState = DET_STARTED;\r
}\r
typedef enum {\r
CAN_OK,\r
CAN_NOT_OK,\r
- CAN_BUSY,\r
+ CAN_BUSY\r
// CAN_WAKEUP, // Removed in 3.0\r
} Can_ReturnType;\r
\r
#include "Can_Cfg.h"\r
\r
void Can_Init( const Can_ConfigType *Config );\r
-void Can_DeInit();\r
+void Can_DeInit(void);\r
\r
#if ( CAN_VERSION_INFO_API == STD_ON )\r
#define Can_GetVersionInfo(_vi) STD_GET_VERSION_INFO(_vi,CAN)\r
* SLEEP mode and can be woken up by request of the\r
* CAN driver or by a network event (must be supported\r
* by CAN hardware) */\r
- CANIF_CS_SLEEP,\r
+ CANIF_CS_SLEEP\r
} CanIf_ControllerModeType;\r
\r
/** Status of the PDU channel group. Current mode of the channel defines its\r
* shall be set to the offline active mode\r
* => notifications are processed but transmit\r
* requests are blocked. */\r
- CANIF_SET_TX_OFFLINE_ACTIVE,\r
+ CANIF_SET_TX_OFFLINE_ACTIVE\r
} CanIf_ChannelSetModeType;\r
\r
\r
CANIF_NO_NOTIFICATION = 0, \r
/** The requested Rx/Tx CAN L-PDU was\r
* successfully transmitted or received. */\r
- CANIF_TX_RX_NOTIFICATION,\r
+ CANIF_TX_RX_NOTIFICATION\r
\r
} CanIf_NotifStatusType;\r
\r
* Implemented functions\r
****************************/\r
\r
-void CanTp_Init(); /** @req CANTP208 **/\r
+void CanTp_Init(void); /** @req CANTP208 **/\r
\r
#if ( CANTP_VERSION_INFO_API == STD_ON ) /** @req CANTP162 *//** @req CANTP163 */\r
#define CanTp_GetVersionInfo(_vi) STD_GET_VERSION_INFO(_vi,CANTP) /** @req CANTP210 */ /* @req CANTP218 */\r
#endif /* CANTP_VERSION_INFO_API */\r
\r
-void CanTp_Shutdown(); /** @req CANTP211 */\r
+void CanTp_Shutdown(void); /** @req CANTP211 */\r
\r
Std_ReturnType CanTp_Transmit( PduIdType CanTpTxSduId, const PduInfoType * CanTpTxInfoPtr ); /** @req CANTP212 */\r
\r
Std_ReturnType FrTp_CancelTransmitRequest( PduIdType FrTpTxPduId, FrTp_CancelReasonType FrTpCancelReason ); /** @req CANTP246 */\r
\r
-void CanTp_MainFunction(); /** @req CANTP213 */\r
+void CanTp_MainFunction(void); /** @req CANTP213 */\r
\r
\r
#endif /* CANTP_H_ */\r
\r
\r
typedef struct {\r
- const int CanIf_FcPduId; // The polite CanIf PDU index.\r
- const int PduR_PduId; // The polite PduR index.\r
+ const PduIdType CanIf_FcPduId; // The polite CanIf PDU index.\r
+ const PduIdType PduR_PduId; // The polite PduR index.\r
const CanTp_AddressingFormantType CanTpAddressingFormant; /** @req CANTP242 */\r
const uint8 CanTpBs; /** @req CANTP243 */ /* Sets the maximum number of messages of N-PDUs before flow control. */\r
const uint16 CanTpNar; /** @req CANTP244 */ /* Timeout for transmission of a CAN frame (ms). */\r
} CanTp_RxNSduType; /** @req CANTP137 */\r
\r
typedef struct {\r
- const int CanIf_PduId; // The polite CanIf index.\r
- const int PduR_PduId; // The polite PduR index.\r
+ const PduIdType CanIf_PduId; // The polite CanIf index.\r
+ const PduIdType PduR_PduId; // The polite PduR index.\r
const CanTp_AddressingFormantType CanTpAddressingMode; /** @req CANTP262 */\r
const uint16 CanTpNas; /** @req CANTP263 */ /* N_As timeout for transmission of any CAN frame. */\r
const uint16 CanTpNbs; /** @req CANTP264 */ /* N_Bs timeout of transmission until reception of next Flow Control. */\r
#ifndef COMM_DCM_H_\r
#define COMM_DCM_H_\r
\r
-void ComM_DCM_ActiveDiagnostic();\r
-void ComM_DCM_InactiveDiagnostic();\r
+void ComM_DCM_ActiveDiagnostic(void);\r
+void ComM_DCM_InactiveDiagnostic(void);\r
\r
#endif /*COMM_DCM_H_*/\r
BUFREQ_OK=0,\r
BUFREQ_NOT_OK,\r
BUFREQ_BUSY,\r
- BUFREQ_OVFL,\r
+ BUFREQ_OVFL\r
} BufReq_ReturnType;\r
\r
// 0x00--0x1e General return types\r
\r
#include "Com.h"\r
\r
-void Com_MainFunctionRx();\r
-void Com_MainFunctionTx();\r
+void Com_MainFunctionRx(void);\r
+void Com_MainFunctionTx(void);\r
\r
// Not supported in this version.\r
//void Com_MainFunctionRouteSignals();\r
\r
typedef enum {\r
IMMEDIATE,\r
- DEFERRED,\r
+ DEFERRED\r
} Com_IPduSignalProcessingMode;\r
\r
typedef enum {\r
\r
typedef enum {\r
PENDING,\r
- TRIGGERED,\r
+ TRIGGERED\r
} ComTransferProperty_type;\r
\r
typedef enum {\r
DIRECT,\r
MIXED,\r
NONE,\r
- PERIODIC,\r
+ PERIODIC\r
} ComTxModeMode_type;\r
\r
\r
NEVER,\r
NEW_IS_OUTSIDE,\r
NEW_IS_WITHIN,\r
- ONE_EVERY_N,\r
+ ONE_EVERY_N\r
} ComFilterAlgorithm_type;\r
\r
typedef enum {\r
COM_BIG_ENDIAN,\r
COM_LITTLE_ENDIAN,\r
- COM_OPAQUE,\r
+ COM_OPAQUE\r
} ComSignalEndianess_type;\r
\r
typedef enum {\r
\r
/* REQ:COMPILER040,049,051 */\r
#define AUTOMATIC\r
-#define _STATIC_ static\r
+#define STATIC static\r
#define NULL_PTR ((void *)0)\r
\r
/* REQ:COMPILER005 */\r
#ifndef DCM_CBK_H_\r
#define DCM_CBK_H_\r
\r
+//lint -e451 //451 PC-Lint OK. Slå av regel helt?\r
#include "ComStack_Types.h"\r
\r
/*\r
Std_ReturnType Dem_GetEventFailed(Dem_EventIdType eventId, boolean *eventFailed); /** @req DEM196 */\r
Std_ReturnType Dem_GetEventTested(Dem_EventIdType eventId, boolean *eventTested); /** @req DEM197 */\r
Std_ReturnType Dem_GetFaultDetectionCounter(Dem_EventIdType eventId, sint8 *counter); /** @req DEM203 */\r
-Std_ReturnType Dem_SetOperationCycleState(Dem_OperationCycleIdType OperationCycleId, Dem_OperationCycleStateType CycleState); /** @req DEM194 */\r
+Std_ReturnType Dem_SetOperationCycleState(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState); /** @req DEM194 */\r
Std_ReturnType Dem_GetDTCOfEvent(Dem_EventIdType eventId, Dem_DTCKindType dtcKind, uint32* dtcOfEvent); /** @req DEM198 */\r
\r
\r
*/\r
Dem_ReturnClearDTCType Dem_ClearDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin); /** @req DEM241 */\r
Dem_ReturnSetDTCFilterType Dem_SetDTCFilter(uint8 dtcStatusMask, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, Dem_FilterWithSeverityType filterWithSeverity, Dem_DTCSeverityType dtcSeverityMask, Dem_FilterForFDCType filterForFaultDetectionCounter); /** @req DEM208 */\r
-Dem_ReturnGetStatusOfDTCType Dem_GetStatusOfDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, Dem_EventStatusExtendedType* dtcStatus); /** @req DEM212 */\r
+Dem_ReturnGetStatusOfDTCType Dem_GetStatusOfDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, Dem_EventStatusExtendedType* status); /** @req DEM212 */\r
Std_ReturnType Dem_GetDTCStatusAvailabilityMask(uint8 *dtcStatusMask); /** @req DEM213 */\r
Dem_ReturnGetNumberOfFilteredDTCType Dem_GetNumberOfFilteredDtc(uint16* numberOfFilteredDTC); /** @req DEM214 */\r
Dem_ReturnGetNextFilteredDTCType Dem_GetNextFilteredDTC(uint32* dtc, Dem_EventStatusExtendedType* dtcStatus); /** @req DEM215 */\r
Dem_ReturnTypeOfDtcSupportedType Dem_GetTranslationType(void); /** @req DEM230 */\r
Dem_ReturnControlDTCStorageType Dem_DisableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind); /** @req DEM242 */\r
Dem_ReturnControlDTCStorageType Dem_EnableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind); /** @req DEM243 */\r
-Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint8 *bufSize); /** @req DEM239 */\r
+Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint16 *bufSize); /** @req DEM239 */\r
Dem_ReturnGetSizeOfExtendedDataRecordByDTCType Dem_GetSizeOfExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint16 *sizeOfExtendedDataRecord); /** @req DEM240 */\r
\r
\r
/*\r
* Development Error Tracer driver\r
*\r
- * Specification: Autosar v2.0.1, Final\r
- *\r
*/\r
\r
-#ifndef _DET_H_\r
-#define _DET_H_\r
+#ifndef DET_H\r
+#define DET_H\r
\r
#define DET_MODULE_ID MODULE_ID_DET\r
#define DET_VENDOR_ID 1\r
\r
+/* Implementation version */\r
#define DET_SW_MAJOR_VERSION 1\r
#define DET_SW_MINOR_VERSION 0\r
#define DET_SW_PATCH_VERSION 0\r
\r
+/* AUTOSAR specification document version */\r
#define DET_AR_MAJOR_VERSION 2\r
#define DET_AR_MINOR_VERSION 2\r
#define DET_AR_PATCH_VERSION 2\r
} Det_EntryType;\r
\r
#if ( DET_ENABLE_CALLBACKS == STD_ON )\r
-typedef void *(*detCbk_t)( uint16 ModuleId, uint8 InstanceId , uint8 ApiId, uint8 ErrorId);\r
+typedef void (*detCbk_t)( uint16 ModuleId, uint8 InstanceId , uint8 ApiId, uint8 ErrorId);\r
\r
/*\r
* Add a callback function to the array of callback. After a call to Det_ReportError the callback\r
void Det_Start( void );\r
#define Det_GetVersionInfo(_vi) STD_GET_VERSION_INFO(_vi,DET)\r
\r
-#endif /*_DET_H_*/\r
+#endif /*DET_H*/\r
* If hardware cannot distinguish between a\r
* power cycle and a reset reason, then this\r
* shall be the default wakeup source */\r
- ECUM_WKSOURCE_RESET = 0x02,\r
+ ECUM_WKSOURCE_RESET = 0x02\r
};\r
\r
typedef uint32 EcuM_WakeupSourceType;\r
ECUM_WKSTATUS_NONE = 0, /**< No pending wakeup event was detected */\r
ECUM_WKSTATUS_PENDING = 1, /**< The wakeup event was detected but not yet validated */\r
ECUM_WKSTATUS_VALIDATED = 2, /**< The wakeup event is valid */\r
- ECUM_WKSTATUS_EXPIRED = 3, /**< The wakeup event has not been validated and has expired therefore */\r
+ ECUM_WKSTATUS_EXPIRED = 3 /**< The wakeup event has not been validated and has expired therefore */\r
} EcuM_WakeupStatusType;\r
\r
typedef enum\r
{\r
ECUM_WWKACT_RUN = 0, /**< Initialization into RUN state */\r
ECUM_WKACT_TTII = 2, /**< Execute time triggered increased inoperation protocol and shutdown */\r
- ECUM_WKACT_SHUTDOWN = 3, /**< Immediate shutdown */\r
+ ECUM_WKACT_SHUTDOWN = 3 /**< Immediate shutdown */\r
} EcuM_WakeupReactionType;\r
\r
typedef enum\r
{\r
ECUM_BOOT_TARGET_APP = 0, /**< The Ecu will boot into the application */\r
- ECUM_BOOT_TARGET_BOOTLOADER = 1, /**< The Ecu will boot into the bootloader */\r
+ ECUM_BOOT_TARGET_BOOTLOADER = 1 /**< The Ecu will boot into the bootloader */\r
} EcuM_BootTargetType;\r
\r
\r
\r
\r
\r
-#ifndef _MCU_EXTENSIONS_H_\r
-#define _MCU_EXTENSIONS_H_\r
+#ifndef MCU_EXTENSIONS_H\r
+#define MCU_EXTENSIONS_H\r
\r
#include "Std_Types.h"\r
typedef uint32_t imask_t;\r
// Module Id:s from document "List of Basic Sofware Modules" Rev 1.2.1 Part of release 3.0\r
//\r
\r
-#ifndef _MODULES_H_\r
-#define _MODULES_H_\r
+#ifndef MODULES_H\r
+#define MODULES_H\r
\r
#include "Std_Types.h"\r
\r
TASK_STATE_WAITING,\r
TASK_STATE_READY,\r
TASK_STATE_SUSPENDED,\r
- TASK_STATE_RUNNING,\r
+ TASK_STATE_RUNNING\r
} TaskStateType;\r
\r
#define INVALID_TASK 0xdeadU\r
OSServiceId_PostTaskHook,\r
OSServiceId_StartupHook,\r
OSServiceId_ShutdownHook,\r
- OSServiceId_GetTaskState,\r
-} OsServiceIdType;;\r
+ OSServiceId_GetTaskState\r
+} OsServiceIdType;\r
\r
typedef struct OsError {\r
OsServiceIdType serviceId;\r
// Define macro for state, parameter and data pointer checks.\r
// TODO Implement data range check if needed.\r
#define PduR_DevCheck(PduId,PduPtr,ApiId,...) \\r
- if (PduRState == PDUR_UNINIT || PduRState == PDUR_REDUCED) { \\r
+ if ((PduRState == PDUR_UNINIT) || (PduRState == PDUR_REDUCED)) { \\r
PDUR_DET_REPORTERROR(MODULE_ID_PDUR, PDUR_INSTANCE_ID, ApiId, PDUR_E_INVALID_REQUEST); \\r
return __VA_ARGS__; \\r
} \\r
- if (PduPtr == 0 && PDUR_DEV_ERROR_DETECT) { \\r
+ if ((PduPtr == 0) && (PDUR_DEV_ERROR_DETECT)) { \\r
PDUR_DET_REPORTERROR(MODULE_ID_PDUR, PDUR_INSTANCE_ID, ApiId, PDUR_E_DATA_PTR_INVALID); \\r
return __VA_ARGS__; \\r
} \\r
//#error fail\r
void PduR_Init(const PduR_PBConfigType* ConfigPtr);\r
void PduR_GetVersionInfo(Std_VersionInfoType* versionInfo);\r
-uint32 PduR_GetConfigurationId();\r
+uint32 PduR_GetConfigurationId(void);\r
\r
+void PduR_BufferInc(PduRTxBuffer_type *Buffer, uint8 **ptr);\r
void PduR_BufferQueue(PduRTxBuffer_type *Buffer, const uint8 * SduPtr);\r
void PduR_BufferDeQueue(PduRTxBuffer_type *Buffer, uint8 *SduPtr);\r
void PduR_BufferFlush(PduRTxBuffer_type *Buffer);\r
uint8 PduR_BufferIsFull(PduRTxBuffer_type *Buffer);\r
+void PduR_LoIfRxIndication(PduIdType PduId, const uint8* SduPtr);\r
+void PduR_LoIfTxConfirmation(PduIdType PduId);\r
+void PduR_LoIfTriggerTransmit(PduIdType PduId, uint8* SduPtr);\r
\r
/*\r
* Macros\r
*/\r
-#define setTxConfP(R) R->PduRDestPdu.TxBufferRef->TxConfP = 1\r
-#define clearTxConfP(R) R->PduRDestPdu.TxBufferRef->TxConfP = 0\r
+#define setTxConfP(R) (R->PduRDestPdu.TxBufferRef->TxConfP = 1)\r
+#define clearTxConfP(R) (R->PduRDestPdu.TxBufferRef->TxConfP = 0)\r
\r
#endif\r
\r
* General platform type definitions.\r
*/\r
\r
-#ifndef _PLATFORM_TYPES_H_\r
-#define _PLATFORM_TYPES_H_\r
+#include <stdbool.h>\r
+\r
+#ifndef PLATFORM_TYPES_H\r
+#define PLATFORM_TYPES_H\r
\r
#define CPU_TYPE CPU_TYPE_32 \r
#define CPU_BIT_ORDER MSB_FIRST \r
#define CPU_BYTE_ORDER HIGH_BYTE_FIRST\r
\r
-#if !defined(FALSE)\r
-#define FALSE 0\r
-#define TRUE 1\r
-#endif\r
+#define FALSE (boolean)false\r
+#define TRUE (boolean)true\r
\r
-typedef unsigned long boolean; \r
+//typedef unsigned long boolean;\r
+typedef _Bool boolean;\r
typedef signed char sint8; \r
typedef unsigned char uint8; \r
typedef signed short sint16; \r
typedef unsigned short uint16; \r
typedef signed long sint32; \r
-typedef unsigned long uint32; \r
+typedef unsigned long uint32;\r
typedef unsigned long long uint64;\r
typedef unsigned long uint8_least; \r
typedef unsigned long uint16_least; \r
* Definitions of General types.\r
*/\r
\r
-#ifndef _STD_TYPES_H\r
-#define _STD_TYPES_H\r
+#ifndef STD_TYPES_H\r
+#define STD_TYPES_H\r
\r
// Autosar include files....\r
// TODO: we haven't really defined the autosar types yet.\r
#include "Compiler.h"\r
\r
#ifndef NULL\r
+//lint -esym(960,20.2) // PC-Lint LINT EXCEPTION\r
#define NULL 0\r
#endif\r
\r
((_vi)->ar_patch_version = _module ## _AR_PATCH_VERSION);\r
\r
\r
-// TODO: Move to OSEK implementation, See 8.2 in SWS_StandardTypes\r
-\r
-#define STATUSTYPEDEFINED\r
typedef enum {\r
- E_OK = 0,\r
+ E_OK = 0, /**< Differs from spec. (see StandardTypes 8.2.1) */\r
+ E_NOT_OK = 1, /**< Differs from spec. (see StandardTypes 8.2.1) */\r
+\r
E_OS_ACCESS = 1, /**< STD OSEK */\r
E_OS_CALLEVEL = 2, /**< STD OSEK */\r
E_OS_ID = 3, /**< STD OSEK */\r
E_OS_PROTECTION_RATE, /**< AUTOSAR, see 7.10 */\r
\r
/* COM.. TODO: move ?? */\r
- E_COM_ID,\r
-\r
-\r
- /** Implementation specific */\r
- E_OS_SYS_APA,\r
+ E_COM_ID\r
\r
- E_NOT_OK,\r
} StatusType;\r
\r
typedef uint8 Std_ReturnType;\r
\r
\r
-#ifndef STATUSTYPEDEFINED\r
-#define STATUSTYPEDEFINED\r
-#define E_OK 0\r
-typedef unsigned char StatusType;\r
-#endif\r
-\r
-#define E_NOT_OK 1\r
-\r
#define E_NO_DTC_AVAILABLE 2\r
#define E_SESSION_NOT_ALLOWED 4\r
#define E_PROTOCOL_NOT_ALLOWED 5\r
\r
#include "Std_Types.h"\r
\r
-#define Irq_Save(flags)\r
-#define Irq_Restore(flags)\r
+#define Irq_Save(flags) ((flags) = 0) // Dummy assignment to avoid compiler warnings\r
+#define Irq_Restore(flags) (void)(flags)\r
\r
#define Irq_Disable()\r
#define Irq_Enable()\r
# Some dependency for xxx_offset.c/h also\r
-include $(subst .h,.d,$(dep-y))\r
\r
+#LINT:\r
+LINT_EXCLUDE ?= arc-tests\r
+\r
ifneq ($(PCLINT),)\r
define run_pclint\r
-$(Q)$(PCLINT) $(lint_extra) $(addprefix $(lintinc_ext),$(inc-y)) $(addprefix $(lintdef_ext),$(def-y)) $(abspath $<)\r
+$(if \r
+$(findstring $(LINT_EXCLUDE),$(abspath $<)),\r
+$(info $(abspath $<):0:0: Info: Not running lint check on $(abspath $<)),\r
+$(Q)$(PCLINT) $(lint_extra) $(addprefix $(lintinc_ext),$(inc-y)) $(addprefix $(lintdef_ext),$(def-y)) $(abspath $<))\r
endef\r
endif\r
\r
ifneq ($(SPLINT),)\r
define run_splint\r
-$(Q)$(SPLINT) $(splint_extra) $(addprefix $(lintinc_ext),$(inc-y)) $(addprefix $(lintdef_ext),$(def-y)) $(abspath $<)\r
+$(if \r
+$(findstring $(LINT_EXCLUDE),$(abspath $<)),\r
+$(info $(abspath $<):0:0: Info: Not running lint check on $(abspath $<)),\r
+$(Q)$(SPLINT) $(splint_extra) $(addprefix $(lintinc_ext),$(inc-y)) $(addprefix $(lintdef_ext),$(def-y)) $(abspath $<))\r
endef\r
endif\r
\r
# Compile\r
%.o: %.c\r
@echo " >> CC $(notdir $<)"\r
+# compile\r
$(Q)$(CC) -c $(CFLAGS) -o $(goal) $(addprefix -I ,$(inc-y)) $(addprefix -D,$(def-y)) $(abspath $<)\r
+# run lint if enabled\r
$(run_pclint)\r
$(run_splint)\r
\r
# Preprocess linker files..\r
%.ldp: %.ldf\r
@echo " >> CPP $<"\r
- $(Q)$(CPP) -E -P -x assembler-with-cpp -o $@ $(addprefix -I ,$(inc-y)) $(addprefix -D,$(def-y)) $<\r
+ $(Q)$(CPP) -E -P -x assembler-with-cpp -o $@ $(addprefix -I ,$(inc-y)) $<\r
\r
# @cat $@ \r
\r
$(Q)$(CC) $(LDFLAGS) -o $@ $(libpath-y) $(obj-y) $(lib-y) $(libitem-y) \r
else \r
$(Q)$(LD) $(LDFLAGS) -T $(ldcmdfile-y) -o $@ $(libpath-y) --start-group $(obj-y) $(lib-y) $(libitem-y) --end-group $(LDMAPFILE)\r
-ifdef CFG_HC1X\r
+ifdef CFG_MC912DG128A\r
@$(CROSS_COMPILE)objdump -h $@ | gawk -f $(ROOTDIR)/scripts/hc1x_memory.awk\r
else\r
@echo "Image size: (decimal)"\r
ALARM_ACTION_ACTIVATETASK=0,\r
ALARM_ACTION_SETEVENT,\r
ALARM_ACTION_ALARMCALLBACK, /* Only class 1 */\r
- ALARM_ACTION_INCREMENTCOUNTER, /* SWS OS302 */\r
+ ALARM_ACTION_INCREMENTCOUNTER/* SWS OS302 */\r
} alarm_action_type_t;\r
\r
\r
// Start with SetAbsAlarm()\r
ALARM_AUTOSTART_ABSOLUTE,\r
// Start with SetRelAlarm()\r
- ALARM_AUTOSTART_RELATIVE,\r
+ ALARM_AUTOSTART_RELATIVE\r
};\r
\r
\r
*/\r
\r
static inline uint32_t os_task_nr_to_mask( uint32_t nr ) {\r
- return (1<<nr);\r
+ return ((uint32_t) 1 << nr); // 701 PC-lint [10.5]: OK om skriver 1u... får då istället: 960 PC-lint [10.5]: Båda ok om skriver 1ul eller castar till uint32_t\r
}\r
\r
// task_i.c\r
\r
typedef enum {\r
LOCK_TYPE_RESOURCE,\r
- LOCK_TYPE_INTERRUPT,\r
+ LOCK_TYPE_INTERRUPT\r
} OsLocktypeType;\r
\r
typedef struct OsLockingtime {\r
// Start with StartScheduleTableRel()\r
SCHTBL_AUTOSTART_RELATIVE,\r
// Start with StartScheduleTableSyncon()\r
- SCHTBL_AUTOSTART_SYNCHRONE,\r
+ SCHTBL_AUTOSTART_SYNCHRONE\r
};\r
\r
\r
OP_TERMINATE_TASK = 8,\r
OP_SCHEDULE = 16,\r
OP_CHAIN_TASK = 32,\r
- OP_RELEASE_RESOURCE = 64,\r
+ OP_RELEASE_RESOURCE = 64\r
} OpType ;\r
\r
typedef struct sys_s {\r
rPtr = &os_sys.resScheduler;\r
} else {\r
/* Check we can access it */\r
- if( (pcbPtr->resourceAccess & (1<< ResID)) == 0 ) {\r
+ if( (pcbPtr->resourceAccess & ( (uint32_t) 1 << ResID)) == 0 ) {\r
rv = E_OS_ID;\r
goto err;\r
}\r
rPtr = &os_sys.resScheduler;\r
} else {\r
/* Check we can access it */\r
- if( (pcbPtr->resourceAccess & (1<< ResID)) == 0 ) {\r
+ if( (pcbPtr->resourceAccess & ( (uint32_t) 1 << ResID) ) == 0 ) {// 960 PC-lint [10.5]: varför klagar? funkar inte heller om (unsigned char)1 )\r
rv = E_OS_ID;\r
goto err;\r
}\r
pcb_p = os_get_pcb(pi);\r
\r
\r
- if(pcb_p->resourceAccess & (1<<i) ) {\r
+ if(pcb_p->resourceAccess & ( (uint32_t) 1<<i) ) {\r
topPrio = MAX(topPrio,pcb_p->prio);\r
}\r
\r
projects / arc.git / commitdiff