* for more details.\r
* -------------------------------- Arctic Core ------------------------------*/\r
\r
+/*\r
+ * General requirements\r
+ */\r
+/** @req DCM030 */\r
+\r
+\r
#include <string.h>\r
-#include "Mcu.h"\r
#include "Dcm.h"\r
#include "Dcm_Internal.h"\r
-#include "Det.h"\r
#include "MemMap.h"\r
+#if defined(USE_COMM)\r
#include "ComM_Dcm.h"\r
+#endif\r
#include "PduR_Dcm.h"\r
#include "ComStack_Types.h"\r
-\r
-#define USE_DEBUG_PRINTF\r
+#include "Cpu.h"\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
+#if (DCM_PAGEDBUFFER_ENABLED)\r
+#error "DCM_PAGEDBUFFER_ENABLED is set to STD_ON, this is not supported by the code."\r
+#endif\r
+\r
/*\r
* Type definitions.\r
*/\r
-typedef struct {\r
- const Dcm_DslProtocolRxType *protocolRx;\r
- const Dcm_DslMainConnectionType *mainConnection;\r
- const Dcm_DslConnectionType *connection;\r
- const Dcm_DslProtocolRowType *protocolRow;\r
-} DcmDsl_ProtocolConfigurationType;\r
-\r
-#define MAX_PARALLEL_PROTOCOLS_ALLOWED 1\r
+// #define MAX_PARALLEL_PROTOCOLS_ALLOWED 1\r
\r
typedef struct {\r
boolean initRun;\r
- const Dcm_DslProtocolRowType *preemptedProtocol; // Points to the currently active protocol.\r
+ //boolean diagnosticRequestPending; // This is a "semaphore" because DSD and DCM can handle multiple/parallel request at the moment.\r
const Dcm_DslProtocolRowType *activeProtocol; // Points to the currently active protocol.\r
- Dcm_DslRunTimeProtocolParametersType\r
- protocolList[MAX_PARALLEL_PROTOCOLS_ALLOWED];\r
+// const Dcm_DslProtocolRowType *preemptedProtocol; // Points to the currently active protocol - reserved for future use\r
+// Dcm_DslRunTimeProtocolParametersType protocolList[MAX_PARALLEL_PROTOCOLS_ALLOWED]; // Reserved for future use\r
} DcmDsl_RunTimeDataType;\r
\r
-DcmDsl_RunTimeDataType DcmDslRunTimeData = { .initRun = FALSE,\r
- .preemptedProtocol = NULL, .activeProtocol = NULL };\r
-\r
-// ################# DUMMIES START #################\r
-\r
-/*\r
- * Local types\r
- */\r
-\r
-// Global service table, set by DSL used by DSD\r
-Dcm_DsdServiceTableType *DslCurrentServiceTable = NULL;\r
-\r
-void ComM_DCM_ActivateDiagnostic() {\r
- ;\r
-}\r
-\r
-void ComM_DCM_InactivateDiagnostic() {\r
- ;\r
-}\r
+static DcmDsl_RunTimeDataType DcmDslRunTimeData = {\r
+ .initRun = FALSE,\r
+ .activeProtocol = NULL\r
+// .preemptedProtocol = NULL,\r
+// .protocolList = {}\r
+};\r
\r
// ################# HELPER FUNCTIONS START #################\r
\r
//\r
// This function reset/stars the session (S3) timer. See requirement\r
-// @DCM141 when that action should be taken.\r
+// DCM141 when that action should be taken.\r
//\r
-void startS3SessionTimer(Dcm_DslRunTimeProtocolParametersType *runtime,\r
- const Dcm_DslProtocolRowType *protocolRow) {\r
+static inline void startS3SessionTimer(Dcm_DslRunTimeProtocolParametersType *runtime, const Dcm_DslProtocolRowType *protocolRow) {\r
const Dcm_DslProtocolTimingRowType *timeParams;\r
timeParams = protocolRow->DslProtocolTimeLimit;\r
- runtime->S3ServerTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(\r
- timeParams->TimStrS3Server);\r
+ runtime->S3ServerTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(timeParams->TimStrS3Server);\r
}\r
\r
// - - - - - - - - - - -\r
\r
//\r
// This function reset/stars the session (S3) timer. See requirement\r
-// @DCM141 when that action should be taken.\r
+// DCM141 when that action should be taken.\r
//\r
-void stopS3SessionTimer(Dcm_DslRunTimeProtocolParametersType *runtime) {\r
+static inline void stopS3SessionTimer(Dcm_DslRunTimeProtocolParametersType *runtime) {\r
runtime->S3ServerTimeoutCount = 0;\r
}\r
\r
// - - - - - - - - - - -\r
\r
-#if 1\r
//\r
-// This function implements the requirement @DCM139 when\r
+// This function implements the requirement DCM139 when\r
// transition from one session to another.\r
-// qqq, strange observation: If S3 timeout we will not change security mode to\r
-// locked and that is how I interper the requirement.\r
//\r
-void changeDiagnosticSession(Dcm_DslRunTimeProtocolParametersType *runtime,\r
- Dcm_SesCtrlType newSession) {\r
+static void changeDiagnosticSession(Dcm_DslRunTimeProtocolParametersType *runtime, Dcm_SesCtrlType newSession) {\r
+\r
+ /** @req DCM139 */\r
+\r
switch (runtime->sessionControl) {\r
case DCM_DEFAULT_SESSION: // "default".\r
+ /* to set the dsp buffer to default*/\r
+ DspInit();\r
break;\r
\r
case DCM_PROGRAMMING_SESSION:\r
break;\r
\r
default:\r
- // TODO: Log this error.\r
- DEBUG(DEBUG_MEDIUM, "Old session invalid")\r
+ DET_REPORTERROR(MODULE_ID_DCM, 0, DCM_CHANGE_DIAGNOSTIC_SESSION_ID, DCM_E_PARAM);\r
+ //DEBUG(DEBUG_MEDIUM, "Old session invalid");\r
break;\r
}\r
\r
break;\r
\r
default:\r
- // TODO: Log this error.\r
- DEBUG(DEBUG_MEDIUM, "New session invalid")\r
- break;\r
- }\r
-}\r
-#else\r
-//\r
-// This function implements the requirement @DCM139 when\r
-// transition from one session to another.\r
-// qqq, strange observation: If S3 timeout we will not change security mode to\r
-// locked and that is how I interper the requirement.\r
-//\r
-void changeDiagnosticSession( Dcm_DslRunTimeProtocolParametersType *runtime,\r
- Dcm_SesCtrlType newSession) {\r
- switch (runtime->sessionControl) {\r
- case DCM_DEFAULT_SESSION: // "default".\r
- if ( newSession != DCM_DEFAULT_SESSION ) { // "default"\r
- runtime->securityLevel = DCM_SEC_LEV_LOCKED; // "0x00".\r
- runtime->sessionControl = newSession;\r
- runtime->protocolStarted = FALSE;\r
- DcmDslRunTimeData.activeProtocol = NULL;\r
- }\r
- break;\r
- case DCM_PROGRAMMING_SESSION:\r
- case DCM_EXTENDED_DIAGNOSTIC_SESSION:\r
- case DCM_SAFTEY_SYSTEM_DIAGNOSTIC_SESSION:\r
- case DCM_ALL_SESSION_LEVEL:\r
- runtime->securityLevel = DCM_SEC_LEV_LOCKED; // "0x00".\r
- runtime->sessionControl = newSession;\r
- break;\r
- default:\r
- // qqq: Log this error.\r
+ DET_REPORTERROR(MODULE_ID_DCM, 0, DCM_CHANGE_DIAGNOSTIC_SESSION_ID, DCM_E_PARAM);\r
+ //DEBUG(DEBUG_MEDIUM, "New session invalid");\r
break;\r
}\r
}\r
-#endif\r
\r
// - - - - - - - - - - -\r
\r
-void DslResetSessionTimeoutTimer() {\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
- Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+void DslResetSessionTimeoutTimer(void) {\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
+ Dcm_DslRunTimeProtocolParametersType *runtime;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
runtime = activeProtocol->DslRunTimeProtocolParameters;\r
- startS3SessionTimer(runtime, activeProtocol); // @DCM141\r
+ startS3SessionTimer(runtime, activeProtocol); /** @req DCM141 */\r
}\r
\r
// - - - - - - - - - - -\r
\r
-void DslGetCurrentServiceTable(\r
- const Dcm_DsdServiceTableType **currentServiceTable) {\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
+void DslGetCurrentServiceTable(const Dcm_DsdServiceTableType **currentServiceTable) { /** @req DCM195 */\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
if (activeProtocol != NULL) {\r
*currentServiceTable = activeProtocol->DslProtocolSIDTable;\r
\r
// - - - - - - - - - - -\r
\r
-Std_ReturnType DslGetActiveProtocol(Dcm_ProtocolType *protocolId) {\r
+Std_ReturnType DslGetActiveProtocol(Dcm_ProtocolType *protocolId) { /** @req DCM340 */\r
Std_ReturnType ret = E_NOT_OK;\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
if (activeProtocol != NULL) {\r
*protocolId = activeProtocol->DslProtocolID;\r
\r
// - - - - - - - - - - -\r
\r
-void DslSetSecurityLevel(Dcm_SecLevelType secLevel) {\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
- Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+void DslSetSecurityLevel(Dcm_SecLevelType secLevel) { /** @req DCM020 */\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
+ Dcm_DslRunTimeProtocolParametersType *runtime;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
runtime = activeProtocol->DslRunTimeProtocolParameters;\r
runtime->securityLevel = secLevel;\r
\r
// - - - - - - - - - - -\r
\r
-Std_ReturnType DslGetSecurityLevel(Dcm_SecLevelType *secLevel) {\r
+Std_ReturnType DslGetSecurityLevel(Dcm_SecLevelType *secLevel) { /** @req DCM020 *//** @req DCM338 */\r
Std_ReturnType ret = E_NOT_OK;\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
if (activeProtocol != NULL) {\r
runtime = activeProtocol->DslRunTimeProtocolParameters;\r
\r
// - - - - - - - - - - -\r
\r
-void DslSetSesCtrlType(Dcm_SesCtrlType sesCtrl) {\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
+void DslSetSesCtrlType(Dcm_SesCtrlType sesCtrl) { /** @req DCM022 */\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
if (activeProtocol != NULL) {\r
runtime = activeProtocol->DslRunTimeProtocolParameters;\r
\r
// - - - - - - - - - - -\r
\r
-Std_ReturnType DslGetSesCtrlType(Dcm_SesCtrlType *sesCtrlType) {\r
+Std_ReturnType DslGetSesCtrlType(Dcm_SesCtrlType *sesCtrlType) { /** @req DCM022 *//** @req DCM339 */\r
Std_ReturnType ret = E_NOT_OK;\r
- const Dcm_DslProtocolRowType *activeProtocol = NULL;\r
+ const Dcm_DslProtocolRowType *activeProtocol;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+\r
activeProtocol = DcmDslRunTimeData.activeProtocol;\r
if (activeProtocol != NULL) {\r
runtime = activeProtocol->DslRunTimeProtocolParameters;\r
\r
// - - - - - - - - - - -\r
\r
-boolean findRxPduIdParentConfigurationLeafs(PduIdType dcmRxPduId,\r
+static boolean findRxPduIdParentConfigurationLeafs(PduIdType dcmRxPduId,\r
const Dcm_DslProtocolRxType **protocolRx,\r
const Dcm_DslMainConnectionType **mainConnection,\r
const Dcm_DslConnectionType **connection,\r
Dcm_DslRunTimeProtocolParametersType **runtime) {\r
\r
boolean ret = FALSE;\r
- if (dcmRxPduId < DCM_DSL_BUFFER_LIST_LENGTH) {\r
- *protocolRx\r
- = &DCM_Config.Dsl->DslProtocol->DslProtocolRxGlobalList[dcmRxPduId];\r
+ if (dcmRxPduId < DCM_DSL_RX_PDU_ID_LIST_LENGTH) {\r
+ *protocolRx = &DCM_Config.Dsl->DslProtocol->DslProtocolRxGlobalList[dcmRxPduId];\r
*mainConnection = (*protocolRx)->DslMainConnectionParent;\r
*connection = (*mainConnection)->DslConnectionParent;\r
*protocolRow = (*connection)->DslProtocolRow;\r
\r
// - - - - - - - - - - -\r
\r
-boolean findTxPduIdParentConfigurationLeafs(PduIdType dcmTxPduId,\r
+static boolean findTxPduIdParentConfigurationLeafs(PduIdType dcmTxPduId,\r
const Dcm_DslProtocolTxType **protocolTx,\r
const Dcm_DslMainConnectionType **mainConnection,\r
const Dcm_DslConnectionType **connection,\r
Dcm_DslRunTimeProtocolParametersType **runtime) {\r
\r
boolean ret = FALSE;\r
- if (dcmTxPduId < DCM_DSL_BUFFER_LIST_LENGTH) {\r
- *protocolTx\r
- = &DCM_Config.Dsl->DslProtocol->DslProtocolTxGlobalList[dcmTxPduId];\r
+ if (dcmTxPduId < DCM_DSL_TX_PDU_ID_LIST_LENGTH) {\r
+ *protocolTx = &DCM_Config.Dsl->DslProtocol->DslProtocolTxGlobalList[dcmTxPduId];\r
*mainConnection = (*protocolTx)->DslMainConnectionParent;\r
*connection = (*mainConnection)->DslConnectionParent;\r
*protocolRow = (*connection)->DslProtocolRow;\r
\r
// - - - - - - - - - - -\r
\r
-void releaseExternalRxTxBuffers(const Dcm_DslProtocolRowType *protocolRow,\r
+static inline void releaseExternalRxTxBuffers(const Dcm_DslProtocolRowType *protocolRow,\r
Dcm_DslRunTimeProtocolParametersType *runtime) {\r
\r
- protocolRow->DslProtocolTxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
- protocolRow->DslProtocolRxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
+ protocolRow->DslProtocolTxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
+ protocolRow->DslProtocolRxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
runtime->externalTxBufferStatus = NOT_IN_USE; // We are waiting for DSD to return the buffer. qqq.\r
runtime->externalRxBufferStatus = NOT_IN_USE; // We are waiting for DSD to return the buffer. qqq.\r
}\r
// - - - - - - - - - - -\r
\r
\r
-void releaseExternalRxTxBuffersHelper(PduIdType rxPduIdRef) {\r
+static inline void releaseExternalRxTxBuffersHelper(PduIdType rxPduIdRef) {\r
const Dcm_DslProtocolRxType *protocolRx = NULL;\r
const Dcm_DslMainConnectionType *mainConnection = NULL;\r
const Dcm_DslConnectionType *connection = NULL;\r
const Dcm_DslProtocolRowType *protocolRow = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
\r
- if (findRxPduIdParentConfigurationLeafs(rxPduIdRef, &protocolRx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
+ if (findRxPduIdParentConfigurationLeafs(rxPduIdRef, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
releaseExternalRxTxBuffers(protocolRow, runtime);\r
}\r
}\r
\r
+// - - - - - - - - - - -\r
+\r
/*\r
* This function is called from the DSD module to the DSL when\r
* a response to a diagnostic request has been copied into the\r
* given TX-buffer and is ready for transmission.\r
*/\r
-void DslDsdProcessingDone(PduIdType rxPduIdRef,\r
- DsdProcessingDoneResultType responseResult) {\r
+void DslDsdProcessingDone(PduIdType rxPduIdRef, DsdProcessingDoneResultType responseResult) {\r
const Dcm_DslProtocolRxType *protocolRx = NULL;\r
const Dcm_DslMainConnectionType *mainConnection = NULL;\r
const Dcm_DslConnectionType *connection = NULL;\r
const Dcm_DslProtocolRowType *protocolRow = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
\r
- DEBUG( DEBUG_MEDIUM, "DslDsdProcessingDone rxPduIdRef=%d\n", rxPduIdRef);\r
+// DEBUG( DEBUG_MEDIUM, "DslDsdProcessingDone rxPduIdRef=%d\n", rxPduIdRef);\r
\r
- if (findRxPduIdParentConfigurationLeafs(rxPduIdRef, &protocolRx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
- imask_t state = McuE_EnterCriticalSection();\r
+ if (findRxPduIdParentConfigurationLeafs(rxPduIdRef, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
+ imask_t state;\r
+ Irq_Save(state);\r
switch (responseResult) {\r
case DSD_TX_RESPONSE_READY:\r
- runtime->externalTxBufferStatus = DSD_PENDING_RESPONSE_SIGNALED;\r
+ runtime->externalTxBufferStatus = DSD_PENDING_RESPONSE_SIGNALED; /** @req DCM114 */\r
break;\r
- case DSD_TX_RESPONSE_SUPPRESSED:\r
+ case DSD_TX_RESPONSE_SUPPRESSED: /** @req DCM238 */\r
+ //DEBUG( DEBUG_MEDIUM, "DslDsdProcessingDone called with DSD_TX_RESPONSE_SUPPRESSED.\n");\r
releaseExternalRxTxBuffersHelper(rxPduIdRef);\r
break;\r
default:\r
- DEBUG( DEBUG_MEDIUM, "Unknown response result from DslDsdProcessingDone!\n");\r
+ //DEBUG( DEBUG_MEDIUM, "Unknown response result from DslDsdProcessingDone!\n");\r
break;\r
}\r
- McuE_ExitCriticalSection(state);\r
+ Irq_Restore(state);\r
}\r
}\r
\r
+// - - - - - - - - - - -\r
+\r
/*\r
* This function preparing transmission of response\r
* pending message to tester.\r
*/\r
-void sendResponse(const Dcm_DslProtocolRowType *protocol,\r
+static void sendResponse(const Dcm_DslProtocolRowType *protocol,\r
Dcm_NegativeResponseCodeType responseCode) {\r
+ //Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+ const Dcm_DslProtocolRxType *protocolRx = NULL;\r
+ const Dcm_DslMainConnectionType *mainConnection = NULL;\r
+ const Dcm_DslConnectionType *connection = NULL;\r
+ const Dcm_DslProtocolRowType *protocolRow = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
- const uint32 txPduId = protocol->DslConnection->DslMainConnection->DslProtocolTx->DcmDslProtocolTxPduId;\r
- runtime = protocol->DslRunTimeProtocolParameters;\r
- imask_t state = McuE_EnterCriticalSection();\r
- if (runtime->localTxBuffer.status == NOT_IN_USE) {\r
- runtime->localTxBuffer.status = PROVIDED_TO_DSD; // For readability (yes, it will later be overwritten).\r
- runtime->localTxBuffer.buffer[0] = SID_NEGATIVE_RESPONSE;\r
- runtime->localTxBuffer.buffer[1]\r
- = protocol->DslProtocolRxBufferID->pduInfo.SduDataPtr[2];\r
- runtime->localTxBuffer.buffer[2] = responseCode; // 0x78.\r
- runtime->localTxBuffer.PduInfo.SduDataPtr\r
- = runtime->localTxBuffer.buffer;\r
- runtime->localTxBuffer.PduInfo.SduLength = 3;\r
- runtime->localTxBuffer.status = DCM_TRANSMIT_SIGNALED; // In the DslProvideTxBuffer 'callback' this state signals it is the local buffer we are intressted in sending.\r
- PduR_DcmTransmit(txPduId, &(runtime->localTxBuffer.PduInfo));\r
+ Std_ReturnType transmitResult;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+ /** @req DCM119 */\r
+ if (findRxPduIdParentConfigurationLeafs(protocol->DslRunTimeProtocolParameters->diagReqestRxPduId, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
+ if (runtime->localTxBuffer.status == NOT_IN_USE) {\r
+ runtime->localTxBuffer.status = PROVIDED_TO_DSD;\r
+ runtime->localTxBuffer.buffer[0] = SID_NEGATIVE_RESPONSE;\r
+ runtime->localTxBuffer.buffer[1] = protocol->DslProtocolRxBufferID->pduInfo.SduDataPtr[2];\r
+ runtime->localTxBuffer.buffer[2] = responseCode;\r
+ runtime->localTxBuffer.PduInfo.SduDataPtr = runtime->localTxBuffer.buffer;\r
+ runtime->localTxBuffer.PduInfo.SduLength = 3;\r
+ runtime->localTxBuffer.status = DCM_TRANSMIT_SIGNALED; // In the DslProvideTxBuffer 'callback' this state signals it is the local buffer we are interested in sending.\r
+ transmitResult = PduR_DcmTransmit(mainConnection->DslProtocolTx->DcmDslProtocolTxPduId, &(runtime->localTxBuffer.PduInfo));/** @req DCM115.Partially */ /* The P2ServerMin has not been implemented. */\r
+ if (transmitResult != E_OK) {\r
+ // TODO: What to do here?\r
+ }\r
+ }\r
}\r
- McuE_ExitCriticalSection(state);\r
+ Irq_Restore(state);\r
}\r
\r
// - - - - - - - - - - -\r
\r
-Std_ReturnType StartProtocolHelper(Dcm_ProtocolType protocolId) {\r
+static Std_ReturnType StartProtocolHelper(Dcm_ProtocolType protocolId) {\r
Std_ReturnType ret = E_NOT_OK;\r
uint16 i;\r
\r
for (i = 0; !DCM_Config.Dsl->DslCallbackDCMRequestService[i].Arc_EOL; i++) {\r
- if (DCM_Config.Dsl->DslCallbackDCMRequestService[i].StartProtocol\r
- != NULL) {\r
- ret\r
- = DCM_Config.Dsl->DslCallbackDCMRequestService[i]. StartProtocol(\r
- protocolId);\r
- if (ret != E_OK) { // qqq: eqvivalent to DCM_E_OK?\r
+ if (DCM_Config.Dsl->DslCallbackDCMRequestService[i].StartProtocol != NULL) {\r
+ ret = DCM_Config.Dsl->DslCallbackDCMRequestService[i]. StartProtocol(protocolId);\r
+ if (ret != E_OK) {\r
break;\r
}\r
}\r
\r
// - - - - - - - - - - -\r
\r
-boolean isTesterPresentCommand(const PduInfoType *rxPdu) {\r
+static boolean isTesterPresentCommand(const PduInfoType *rxPdu) {\r
boolean ret = FALSE;\r
- if ((rxPdu->SduDataPtr[0] == SID_TESTER_PRESENT) && (rxPdu->SduDataPtr[1]\r
- & SUPPRESS_POS_RESP_BIT)) {\r
- return TRUE;\r
+ if ((rxPdu->SduDataPtr[0] == SID_TESTER_PRESENT) && (rxPdu->SduDataPtr[1] & SUPPRESS_POS_RESP_BIT)) {\r
+ ret = TRUE;\r
}\r
return ret;\r
}\r
// Implements 'void Dcm_Init(void)' for DSL.\r
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
void DslInit(void) {\r
- const Dcm_DslProtocolRowType *listEntry = NULL;\r
+ const Dcm_DslProtocolRowType *listEntry;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
\r
listEntry = DCM_Config.Dsl->DslProtocol->DslProtocolRowList;\r
runtime->externalTxBufferStatus = DCM_IDLE;\r
runtime->localRxBuffer.status = DCM_IDLE;\r
runtime->localTxBuffer.status = DCM_IDLE;\r
- runtime->securityLevel = DCM_SEC_LEV_LOCKED;\r
- runtime->sessionControl = DCM_DEFAULT_SESSION;\r
- listEntry->DslProtocolRxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
- listEntry->DslProtocolRxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
+ runtime->securityLevel = DCM_SEC_LEV_LOCKED; /** @req DCM033 */\r
+ runtime->sessionControl = DCM_DEFAULT_SESSION; /** @req DCM034 */\r
+ listEntry->DslProtocolRxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
+ listEntry->DslProtocolRxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
listEntry++;\r
};\r
+ //DcmDslRunTimeData.diagnosticRequestPending = FALSE;\r
DcmDslRunTimeData.initRun = TRUE;\r
}\r
\r
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
-// Implements 'void Dcm_MainFunction(void)' for DSL.\r
+// Implements 'void DslInternal_ResponseOnOneDataByPeriodicId(uint8 PericodID)' for simulator a periodic did data.\r
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
\r
+void DslInternal_ResponseOnOneDataByPeriodicId(uint8 PericodID)\r
+{\r
+ const Dcm_DslProtocolRowType *protocolRowEntry;\r
+ Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
+ PduInfoType *pPeriodData;\r
+ protocolRowEntry = DCM_Config.Dsl->DslProtocol->DslProtocolRowList;\r
+ while (protocolRowEntry->Arc_EOL == FALSE) \r
+ {\r
+ runtime = protocolRowEntry->DslRunTimeProtocolParameters;\r
+ if(runtime != NULL) // find the runtime\r
+ {\r
+ DslProvideRxBufferToPdur(runtime->diagReqestRxPduId, 3, (const PduInfoType **)&pPeriodData);\r
+ pPeriodData->SduDataPtr[0] = 0x2a;\r
+ pPeriodData->SduDataPtr[1] = 0;\r
+ pPeriodData->SduDataPtr[2] = PericodID;\r
+ pPeriodData->SduLength = 3;\r
+ DslRxIndicationFromPduR(0, NTFRSLT_OK);\r
+ break;\r
+ }\r
+ protocolRowEntry++;\r
+ }\r
+}\r
+\r
+\r
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
+// Implements 'void Dcm_MainFunction(void)' for DSL.\r
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
void DslMain(void) {\r
- const Dcm_DslProtocolRowType *protocolRowEntry = NULL;\r
+ const Dcm_DslProtocolRowType *protocolRowEntry;\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
runtime = protocolRowEntry->DslRunTimeProtocolParameters;\r
if (runtime != NULL) {\r
+ // #### HANDLE THE TESTER PRESENT PRESENCE ####\r
if (runtime->sessionControl != DCM_DEFAULT_SESSION) { // Timeout if tester present is lost.\r
DECREMENT(runtime->S3ServerTimeoutCount);\r
if (runtime->S3ServerTimeoutCount == 0) {\r
- changeDiagnosticSession(runtime, DCM_DEFAULT_SESSION);\r
+ changeDiagnosticSession(runtime, DCM_DEFAULT_SESSION); /** @req DCM140 */\r
}\r
}\r
switch (runtime->externalTxBufferStatus) { // #### TX buffer state. ####\r
//DEBUG( DEBUG_MEDIUM, "state NOT_IN_USE!\n");\r
break;\r
case PROVIDED_TO_DSD: {\r
- DEBUG( DEBUG_MEDIUM, "debug_count=%d\n", debug_count);\r
DECREMENT(runtime->stateTimeoutCount);\r
if (runtime->stateTimeoutCount == 0) {\r
timeParams = protocolRowEntry->DslProtocolTimeLimit;\r
- runtime->stateTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(\r
- timeParams->TimStrP2ServerMax); /* Reinitiate timer, see 9.2.2. */\r
- if (DCM_Config.Dsl->DslDiagResp->DslDiagRespForceRespPendEn\r
- == TRUE) {\r
- if (runtime->responsePendingCount != 0) {\r
- DEBUG( DEBUG_MEDIUM, "No response withing timeout, sending response pending!\n");\r
- sendResponse(protocolRowEntry, DCM_E_RESPONSEPENDING);\r
- DECREMENT( runtime->responsePendingCount );\r
+ runtime->stateTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(timeParams->TimStrP2ServerMax); /* Reinitiate timer, see 9.2.2. */\r
+ if (DCM_Config.Dsl->DslDiagResp != NULL) {\r
+ if (DCM_Config.Dsl->DslDiagResp->DslDiagRespForceRespPendEn == TRUE) {\r
+ if (runtime->responsePendingCount != 0) {\r
+ sendResponse(protocolRowEntry, DCM_E_RESPONSEPENDING); /** @req DCM024 */\r
+ DECREMENT( runtime->responsePendingCount );\r
+ } else {\r
+ sendResponse(protocolRowEntry, DCM_E_GENERALREJECT); /** @req DCM120 */\r
+ releaseExternalRxTxBuffers(protocolRowEntry, runtime);\r
+ }\r
} else {\r
- DEBUG( DEBUG_MEDIUM, "Sent all response pending, now sending general reject!\n");\r
+ // DEBUG( DEBUG_MEDIUM, "Not configured to send response pending, now sending general reject!\n");\r
sendResponse(protocolRowEntry, DCM_E_GENERALREJECT);\r
- releaseExternalRxTxBuffers(protocolRowEntry,\r
- runtime);\r
+ releaseExternalRxTxBuffers(protocolRowEntry, runtime);\r
}\r
- } else {\r
- DEBUG( DEBUG_MEDIUM, "Not configured to send response pending, now sending general reject!\n");\r
- sendResponse(protocolRowEntry, DCM_E_GENERALREJECT);\r
- releaseExternalRxTxBuffers(protocolRowEntry, runtime);\r
}\r
}\r
break;\r
// Make sure that response pending or general reject have not been issued,\r
// if so we can not transmit to PduR because we would not know from where\r
// the Tx confirmation resides later.\r
- DEBUG( DEBUG_MEDIUM, "Current polite index=debug_count=%d\n", debug_count);\r
- DEBUG( DEBUG_MEDIUM, "state DSD_PENDING_RESPONSE_SIGNALED!\n");\r
- if (runtime->localTxBuffer.status == NOT_IN_USE) {\r
- const uint32 txPduId = protocolRowEntry->DslConnection->DslMainConnection->DslProtocolTx->DcmDslProtocolTxPduId;\r
- DEBUG( DEBUG_MEDIUM, "runtime->externalTxBufferStatus enter state DSD_PENDING_RESPONSE_SIGNALED.\n", txPduId);\r
- runtime->externalTxBufferStatus = DCM_TRANSMIT_SIGNALED;\r
- DEBUG( DEBUG_MEDIUM, "Calling PduR_DcmTransmit with txPduId = %d from DslMain\n", txPduId);\r
- PduR_DcmTransmit(txPduId,\r
- &runtime->diagnosticResponseFromDsd); /** @req DCM237 **//* Will trigger PduR (CanTP) to call DslProvideTxBuffer(). */\r
+ // DEBUG( DEBUG_MEDIUM, "state DSD_PENDING_RESPONSE_SIGNALED!\n");\r
+ if (runtime->localTxBuffer.status == NOT_IN_USE) { // Make sure that no TxConfirm could be sent by the local buffer and mixed up with this transmission.\r
+ const Dcm_DslProtocolRxType *protocolRx = NULL;\r
+ const Dcm_DslMainConnectionType *mainConnection = NULL;\r
+ const Dcm_DslConnectionType *connection = NULL;\r
+ const Dcm_DslProtocolRowType *protocolRow = NULL;\r
+ Std_ReturnType transmitResult;\r
+\r
+ if (findRxPduIdParentConfigurationLeafs(runtime->diagReqestRxPduId, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
+ const PduIdType txPduId = mainConnection->DslProtocolTx->DcmDslProtocolTxPduId;\r
+ // DEBUG( DEBUG_MEDIUM, "runtime->externalTxBufferStatus enter state DCM_TRANSMIT_SIGNALED.\n" );\r
+ runtime->externalTxBufferStatus = DCM_TRANSMIT_SIGNALED;\r
+ transmitResult = PduR_DcmTransmit(txPduId, &runtime->diagnosticResponseFromDsd); /** @req DCM237 *//* Will trigger PduR (CanTP) to call DslProvideTxBuffer(). */\r
+ if (transmitResult != E_OK) {\r
+ // TODO: What to do here?\r
+ }\r
+ } else {\r
+ // DEBUG( DEBUG_MEDIUM, "***** WARNING, THIS IS UNEXPECTED !!! ********.\n" );\r
+ const PduIdType txPduId = protocolRowEntry->DslConnection->DslMainConnection->DslProtocolTx->DcmDslProtocolTxPduId;\r
+ // DEBUG( DEBUG_MEDIUM, "runtime->externalTxBufferStatus enter state DSD_PENDING_RESPONSE_SIGNALED.\n", txPduId);\r
+ runtime->externalTxBufferStatus = DCM_TRANSMIT_SIGNALED;\r
+ // DEBUG( DEBUG_MEDIUM, "Calling PduR_DcmTransmit with txPduId = %d from DslMain\n", txPduId);\r
+ transmitResult = PduR_DcmTransmit(txPduId, &runtime->diagnosticResponseFromDsd); /** @req DCM237 *//* Will trigger PduR (CanTP) to call DslProvideTxBuffer(). */\r
+ if (transmitResult != E_OK) {\r
+ // TODO: What to do here?\r
+ }\r
+ }\r
}\r
break;\r
case DCM_TRANSMIT_SIGNALED:\r
}\r
}\r
protocolRowEntry++;\r
- debug_count++;\r
}\r
}\r
\r
// received a FF or a single frame and needs to obtain a buffer from the\r
// receiver so that received data can be forwarded.\r
\r
-BufReq_ReturnType DslProvideRxBufferToPdur(PduIdType dcmRxPduId,\r
- PduLengthType tpSduLength, const PduInfoType **pduInfoPtr) {\r
+BufReq_ReturnType DslProvideRxBufferToPdur(PduIdType dcmRxPduId, PduLengthType tpSduLength, const PduInfoType **pduInfoPtr) {\r
BufReq_ReturnType ret = BUFREQ_NOT_OK;\r
const Dcm_DslProtocolRxType *protocolRx = NULL;\r
const Dcm_DslMainConnectionType *mainConnection = NULL;\r
const Dcm_DslConnectionType *connection = NULL;\r
const Dcm_DslProtocolRowType *protocolRow = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
-\r
- DEBUG( DEBUG_MEDIUM, "DslProvideRxBufferToPdur(dcmRxPduId=%d) called!\n", dcmRxPduId);\r
- imask_t state = McuE_EnterCriticalSection();\r
- if (findRxPduIdParentConfigurationLeafs(dcmRxPduId, &protocolRx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
- const Dcm_DslBufferType *externalRxBuffer =\r
- protocolRow->DslProtocolRxBufferID;\r
- if (externalRxBuffer->pduInfo.SduLength >= tpSduLength) { // First validate that we have a chance receiving the chunk of data.\r
- if ((runtime->externalRxBufferStatus == NOT_IN_USE)\r
- && (externalRxBuffer->externalBufferRuntimeData->status\r
- == BUFFER_AVAILABLE)) {\r
- DEBUG( DEBUG_MEDIUM, "External buffer available!\n");\r
+ imask_t state;\r
+// DEBUG( DEBUG_MEDIUM, "DslProvideRxBufferToPdur(dcmRxPduId=%d) called!\n", dcmRxPduId); \r
+ Irq_Save(state);\r
+ if (findRxPduIdParentConfigurationLeafs(dcmRxPduId, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
+ const Dcm_DslBufferType *externalRxBuffer = protocolRow->DslProtocolRxBufferID;\r
+ if (externalRxBuffer->pduInfo.SduLength >= tpSduLength) { /** @req DCM443 */\r
+ if ((runtime->externalRxBufferStatus == NOT_IN_USE) && (externalRxBuffer->externalBufferRuntimeData->status == BUFFER_AVAILABLE)) {\r
+ // DEBUG( DEBUG_MEDIUM, "External buffer available!\n");\r
// ### EXTERNAL BUFFER IS AVAILABLE; GRAB IT AND REMEBER THAT WE OWN IT! ###\r
- externalRxBuffer->externalBufferRuntimeData->status\r
- = BUFFER_BUSY;\r
- runtime->diagnosticRequestFromTester.SduDataPtr\r
- = externalRxBuffer->pduInfo.SduDataPtr;\r
+ externalRxBuffer->externalBufferRuntimeData->status = BUFFER_BUSY;\r
+ runtime->diagnosticRequestFromTester.SduDataPtr = externalRxBuffer->pduInfo.SduDataPtr;\r
runtime->diagnosticRequestFromTester.SduLength = tpSduLength;\r
- //*pduInfoPtr = &(externalRxBuffer->pduInfo);\r
*pduInfoPtr = &(runtime->diagnosticRequestFromTester);\r
- runtime->externalRxBufferStatus = PROVIDED_TO_PDUR;\r
+ runtime->externalRxBufferStatus = PROVIDED_TO_PDUR; /** @req DCM342 */\r
ret = BUFREQ_OK;\r
} else {\r
- DEBUG( DEBUG_MEDIUM, "Local buffer available!\n");\r
if (runtime->externalRxBufferStatus == PROVIDED_TO_DSD) {\r
// ### EXTERNAL BUFFER IS IN USE BY THE DSD, TRY TO USE LOCAL BUFFER! ###\r
if (runtime->localRxBuffer.status == NOT_IN_USE) {\r
if (tpSduLength < DCM_DSL_LOCAL_BUFFER_LENGTH) {\r
runtime->localRxBuffer.status = PROVIDED_TO_PDUR;\r
- runtime->localRxBuffer.PduInfo.SduDataPtr\r
- = runtime->localRxBuffer.buffer;\r
- runtime->localRxBuffer.PduInfo.SduLength\r
- = tpSduLength;\r
+ runtime->localRxBuffer.PduInfo.SduDataPtr = runtime->localRxBuffer.buffer;\r
+ runtime->localRxBuffer.PduInfo.SduLength = tpSduLength;\r
*pduInfoPtr = &(runtime->localRxBuffer.PduInfo);\r
ret = BUFREQ_OK;\r
+ } else {\r
+ ret = BUFREQ_BUSY;\r
}\r
}\r
} else {\r
// The buffer is in use by the PduR, we can not help this because then\r
// we would have two different Rx-indications with same PduId but we\r
// will not know which buffer the indication should free.\r
- ret = BUFREQ_BUSY;\r
+ ret = BUFREQ_BUSY; /** @req DCM445 */\r
}\r
}\r
} else {\r
- ret = BUFREQ_OVFL; // Required size is too big.\r
+ ret = BUFREQ_OVFL; /** @req DCM444 */\r
}\r
if (ret == BUFREQ_OK) {\r
- stopS3SessionTimer(runtime); /** req: DCM141 **/\r
+ stopS3SessionTimer(runtime); /** @req DCM141 */\r
}\r
}\r
- McuE_ExitCriticalSection(state);\r
+ Irq_Restore(state);\r
return ret;\r
}\r
\r
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
// This function is called called by the PduR typically when CanTp has\r
// received the diagnostic request, copied it to the provided buffer and need to indicate\r
-// this to the DCM (DSL) module via propritary API.\r
+// this to the DCM (DSL) module via proprietary API.\r
\r
void DslRxIndicationFromPduR(PduIdType dcmRxPduId, NotifResultType result) {\r
const Dcm_DslProtocolRxType *protocolRx = NULL;\r
Std_ReturnType higherLayerResp;\r
imask_t state;\r
\r
- // qqq: handle the actual result code.\r
- if (findRxPduIdParentConfigurationLeafs(dcmRxPduId, &protocolRx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
+ /** @req DCM345, this needs to be verified when connection to CanIf works. */\r
+\r
+ if (findRxPduIdParentConfigurationLeafs(dcmRxPduId, &protocolRx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
timeParams = protocolRow->DslProtocolTimeLimit;\r
// We need to find out in what buffer we can find our Rx data (it can\r
// be either in the normal RX-buffer or the 'extra' buffer for implementing\r
// the Concurrent "Test Present" functionality.\r
+ Irq_Save(state);\r
if (runtime->externalRxBufferStatus == PROVIDED_TO_PDUR) {\r
- if (isTesterPresentCommand(\r
- &(protocolRow->DslProtocolRxBufferID->pduInfo))) {\r
- state = McuE_EnterCriticalSection();\r
- startS3SessionTimer(runtime, protocolRow); /** @req DCM141 **//** @req DCM112 **//** @req DCM113 **/\r
- runtime->externalRxBufferStatus = NOT_IN_USE;\r
- McuE_ExitCriticalSection(state);\r
- } else {\r
- if (runtime->protocolStarted == FALSE) {\r
- higherLayerResp = StartProtocolHelper(\r
- protocolRow->DslProtocolID);\r
- if (higherLayerResp == E_OK) {\r
- runtime->protocolStarted = TRUE;\r
- DcmDslRunTimeData.activeProtocol = protocolRow;\r
+ if ( result == NTFRSLT_OK ) { /** @req DCM111 */\r
+ if (isTesterPresentCommand(&(protocolRow->DslProtocolRxBufferID->pduInfo))) {\r
+ startS3SessionTimer(runtime, protocolRow); /** @req DCM141 *//** @req DCM112 *//** @req DCM113 */\r
+ runtime->externalRxBufferStatus = NOT_IN_USE;\r
+ protocolRow->DslProtocolRxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
+ } else {\r
+ if (runtime->protocolStarted == FALSE) {\r
+ higherLayerResp = StartProtocolHelper(protocolRow->DslProtocolID); /** @req DCM036 */\r
+ if (higherLayerResp == E_OK) {\r
+ runtime->protocolStarted = TRUE;\r
+ DcmDslRunTimeData.activeProtocol = protocolRow;\r
+ }\r
}\r
- }\r
- if (runtime->protocolStarted == TRUE) {\r
- if (runtime->diagnosticActiveComM == FALSE) {\r
- ComM_DCM_ActivateDiagnostic(); /* @DCM163 */\r
- runtime->diagnosticActiveComM = TRUE;\r
+ if (runtime->protocolStarted == TRUE) {\r
+ if (runtime->diagnosticActiveComM == FALSE) {\r
+#if defined(USE_COMM)\r
+ ComM_DCM_ActiveDiagnostic(); /** @req DCM163 */\r
+#endif\r
+ runtime->diagnosticActiveComM = TRUE;\r
+ }\r
+ timeParams = protocolRow->DslProtocolTimeLimit;\r
+ runtime->stateTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(timeParams->TimStrP2ServerMax); /* See 9.2.2. */\r
+ runtime->externalRxBufferStatus = PROVIDED_TO_DSD; /** @req DCM241 */\r
+ if (runtime->externalTxBufferStatus == NOT_IN_USE) {\r
+ // DEBUG( DEBUG_MEDIUM, "External Tx buffer available, we can pass it to DSD.\n");\r
+ } else {\r
+ //DEBUG( DEBUG_MEDIUM, "External buffer not available, a response is being transmitted?\n");\r
+ }\r
+ runtime->externalTxBufferStatus = PROVIDED_TO_DSD; /** @req DCM241 */\r
+ runtime->responsePendingCount = DCM_Config.Dsl->DslDiagResp->DslDiagRespMaxNumRespPend;\r
+ runtime->diagnosticResponseFromDsd.SduDataPtr = protocolRow->DslProtocolTxBufferID->pduInfo.SduDataPtr;\r
+ runtime->diagnosticResponseFromDsd.SduLength = protocolRow->DslProtocolTxBufferID->pduInfo.SduLength;\r
+ // DEBUG( DEBUG_MEDIUM, "DsdDslDataIndication(DcmDslProtocolTxPduId=%d, dcmRxPduId=%d)\n", mainConnection->DslProtocolTx->DcmDslProtocolTxPduId, dcmRxPduId);\r
+ runtime->diagReqestRxPduId = dcmRxPduId;\r
+ // DEBUG(DEBUG_MEDIUM,"\n\n runtime->diagnosticRequestFromTester.SduDataPtr[2] %x\n\n ",runtime->diagnosticRequestFromTester.SduDataPtr[2]);\r
+ DsdDslDataIndication( // qqq: We are inside a critical section.\r
+ &(runtime->diagnosticRequestFromTester),\r
+ protocolRow->DslProtocolSIDTable, /** @req DCM035 */\r
+ protocolRx->DslProtocolAddrType,\r
+ mainConnection->DslProtocolTx->DcmDslProtocolTxPduId,\r
+ &(runtime->diagnosticResponseFromDsd),\r
+ dcmRxPduId);\r
}\r
- state = McuE_EnterCriticalSection();\r
- runtime->stateTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(\r
- timeParams->TimStrP2ServerMax); /* See 9.2.2. */\r
- runtime->externalRxBufferStatus = PROVIDED_TO_DSD;\r
- runtime->externalTxBufferStatus = PROVIDED_TO_DSD; // Used in main.\r
- timeParams = protocolRow->DslProtocolTimeLimit;\r
- runtime->stateTimeoutCount = DCM_CONVERT_MS_TO_MAIN_CYCLES(\r
- timeParams->TimStrP2ServerMax); /* Reinitiate timer, see 9.2.2. */\r
- McuE_ExitCriticalSection(state);\r
- runtime->diagnosticResponseFromDsd.SduDataPtr\r
- = protocolRow->DslProtocolTxBufferID->pduInfo.SduDataPtr;\r
- runtime->diagnosticResponseFromDsd.SduLength\r
- = protocolRow->DslProtocolTxBufferID->pduInfo.SduLength;\r
- DEBUG( DEBUG_MEDIUM, "DsdDslDataIndication(DcmDslProtocolTxPduId=%d, dcmRxPduId=%d)\n",\r
- mainConnection->DslProtocolTx->DcmDslProtocolTxPduId, dcmRxPduId);\r
- DsdDslDataIndication(\r
- &(runtime->diagnosticRequestFromTester),\r
- protocolRow->DslProtocolSIDTable,\r
- protocolRx->DslProtocolAddrType,\r
- dcmRxPduId,\r
- &(runtime->diagnosticResponseFromDsd),\r
- dcmRxPduId);\r
-\r
-\r
}\r
+ } else { /** @req DCM344 */\r
+ // The indication was not equal to NTFRSLT_OK, release the resources and no forward to DSD.\r
+ runtime->externalRxBufferStatus = NOT_IN_USE;\r
+ protocolRow->DslProtocolRxBufferID->externalBufferRuntimeData->status = BUFFER_AVAILABLE;\r
}\r
} else {\r
// It is the local buffer that was provided to the PduR, that buffer\r
// is only used for tester present reception in parallel to diagnostic\r
// requests.\r
- state = McuE_EnterCriticalSection();\r
if (runtime->localRxBuffer.status == PROVIDED_TO_PDUR) {\r
- if (isTesterPresentCommand(&(runtime->localRxBuffer.PduInfo))) {\r
- startS3SessionTimer(runtime, protocolRow); /** @req DCM141 **//** @req DCM112 **//** @req DCM113 **/\r
+ if ( result == NTFRSLT_OK ) { // Make sure that the data in buffer is valid.\r
+ if (isTesterPresentCommand(&(runtime->localRxBuffer.PduInfo))) {\r
+ startS3SessionTimer(runtime, protocolRow); /** @req DCM141 *//** @req DCM112 *//** @req DCM113 */\r
+ }\r
}\r
runtime->localRxBuffer.status = NOT_IN_USE;\r
}\r
- McuE_ExitCriticalSection(state);\r
}\r
+ Irq_Restore(state);\r
}\r
}\r
\r
// it has detected that the pending request has been answered by DSD\r
// (or any other module?).\r
\r
-BufReq_ReturnType DslProvideTxBuffer(PduIdType dcmTxPduId,\r
- const PduInfoType **pduInfoPtr, PduLengthType length) {\r
+BufReq_ReturnType DslProvideTxBuffer(PduIdType dcmTxPduId, const PduInfoType **pduInfoPtr, PduLengthType length) {\r
BufReq_ReturnType ret = BUFREQ_NOT_OK;\r
const Dcm_DslProtocolTxType *protocolTx = NULL;\r
const Dcm_DslMainConnectionType *mainConnection = NULL;\r
const Dcm_DslProtocolRowType *protocolRow = NULL;\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
\r
- DEBUG( DEBUG_MEDIUM, "DslProvideTxBuffer (dcmTxPduId=%d)\n", dcmTxPduId);\r
- if (findTxPduIdParentConfigurationLeafs(dcmTxPduId, &protocolTx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
+ (void)length; // Currently not used, this is only to remove compilation warnings\r
+// DEBUG( DEBUG_MEDIUM, "DslProvideTxBuffer=%d\n", dcmTxPduId);\r
+ if (findTxPduIdParentConfigurationLeafs(dcmTxPduId, &protocolTx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
switch (runtime->externalTxBufferStatus) { // ### EXTERNAL TX BUFFER ###\r
case DCM_TRANSMIT_SIGNALED: {\r
+ /** @req DCM346 */ /* Length verification is already done if this state is reached. */\r
*pduInfoPtr = &(protocolRow->DslProtocolTxBufferID->pduInfo);\r
- runtime->externalTxBufferStatus = PROVIDED_TO_PDUR;\r
+ runtime->externalTxBufferStatus = PROVIDED_TO_PDUR; /** @req DCM349 */\r
ret = BUFREQ_OK;\r
break;\r
}\r
default:\r
- DEBUG( DEBUG_MEDIUM, "DCM_TRANSMIT_SIGNALED was not signaled in the external buffer\n");\r
+ //DEBUG( DEBUG_MEDIUM, "DCM_TRANSMIT_SIGNALED was not signaled in the external buffer\n");\r
ret = BUFREQ_NOT_OK;\r
break;\r
}\r
if (ret == BUFREQ_NOT_OK) {\r
switch (runtime->localTxBuffer.status) { // ### LOCAL TX BUFFER ###\r
case DCM_TRANSMIT_SIGNALED: {\r
- runtime->localTxBuffer.PduInfo.SduDataPtr\r
- = runtime->localTxBuffer.buffer;\r
- runtime->localTxBuffer.PduInfo.SduLength\r
- = runtime->localTxBuffer.messageLenght;\r
+ runtime->localTxBuffer.PduInfo.SduDataPtr = runtime->localTxBuffer.buffer;\r
+ runtime->localTxBuffer.PduInfo.SduLength = runtime->localTxBuffer.messageLenght;\r
*pduInfoPtr = &runtime->localTxBuffer.PduInfo;\r
runtime->localTxBuffer.status = PROVIDED_TO_PDUR; // Now the DSL should not touch this Tx-buffer anymore.\r
ret = BUFREQ_OK;\r
break;\r
}\r
default:\r
- DEBUG( DEBUG_MEDIUM, "DCM_TRANSMIT_SIGNALED was not signaled for the local buffer either\n");\r
+ //DEBUG( DEBUG_MEDIUM, "DCM_TRANSMIT_SIGNALED was not signaled for the local buffer either\n");\r
ret = BUFREQ_NOT_OK;\r
break;\r
}\r
Dcm_DslRunTimeProtocolParametersType *runtime = NULL;\r
imask_t state;\r
\r
- DEBUG( DEBUG_MEDIUM, "DslTxConfirmation=%d\n", dcmTxPduId);\r
- if (findTxPduIdParentConfigurationLeafs(dcmTxPduId, &protocolTx, &mainConnection,\r
- &connection, &protocolRow, &runtime)) {\r
+// DEBUG( DEBUG_MEDIUM, "DslTxConfirmation=%d, result=%d\n", dcmTxPduId, result);\r
+ if (findTxPduIdParentConfigurationLeafs(dcmTxPduId, &protocolTx, &mainConnection, &connection, &protocolRow, &runtime)) {\r
boolean externalBufferReleased = FALSE;\r
\r
// Free the buffer and free the Pdu runtime data buffer.\r
- state = McuE_EnterCriticalSection();\r
+ Irq_Save(state);\r
switch (runtime->externalTxBufferStatus) { // ### EXTERNAL TX BUFFER ###\r
case PROVIDED_TO_PDUR: {\r
- ComM_DCM_InactivateDiagnostic();\r
- startS3SessionTimer(runtime, protocolRow); // @DCM141\r
- releaseExternalRxTxBuffers(protocolRow, runtime);\r
- /*\r
- protocolRow->DslProtocolTxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
- protocolRow->DslProtocolRxBufferID->externalBufferRuntimeData->status\r
- = BUFFER_AVAILABLE;\r
- runtime->externalTxBufferStatus = DCM_IDLE;\r
- runtime->externalRxBufferStatus = DCM_IDLE;\r
- */\r
- DEBUG( DEBUG_MEDIUM, "Released external buffer sucessfully!\n");\r
+#if defined(USE_COMM)\r
+ ComM_DCM_InactiveDiagnostic(); /** @req DCM164 */\r
+#endif\r
+ startS3SessionTimer(runtime, protocolRow); /** @req DCM141 */\r
+ releaseExternalRxTxBuffers(protocolRow, runtime); /** @req DCM118 *//** @req DCM352 *//** @req DCM353 *//** @req DCM354 */\r
externalBufferReleased = TRUE;\r
-\r
-// DsdDataConfirmation(\r
-// mainConnection->DslProtocolTx->PduR_DcmDslTxPduId, result); /** @req DCM117 **//** @req DCM235 **/\r
-\r
- DsdDataConfirmation(dcmTxPduId, result); /** @req DCM117 **//** @req DCM235 **/\r
-\r
+ // DEBUG( DEBUG_MEDIUM, "Released external buffer OK!\n");\r
+ DsdDataConfirmation(mainConnection->DslProtocolTx->DcmDslProtocolTxPduId, result); /** @req DCM117 *//** @req DCM235 */\r
break;\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!\n");\r
+ // DEBUG( DEBUG_MEDIUM, "Released local buffer buffer OK!\n");\r
runtime->localTxBuffer.status = DCM_IDLE;\r
break;\r
default:\r
- DEBUG( DEBUG_MEDIUM, "WARNING! DslTxConfirmation could not release any buffer!\n");\r
+ // DEBUG( DEBUG_MEDIUM, "WARNING! DslTxConfirmation could not release external or local buffer!\n");\r
break;\r
}\r
}\r
- McuE_ExitCriticalSection(state);\r
+ Irq_Restore(state);\r
}\r
}\r
\r
projects / arc.git / blobdiff