diagnostic/Dcm/Dcm_Dsp.c

   1 /* -------------------------------- Arctic Core ------------------------------\r
   2  * Arctic Core - the open source AUTOSAR platform http://arccore.com\r
   3  *\r
   4  * Copyright (C) 2009  ArcCore AB <contact@arccore.com>\r
   5  *\r
   6  * This source code is free software; you can redistribute it and/or modify it\r
   7  * under the terms of the GNU General Public License version 2 as published by the\r
   8  * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful, but\r
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
  13  * for more details.\r
  14  * -------------------------------- Arctic Core ------------------------------*/\r
  15 \r
  16 //lint -esym(754, SID)  //Structure member SID not used in udsReadDtcInfoSub_0x01_0x07_0x11_0x12() and udsReadDtcInfoSub_0x02_0x0A_0x0F_0x13_0x15()\r
  17 \r
  18 \r
  19 /*\r
  20  *  General requirements\r
  21  */\r
  22 /** @req DCM273 */ /** @req DCM272 */\r
  23 /** @req DCM039 */ /** @req DCM038 */ /** @req DCM269 */\r
  24 /** @req DCM271 */ /** @req DCM274 */ /** @req DCM275 */ /** @req DCM424 */\r
  25 /** @req DCM007 */\r
  26 #include <string.h>\r
  27 #include "Dcm.h"\r
  28 #include "Dcm_Internal.h"\r
  29 #include "Dem.h"\r
  30 #include "MemMap.h"\r
  31 #if defined(USE_MCU)\r
  32 #include "Mcu.h"\r
  33 #endif\r
  34 \r
  35 /*\r
  36  * Macros\r
  37  */\r
  38 #define ZERO_SUB_FUNCTION                               0x00\r
  39 #define DCM_FORMAT_LOW_MASK                     0x0F\r
  40 #define DCM_FORMAT_HIGH_MASK                    0xF0\r
  41 #define DCM_MEMORY_ADDRESS_MASK         0xFFFFFF\r
  42 #define DCM_DID_HIGH_MASK                               0xFF00                  \r
  43 #define DCM_DID_LOW_MASK                                0xFF\r
  44 #define DCM_PERODICDID_HIHG_MASK                0xF200\r
  45 #define SID_AND_ALFID_LEN2   0x2\r
  46 #define SID_AND_ALFID_LEN4   0x4\r
  47 #define SID_AND_ALFID_LEN5      0x5\r
  48 #define SID_AND_ALFID_LEN6   0x6\r
  49 #define SID_AND_ALFID_LEN7   0x7\r
  50 \r
  51 #define BYTES_TO_DTC(hb, mb, lb)        (((uint32)(hb) << 16) | ((uint32)(mb) << 8) | (uint32)(lb))\r
  52 #define DTC_HIGH_BYTE(dtc)                      (((uint32)(dtc) >> 16) & 0xFFu)\r
  53 #define DTC_MID_BYTE(dtc)                       (((uint32)(dtc) >> 8) & 0xFFu)\r
  54 #define DTC_LOW_BYTE(dtc)                       ((uint32)(dtc) & 0xFFu)\r
  55 \r
  56 \r
  57 typedef struct {\r
  58         boolean resetPending;\r
  59         PduIdType resetPduId;\r
  60 } DspUdsEcuResetDataType;\r
  61 \r
  62 static DspUdsEcuResetDataType dspUdsEcuResetData;\r
  63 static boolean dspWritePending;\r
  64 \r
  65 typedef struct {\r
  66         boolean                                                 reqInProgress;\r
  67         Dcm_SecLevelType                                reqSecLevel;\r
  68         const Dcm_DspSecurityRowType    *reqSecLevelRef;\r
  69 } DspUdsSecurityAccessDataType;\r
  70 \r
  71 static DspUdsSecurityAccessDataType dspUdsSecurityAccesData;\r
  72 \r
  73 typedef enum{\r
  74         DCM_MEMORY_UNUSED,\r
  75         DCM_MEMORY_READ,\r
  76         DCM_MEMORY_WRITE,\r
  77         DCM_MEMORY_FAILED       \r
  78 }Dcm_DspMemoryStateType;\r
  79 Dcm_DspMemoryStateType dspMemoryState;\r
  80 \r
  81 typedef enum{\r
  82         DCM_DDD_SOURCE_DEFAULT,\r
  83         DCM_DDD_SOURCE_DID,\r
  84         DCM_DDD_SOURCE_ADDRESS\r
  85 }Dcm_DspDDDTpyeID;\r
  86 \r
  87 typedef struct{\r
  88         uint32 PDidTxCounter;\r
  89         uint32 PDidTxCounterNumber;\r
  90         uint8  PeriodicDid;\r
  91 }Dcm_pDidType;/* a type to save  the periodic DID and cycle */\r
  92 \r
  93 typedef struct{\r
  94         Dcm_pDidType dspPDid[DCM_LIMITNUMBER_PERIODDATA];       /*a buffer to save the periodic DID and cycle   */\r
  95         uint8 PDidNr;                                                                           /* note the number of periodic DID is used */\r
  96 }Dsp_pDidRefType;\r
  97 \r
  98 Dsp_pDidRefType dspPDidRef; \r
  99 \r
 100 typedef struct{\r
 101         uint8   formatOrPosition;                                               /*note the formate of address and size*/\r
 102         uint32 SourceAddressOrDid;                                                              /*note the memory address */\r
 103         uint16 Size;                                                                            /*note the memory size */\r
 104         Dcm_DspDDDTpyeID DDDTpyeID;\r
 105 }Dcm_DspDDDSourceType;\r
 106 \r
 107 typedef struct{\r
 108         uint16 DynamicallyDid;\r
 109         Dcm_DspDDDSourceType DDDSource[DCM_MAX_DDDSOURCE_NUMBER];\r
 110 }\r
 111 Dcm_DspDDDType;\r
 112 \r
 113 Dcm_DspDDDType dspDDD[DCM_MAX_DDD_NUMBER];\r
 114 \r
 115 \r
 116 /*\r
 117  * * static Function\r
 118  */\r
 119 \r
 120 static boolean lookupReadMemory(uint32 memoryAddress,\r
 121                                                                 uint8  memoryAddressFormat,\r
 122                                                                 uint32 memorySize,\r
 123                                                                 const Dcm_DspMemoryIdInfo **MemoryPtr);\r
 124 \r
 125 static boolean LookupDDD(uint16 didNr, const Dcm_DspDDDType **DDid);\r
 126 \r
 127 static boolean checkWriteMemoryByAddress(boolean useId,\r
 128                                                  uint32 memoryAddress,\r
 129                                                                                  uint8 memoryAddressFormat,\r
 130                                                                                  uint32 memorySize,\r
 131                                                                                  const Dcm_DspMemoryIdInfo *dspMemory);\r
 132 \r
 133 \r
 134 /*\r
 135 *   end  \r
 136 */\r
 137 \r
 138 void DspInit(void)\r
 139 {\r
 140         dspUdsSecurityAccesData.reqInProgress = FALSE;\r
 141         dspUdsEcuResetData.resetPending = FALSE;\r
 142 \r
 143         dspWritePending = FALSE;\r
 144         dspMemoryState=DCM_MEMORY_UNUSED;\r
 145         /* clear periodic send buffer */\r
 146         memset(&dspPDidRef,0,sizeof(dspPDidRef));\r
 147         /* clear dynamically Did buffer */\r
 148         memset(&dspDDD[0],0,sizeof(dspDDD)); \r
 149 }\r
 150 \r
 151 void DspMemoryMainFunction(void)\r
 152 {\r
 153         Dcm_ReturnWriteMemoryType WriteRet;\r
 154         Dcm_ReturnReadMemoryType ReadRet;\r
 155         switch(dspMemoryState)\r
 156         {\r
 157                 case DCM_MEMORY_UNUSED:\r
 158                         break;\r
 159                 case DCM_MEMORY_READ:\r
 160                         ReadRet = Dcm_ReadMemory(DCM_PENDING,0,0,0,0);\r
 161                         if(ReadRet == DCM_READ_OK)/*asynchronous writing is ok*/\r
 162                         {\r
 163                                 DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
 164                                 dspMemoryState = DCM_MEMORY_UNUSED;\r
 165                         }\r
 166                         if(ReadRet == DCM_READ_FAILED)\r
 167                         {\r
 168                                 dspMemoryState = DCM_MEMORY_FAILED;\r
 169                         }\r
 170                         break;\r
 171                 case DCM_MEMORY_WRITE:\r
 172                         WriteRet = Dcm_WriteMemory(DCM_PENDING,0,0,0,0);\r
 173                         if(WriteRet == DCM_WRITE_OK)/*asynchronous writing is ok*/\r
 174                         {\r
 175                                 DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
 176                                 dspMemoryState = DCM_MEMORY_UNUSED;\r
 177                         }\r
 178                         if(WriteRet == DCM_WRITE_FAILED)\r
 179                         {\r
 180                                 dspMemoryState = DCM_MEMORY_FAILED;\r
 181                         }\r
 182                         break;\r
 183                 case DCM_MEMORY_FAILED:\r
 184                         DsdDspProcessingDone(DCM_E_GENERALPROGRAMMINGFAILURE);\r
 185                         dspMemoryState = DCM_MEMORY_UNUSED;\r
 186                         break;\r
 187                         \r
 188         }\r
 189 }\r
 190 void DspPeriodicDIDMainFunction()\r
 191 {\r
 192         uint8 i;\r
 193         boolean sentResponseThisLoop = FALSE;\r
 194 \r
 195         for(i = 0;i < dspPDidRef.PDidNr; i++)\r
 196         {\r
 197                 if(dspPDidRef.dspPDid[i].PDidTxCounterNumber > dspPDidRef.dspPDid[i].PDidTxCounter)\r
 198                 {\r
 199                         dspPDidRef.dspPDid[i].PDidTxCounter++;\r
 200                 }\r
 201                 else\r
 202                 {\r
 203                         if( sentResponseThisLoop  == FALSE ) {\r
 204                                 dspPDidRef.dspPDid[i].PDidTxCounter = 0;\r
 205                                 /*AutoSar  DCM  8.10.5 */\r
 206                                 DslInternal_ResponseOnOneDataByPeriodicId(dspPDidRef.dspPDid[i].PeriodicDid);\r
 207                                 sentResponseThisLoop = TRUE;\r
 208                         }\r
 209                         else {\r
 210                                 /* Don't do anything - PDid will be sent next loop */\r
 211                         }\r
 212                 }       \r
 213         }\r
 214 }\r
 215 void DspMain(void)\r
 216 {\r
 217         DspMemoryMainFunction();\r
 218         DspPeriodicDIDMainFunction();\r
 219 }\r
 220 \r
 221 \r
 222 boolean DspCheckSessionLevel(Dcm_DspSessionRowType const* const* sessionLevelRefTable)\r
 223 {\r
 224         Std_ReturnType returnStatus;\r
 225         boolean levelFound = FALSE;\r
 226         Dcm_SesCtrlType currentSession;\r
 227 \r
 228         returnStatus = DslGetSesCtrlType(&currentSession);\r
 229         if (returnStatus == E_OK) {\r
 230                 while ( ((*sessionLevelRefTable)->DspSessionLevel != currentSession) && (!(*sessionLevelRefTable)->Arc_EOL) ) {\r
 231                         sessionLevelRefTable++;\r
 232                 }\r
 233 \r
 234                 if (!(*sessionLevelRefTable)->Arc_EOL) {\r
 235                         levelFound = TRUE;\r
 236                 }\r
 237         }\r
 238 \r
 239         return levelFound;\r
 240 }\r
 241 \r
 242 \r
 243 boolean DspCheckSecurityLevel(Dcm_DspSecurityRowType const* const* securityLevelRefTable)\r
 244 {\r
 245         Std_ReturnType returnStatus;\r
 246         boolean levelFound = FALSE;\r
 247         Dcm_SecLevelType currentSecurityLevel;\r
 248 \r
 249         returnStatus = DslGetSecurityLevel(&currentSecurityLevel);\r
 250         if (returnStatus == E_OK) {\r
 251                 while ( ((*securityLevelRefTable)->DspSecurityLevel != currentSecurityLevel) && (!(*securityLevelRefTable)->Arc_EOL) ) {\r
 252                         securityLevelRefTable++;\r
 253                 }\r
 254                 if (!(*securityLevelRefTable)->Arc_EOL) {\r
 255                         levelFound = TRUE;\r
 256                 }\r
 257         }\r
 258 \r
 259         return levelFound;\r
 260 }\r
 261 \r
 262 \r
 263 static Std_ReturnType askApplicationForSessionPermission(Dcm_SesCtrlType newSessionLevel)\r
 264 {\r
 265         Std_ReturnType returnCode = E_OK;\r
 266         const Dcm_DslSessionControlType *sesControl = DCM_Config.Dsl->DslSessionControl;\r
 267         Dcm_SesCtrlType currentSessionLevel;\r
 268         Std_ReturnType result;\r
 269 \r
 270         while ( (!sesControl->Arc_EOL) && (returnCode != E_SESSION_NOT_ALLOWED)) {\r
 271                 if (sesControl->GetSesChgPermission != NULL) {\r
 272                         result = Dcm_GetSesCtrlType(&currentSessionLevel);\r
 273                         if (result == E_OK) {\r
 274                                 result = sesControl->GetSesChgPermission(currentSessionLevel ,newSessionLevel);\r
 275                                 if (result != E_OK) {\r
 276                                         returnCode = result;\r
 277                                 }\r
 278                         } else {\r
 279                                 returnCode = E_NOT_OK;\r
 280                         }\r
 281                 }\r
 282                 sesControl++;\r
 283         }\r
 284 \r
 285         return returnCode;\r
 286 }\r
 287 \r
 288 \r
 289 void DspUdsDiagnosticSessionControl(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 290 {\r
 291         /** @req DCM250 */\r
 292         const Dcm_DspSessionRowType *sessionRow = DCM_Config.Dsp->DspSession->DspSessionRow;\r
 293         Dcm_SesCtrlType reqSessionType;\r
 294         Std_ReturnType result;\r
 295 \r
 296         if (pduRxData->SduLength == 2) {\r
 297                 reqSessionType = pduRxData->SduDataPtr[1];\r
 298                 // Check if type exist in session table\r
 299                 while ((sessionRow->DspSessionLevel != reqSessionType) && (!sessionRow->Arc_EOL) ) {\r
 300                         sessionRow++;\r
 301                 }\r
 302 \r
 303                 if (!sessionRow->Arc_EOL) {\r
 304                         result = askApplicationForSessionPermission(reqSessionType);\r
 305                         if (result == E_OK) {\r
 306                                 DslSetSesCtrlType(reqSessionType);              /** @req DCM311 */\r
 307                                 // Create positive response\r
 308                                 pduTxData->SduDataPtr[1] = reqSessionType;\r
 309                                 pduTxData->SduLength = 2;\r
 310                                 DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
 311                         }\r
 312                         else {\r
 313                                 // TODO: Add handling of special case of E_FORCE_RCRRP (Dcm138)\r
 314                                 DsdDspProcessingDone(DCM_E_CONDITIONSNOTCORRECT);       /** @req DCM308 */\r
 315                         }\r
 316                 }\r
 317                 else {\r
 318                         DsdDspProcessingDone(DCM_E_SUBFUNCTIONNOTSUPPORTED);    /** @req DCM307 */\r
 319                 }\r
 320         }\r
 321         else {\r
 322                 // Wrong length\r
 323                 DsdDspProcessingDone(DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT);\r
 324         }\r
 325 }\r
 326 \r
 327 \r
 328 void DspUdsEcuReset(const PduInfoType *pduRxData, PduIdType txPduId, PduInfoType *pduTxData)\r
 329 {\r
 330         /** @req DCM260 */\r
 331         uint8 reqResetType;\r
 332 \r
 333         if (pduRxData->SduLength == 2) {\r
 334                 reqResetType = pduRxData->SduDataPtr[1];\r
 335 \r
 336                 switch (reqResetType)\r
 337                 {\r
 338                 case 0x01:      // Hard reset\r
 339                         // TODO: Ask application for permission (Dcm373) (Dcm375) (Dcm377)\r
 340 \r
 341                         // Schedule the reset\r
 342                         dspUdsEcuResetData.resetPending = TRUE;\r
 343                         dspUdsEcuResetData.resetPduId = txPduId;\r
 344 \r
 345                         // Create positive response\r
 346                         pduTxData->SduDataPtr[1] = reqResetType;\r
 347                         pduTxData->SduLength = 2;\r
 348                         DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
 349                         break;\r
 350 \r
 351                 default:\r
 352                         DsdDspProcessingDone(DCM_E_SUBFUNCTIONNOTSUPPORTED);\r
 353                         break;\r
 354                 }\r
 355         }\r
 356         else {\r
 357                 // Wrong length\r
 358                 DsdDspProcessingDone(DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT);\r
 359         }\r
 360 }\r
 361 \r
 362 \r
 363 void DspUdsClearDiagnosticInformation(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 364 {\r
 365         /** @req DCM247 */\r
 366         uint32 dtc;\r
 367         Dem_ReturnClearDTCType result;\r
 368 \r
 369         if (pduRxData->SduLength == 4) {\r
 370                 dtc = BYTES_TO_DTC(pduRxData->SduDataPtr[1], pduRxData->SduDataPtr[2], pduRxData->SduDataPtr[3]);\r
 371 \r
 372                 result = Dem_ClearDTC(dtc, DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY); /** @req DCM005 */\r
 373 \r
 374                 switch (result)\r
 375                 {\r
 376                 case DEM_CLEAR_OK:\r
 377                         // Create positive response\r
 378                         pduTxData->SduLength = 1;\r
 379                         DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
 380                         break;\r
 381 \r
 382                 default:\r
 383                         DsdDspProcessingDone(DCM_E_REQUESTOUTOFRANGE);\r
 384                         break;\r
 385                 }\r
 386         }\r
 387         else {\r
 388                 // Wrong length\r
 389                 DsdDspProcessingDone(DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT);\r
 390         }\r
 391 }\r
 392 \r
 393 \r
 394 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x01_0x07_0x11_0x12(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 395 {\r
 396         typedef struct {\r
 397                 uint8           SID;\r
 398                 uint8           reportType;\r
 399                 uint8           dtcStatusAvailabilityMask;\r
 400                 uint8           dtcFormatIdentifier;\r
 401                 uint8           dtcCountHighByte;\r
 402                 uint8           dtcCountLowByte;\r
 403         } TxDataType;\r
 404 \r
 405         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 406         Dem_ReturnSetDTCFilterType setDtcFilterResult;\r
 407 \r
 408         // Setup the DTC filter\r
 409         switch (pduRxData->SduDataPtr[1])       /** @req DCM293 */\r
 410         {\r
 411         case 0x01:      // reportNumberOfDTCByStatusMask\r
 412                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 413                 break;\r
 414 \r
 415         case 0x07:      // reportNumberOfDTCBySeverityMaskRecord\r
 416                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[3], DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_YES, pduRxData->SduDataPtr[2], DEM_FILTER_FOR_FDC_NO);\r
 417                 break;\r
 418 \r
 419         case 0x11:      // reportNumberOfMirrorMemoryDTCByStatusMask\r
 420                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_MIRROR_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 421                 break;\r
 422 \r
 423         case 0x12:      // reportNumberOfEmissionRelatedOBDDTCByStatusMask\r
 424                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_EMISSION_REL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 425                 break;\r
 426 \r
 427         default:\r
 428                 setDtcFilterResult = DEM_WRONG_FILTER;\r
 429                 break;\r
 430         }\r
 431 \r
 432         if (setDtcFilterResult == DEM_FILTER_ACCEPTED) {\r
 433                 Std_ReturnType result;\r
 434                 Dem_ReturnGetNumberOfFilteredDTCType getNumerResult;\r
 435                 uint16 numberOfFilteredDtc;\r
 436                 uint8 dtcStatusMask;\r
 437                 //lint --e(826) PC-Lint exception - Suspicious pointer conversion\r
 438                 //lint --e(927) PC-Lint exception - Pointer to pointer cast\r
 439                 TxDataType *txData = (TxDataType*)pduTxData->SduDataPtr;\r
 440 \r
 441                 /** @req DCM376 */\r
 442                 getNumerResult = Dem_GetNumberOfFilteredDtc(&numberOfFilteredDtc);\r
 443                 if (getNumerResult == DEM_NUMBER_OK) {\r
 444                         result = Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
 445                         if (result != E_OK) {\r
 446                                 dtcStatusMask = 0;\r
 447                         }\r
 448 \r
 449                         // Create positive response (ISO 14229-1 table 251)\r
 450                         txData->reportType = pduRxData->SduDataPtr[1];                                          // reportType\r
 451                         txData->dtcStatusAvailabilityMask = dtcStatusMask;                                      // DTCStatusAvailabilityMask\r
 452                         txData->dtcFormatIdentifier = Dem_GetTranslationType();                         // DTCFormatIdentifier\r
 453                         txData->dtcCountHighByte = (numberOfFilteredDtc >> 8);                          // DTCCount high byte\r
 454                         txData->dtcCountLowByte = (numberOfFilteredDtc & 0xFFu);                        // DTCCount low byte\r
 455                         pduTxData->SduLength = 6;\r
 456                 } else {\r
 457                         // TODO: What to do?\r
 458                         responseCode = DCM_E_GENERALREJECT;\r
 459                 }\r
 460         }\r
 461         else {\r
 462                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 463         }\r
 464 \r
 465         return responseCode;\r
 466 }\r
 467 \r
 468 \r
 469 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x02_0x0A_0x0F_0x13_0x15(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 470 {\r
 471         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 472         Dem_ReturnSetDTCFilterType setDtcFilterResult;\r
 473 \r
 474         typedef struct {\r
 475                 uint8           dtcHighByte;\r
 476                 uint8           dtcMiddleByte;\r
 477                 uint8           dtcLowByte;\r
 478                 uint8           statusOfDtc;\r
 479         } dtcAndStatusRecordType;\r
 480 \r
 481         typedef struct {\r
 482                 uint8                                   SID;\r
 483                 uint8                                   reportType;\r
 484                 uint8                                   dtcStatusAvailabilityMask;\r
 485                 dtcAndStatusRecordType  dtcAndStatusRecord[];\r
 486         } TxDataType;\r
 487 \r
 488         // Setup the DTC filter\r
 489         switch (pduRxData->SduDataPtr[1])       /** @req DCM378 */\r
 490         {\r
 491         case 0x02:      // reportDTCByStatusMask\r
 492                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 493                 break;\r
 494 \r
 495         case 0x0A:      // reportSupportedDTC\r
 496                 setDtcFilterResult = Dem_SetDTCFilter(DEM_DTC_STATUS_MASK_ALL, DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 497                 break;\r
 498 \r
 499         case 0x0F:      // reportMirrorMemoryDTCByStatusMask\r
 500                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_MIRROR_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 501                 break;\r
 502 \r
 503         case 0x13:      // reportEmissionRelatedOBDDTCByStatusMask\r
 504                 setDtcFilterResult = Dem_SetDTCFilter(pduRxData->SduDataPtr[2], DEM_DTC_KIND_EMISSION_REL_DTCS, DEM_DTC_ORIGIN_PRIMARY_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 505                 break;\r
 506 \r
 507         case 0x15:      // reportDTCWithPermanentStatus\r
 508                 setDtcFilterResult = Dem_SetDTCFilter(DEM_DTC_STATUS_MASK_ALL, DEM_DTC_KIND_ALL_DTCS, DEM_DTC_ORIGIN_PERMANENT_MEMORY, DEM_FILTER_WITH_SEVERITY_NO, VALUE_IS_NOT_USED, DEM_FILTER_FOR_FDC_NO);\r
 509                 break;\r
 510 \r
 511         default:\r
 512                 setDtcFilterResult = DEM_WRONG_FILTER;\r
 513                 break;\r
 514         }\r
 515 \r
 516         if (setDtcFilterResult == DEM_FILTER_ACCEPTED) {\r
 517                 uint8 dtcStatusMask;\r
 518                 //lint --e(826) PC-Lint exception - Suspicious pointer conversion\r
 519                 //lint --e(927) PC-Lint exception - Pointer to pointer cast\r
 520                 TxDataType *txData = (TxDataType*)pduTxData->SduDataPtr;\r
 521                 Dem_ReturnGetNextFilteredDTCType getNextFilteredDtcResult;\r
 522                 uint32 dtc;\r
 523                 Dem_EventStatusExtendedType dtcStatus;\r
 524                 uint16 nrOfDtcs = 0;\r
 525                 Std_ReturnType result;\r
 526 \r
 527                 /** @req DCM377 */\r
 528                 result = Dem_GetDTCStatusAvailabilityMask(&dtcStatusMask);\r
 529                 if (result != E_OK) {\r
 530                         dtcStatusMask = 0;\r
 531                 }\r
 532 \r
 533                 // Create positive response (ISO 14229-1 table 252)\r
 534                 txData->reportType = pduRxData->SduDataPtr[1];\r
 535                 txData->dtcStatusAvailabilityMask = dtcStatusMask;\r
 536 \r
 537                 if (dtcStatusMask != 0x00) {    /** @req DCM008 */\r
 538                         getNextFilteredDtcResult = Dem_GetNextFilteredDTC(&dtc, &dtcStatus);\r
 539                         while (getNextFilteredDtcResult == DEM_FILTERED_OK) {\r
 540                                 txData->dtcAndStatusRecord[nrOfDtcs].dtcHighByte = DTC_HIGH_BYTE(dtc);\r
 541                                 txData->dtcAndStatusRecord[nrOfDtcs].dtcMiddleByte = DTC_MID_BYTE(dtc);\r
 542                                 txData->dtcAndStatusRecord[nrOfDtcs].dtcLowByte = DTC_LOW_BYTE(dtc);\r
 543                                 txData->dtcAndStatusRecord[nrOfDtcs].statusOfDtc = dtcStatus;\r
 544                                 nrOfDtcs++;\r
 545                                 getNextFilteredDtcResult = Dem_GetNextFilteredDTC(&dtc, &dtcStatus);\r
 546                         }\r
 547 \r
 548                         if (getNextFilteredDtcResult != DEM_FILTERED_NO_MATCHING_DTC) {\r
 549                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 550                         }\r
 551                 }\r
 552                 pduTxData->SduLength = (PduLengthType)(3 + (nrOfDtcs * sizeof(dtcAndStatusRecordType)));\r
 553         }\r
 554         else {\r
 555                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 556         }\r
 557 \r
 558         return responseCode;\r
 559 }\r
 560 \r
 561 // PC-Lint (715 etc): Remove errors until function is filled.\r
 562 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 563 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x08(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 564 {\r
 565         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 566 \r
 567         // TODO: Not supported yet, (DEM module does not currently support severity).\r
 568         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 569 \r
 570         return responseCode;\r
 571 }\r
 572 \r
 573 \r
 574 // PC-Lint (715 etc): Remove errors until function is filled.\r
 575 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 576 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x09(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 577 {\r
 578         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 579 \r
 580         // TODO: Not supported yet, (DEM module does not currently support severity).\r
 581         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 582 \r
 583         return responseCode;\r
 584 }\r
 585 \r
 586 \r
 587 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x06_0x10(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 588 {\r
 589         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 590         Dem_DTCOriginType dtcOrigin;\r
 591         uint8 startRecNum;\r
 592         uint8 endRecNum;\r
 593 \r
 594         // Switch on sub function\r
 595         switch (pduRxData->SduDataPtr[1])       /** @req DCM378 */\r
 596         {\r
 597         case 0x06:      // reportDTCExtendedDataRecordByDTCNumber\r
 598                 dtcOrigin = DEM_DTC_ORIGIN_PRIMARY_MEMORY;\r
 599                 break;\r
 600 \r
 601         case 0x10:      // reportMirrorMemoryDTCExtendedDataRecordByDTCNumber\r
 602                 dtcOrigin = DEM_DTC_ORIGIN_MIRROR_MEMORY;\r
 603                 break;\r
 604 \r
 605         default:\r
 606                 responseCode = DCM_E_SUBFUNCTIONNOTSUPPORTED;\r
 607                 dtcOrigin = 0;\r
 608                 break;\r
 609         }\r
 610 \r
 611         // Switch on record number\r
 612         switch (pduRxData->SduDataPtr[5])\r
 613         {\r
 614         case 0xFF:      // Report all Extended Data Records for a particular DTC\r
 615                 startRecNum = 0x00;\r
 616                 endRecNum = 0xEF;\r
 617                 break;\r
 618 \r
 619         case 0xFE:      // Report all OBD Extended Data Records for a particular DTC\r
 620                 startRecNum = 0x90;\r
 621                 endRecNum = 0xEF;\r
 622                 break;\r
 623 \r
 624         default:        // Report one specific Extended Data Records for a particular DTC\r
 625                 startRecNum = pduRxData->SduDataPtr[5];\r
 626                 endRecNum = startRecNum;\r
 627                 break;\r
 628         }\r
 629 \r
 630         if (responseCode == DCM_E_POSITIVERESPONSE) {\r
 631                 Dem_ReturnGetStatusOfDTCType getStatusOfDtcResult;\r
 632                 uint32 dtc;\r
 633                 Dem_EventStatusExtendedType statusOfDtc;\r
 634 \r
 635                 dtc = BYTES_TO_DTC(pduRxData->SduDataPtr[2], pduRxData->SduDataPtr[3], pduRxData->SduDataPtr[4]);\r
 636                 getStatusOfDtcResult = Dem_GetStatusOfDTC(dtc, DEM_DTC_KIND_ALL_DTCS, dtcOrigin, &statusOfDtc); /** @req DCM295 */ /** @req DCM475 */\r
 637                 if (getStatusOfDtcResult == DEM_STATUS_OK) {\r
 638                         Dem_ReturnGetExtendedDataRecordByDTCType getExtendedDataRecordByDtcResult;\r
 639                         uint8 recNum;\r
 640                         uint16 recLength;\r
 641                         uint16 txIndex = 6;\r
 642 \r
 643                         /** @req DCM297 */ /** @req DCM474 */ /** @req DCM386 */\r
 644                         pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];                    // Sub function\r
 645                         pduTxData->SduDataPtr[2] = DTC_HIGH_BYTE(dtc);                                  // DTC high byte\r
 646                         pduTxData->SduDataPtr[3] = DTC_MID_BYTE(dtc);                                   // DTC mid byte\r
 647                         pduTxData->SduDataPtr[4] = DTC_LOW_BYTE(dtc);                                   // DTC low byte\r
 648                         pduTxData->SduDataPtr[5] = statusOfDtc;                                                 // DTC status\r
 649                         for (recNum = startRecNum; recNum <= endRecNum; recNum++) {\r
 650                                 recLength = pduTxData->SduLength - (txIndex + 1);       // Calculate what's left in buffer\r
 651                                 /** @req DCM296 */ /** @req DCM476 */ /** @req DCM382 */\r
 652                                 getExtendedDataRecordByDtcResult = Dem_GetExtendedDataRecordByDTC(dtc, DEM_DTC_KIND_ALL_DTCS, dtcOrigin, recNum, &pduTxData->SduDataPtr[txIndex+1], &recLength);\r
 653                                 if (getExtendedDataRecordByDtcResult == DEM_RECORD_OK) {\r
 654                                         pduTxData->SduDataPtr[txIndex++] = recNum;\r
 655                                         /* Instead of calling Dem_GetSizeOfExtendedDataRecordByDTC() the result from Dem_GetExtendedDataRecordByDTC() is used */\r
 656                                         /** @req DCM478 */ /** @req DCM479 */ /** @req DCM480 */\r
 657                                         txIndex += recLength;\r
 658                                 }\r
 659                                 else {\r
 660                                         // TODO: What to do here?\r
 661                                 }\r
 662                         }\r
 663                         pduTxData->SduLength = txIndex;\r
 664                 }\r
 665                 else {\r
 666                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 667                 }\r
 668         }\r
 669 \r
 670         return responseCode;\r
 671 }\r
 672 \r
 673 \r
 674 // PC-Lint (715 etc): Remove errors until function is filled.\r
 675 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 676 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x03(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 677 {\r
 678         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 679 \r
 680         // TODO: Not supported yet\r
 681         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 682 \r
 683         return responseCode;\r
 684 }\r
 685 \r
 686 \r
 687 // PC-Lint (715 etc): Remove errors until function is filled.\r
 688 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 689 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x04(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 690 {\r
 691         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 692 \r
 693         // TODO: Not supported yet\r
 694         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 695 \r
 696         return responseCode;\r
 697 }\r
 698 \r
 699 \r
 700 // PC-Lint (715 etc): Remove errors until function is filled.\r
 701 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 702 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x05(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 703 {\r
 704         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 705 \r
 706         // TODO: Not supported yet\r
 707         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 708 \r
 709         return responseCode;\r
 710 }\r
 711 \r
 712 \r
 713 // PC-Lint (715 etc): Remove errors until function is filled.\r
 714 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 715 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x0B_0x0C_0x0D_0x0E(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 716 {\r
 717         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 718 \r
 719         // TODO: Not supported yet\r
 720         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 721 \r
 722         return responseCode;\r
 723 }\r
 724 \r
 725 \r
 726 // PC-Lint (715 etc): Remove errors until function is filled.\r
 727 //lint -e{715, 838, 818}                Symbol not referenced, responseCode not used, txData should be const\r
 728 static Dcm_NegativeResponseCodeType udsReadDtcInfoSub_0x14(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 729 {\r
 730         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 731 \r
 732         // TODO: Not supported yet\r
 733         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 734 \r
 735         return responseCode;\r
 736 }\r
 737 \r
 738 \r
 739 void DspUdsReadDtcInformation(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
 740 {\r
 741         /** @req DCM248 */\r
 742         // Sub function number         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F 10 11 12 13 14 15\r
 743         const uint8 sduLength[0x16] = {0, 3, 3, 6, 6, 3, 6, 4, 4, 5, 2, 2, 2, 2, 2, 3, 6, 3, 3, 3, 2, 2};\r
 744 \r
 745         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 746 \r
 747         uint8 subFunctionNumber = pduRxData->SduDataPtr[1];\r
 748 \r
 749         // Check length\r
 750         if (subFunctionNumber <= 0x15) {\r
 751                 if (pduRxData->SduLength == sduLength[subFunctionNumber]) {\r
 752                         switch (subFunctionNumber)\r
 753                         {\r
 754                         case 0x01:      // reportNumberOfDTCByStatusMask\r
 755                         case 0x07:      // reportNumberOfDTCBySeverityMaskRecord\r
 756                         case 0x11:      // reportNumberOfMirrorMemoryDTCByStatusMask\r
 757                         case 0x12:      // reportNumberOfEmissionRelatedOBDDTCByStatusMask\r
 758                                 responseCode = udsReadDtcInfoSub_0x01_0x07_0x11_0x12(pduRxData, pduTxData);\r
 759                                 break;\r
 760 \r
 761                         case 0x02:      // reportDTCByStatusMask\r
 762                         case 0x0A:      // reportSupportedDTC\r
 763                         case 0x0F:      // reportMirrorMemoryDTCByStatusMask\r
 764                         case 0x13:      // reportEmissionRelatedOBDDTCByStatusMask\r
 765                         case 0x15:      // reportDTCWithPermanentStatus\r
 766                                 responseCode = udsReadDtcInfoSub_0x02_0x0A_0x0F_0x13_0x15(pduRxData, pduTxData);\r
 767                                 break;\r
 768 \r
 769                         case 0x08:      // reportDTCBySeverityMaskRecord\r
 770                                 responseCode = udsReadDtcInfoSub_0x08(pduRxData, pduTxData);\r
 771                                 break;\r
 772 \r
 773                         case 0x09:      // reportSeverityInformationOfDTC\r
 774                                 responseCode = udsReadDtcInfoSub_0x09(pduRxData, pduTxData);\r
 775                                 break;\r
 776 \r
 777                         case 0x06:      // reportDTCExtendedDataRecordByDTCNumber\r
 778                         case 0x10:      // reportMirrorMemoryDTCExtendedDataRecordByDTCNumber\r
 779                                 responseCode = udsReadDtcInfoSub_0x06_0x10(pduRxData, pduTxData);\r
 780                                 break;\r
 781 \r
 782                         case 0x03:      // reportDTCSnapshotIdentidication\r
 783                                 responseCode = udsReadDtcInfoSub_0x03(pduRxData, pduTxData);\r
 784                                 break;\r
 785 \r
 786                         case 0x04:      // reportDTCSnapshotByDtcNumber\r
 787                                 responseCode = udsReadDtcInfoSub_0x04(pduRxData, pduTxData);\r
 788                                 break;\r
 789 \r
 790                         case 0x05:      // reportDTCSnapshotRecordNumber\r
 791                                 responseCode = udsReadDtcInfoSub_0x05(pduRxData, pduTxData);\r
 792                                 break;\r
 793 \r
 794                         case 0x0B:      // reportFirstTestFailedDTC\r
 795                         case 0x0C:      // reportFirstConfirmedDTC\r
 796                         case 0x0D:      // reportMostRecentTestFailedDTC\r
 797                         case 0x0E:      // reportMostRecentConfirmedDTC\r
 798                                 responseCode = udsReadDtcInfoSub_0x0B_0x0C_0x0D_0x0E(pduRxData, pduTxData);\r
 799                                 break;\r
 800 \r
 801                         case 0x14:      // reportDTCFaultDetectionCounter\r
 802                                 responseCode = udsReadDtcInfoSub_0x14(pduRxData, pduTxData);\r
 803                                 break;\r
 804 \r
 805                         default:\r
 806                                 // Unknown sub function\r
 807                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 808                                 break;\r
 809                         }\r
 810                 }\r
 811                 else {\r
 812                         // Wrong length\r
 813                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
 814                 }\r
 815         }\r
 816         else {\r
 817                 // Sub function out of range\r
 818                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 819         }\r
 820 \r
 821         DsdDspProcessingDone(responseCode);\r
 822 }\r
 823 /**\r
 824 **              This Function for check the pointer of Dynamically Did Sourced by Did buffer using a didNr\r
 825 **/\r
 826 static boolean LookupDDD(uint16 didNr,  const Dcm_DspDDDType **DDid )   \r
 827 {\r
 828         uint8 i;\r
 829         boolean ret = FALSE;\r
 830         const Dcm_DspDDDType* DDidptr = &dspDDD[0];\r
 831         \r
 832         for(i = 0;((i < DCM_MAX_DDD_NUMBER) && (ret == FALSE)); i++)\r
 833         {\r
 834                 if(DDidptr->DynamicallyDid == didNr)\r
 835                 {\r
 836                         ret = TRUE;\r
 837                 \r
 838                 }\r
 839                 else\r
 840                 {\r
 841                         DDidptr++;\r
 842                 }\r
 843         }\r
 844         if(ret == TRUE)\r
 845         {\r
 846                 *DDid = DDidptr;\r
 847         }\r
 848 \r
 849         return ret;\r
 850 }\r
 851 \r
 852 static boolean lookupDid(uint16 didNr, const Dcm_DspDidType **didPtr)\r
 853 {\r
 854         const Dcm_DspDidType *dspDid = DCM_Config.Dsp->DspDid;\r
 855         boolean didFound = FALSE;\r
 856 \r
 857         while ((dspDid->DspDidIdentifier != didNr) &&  (!dspDid->Arc_EOL)) {\r
 858                 dspDid++;\r
 859         }\r
 860 \r
 861         if (!dspDid->Arc_EOL) {\r
 862                 didFound = TRUE;\r
 863                 *didPtr = dspDid;\r
 864         }\r
 865 \r
 866         return didFound;\r
 867 }\r
 868 \r
 869 \r
 870 static Dcm_NegativeResponseCodeType readDidData(const Dcm_DspDidType *didPtr, PduInfoType *pduTxData, uint16 *txPos)\r
 871 {\r
 872         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 873 \r
 874         if ((didPtr->DspDidInfoRef->DspDidAccess.DspDidRead != NULL) && (didPtr->DspDidConditionCheckReadFnc != NULL) && (didPtr->DspDidReadDataFnc != NULL)) { /** @req DCM433 */\r
 875                 if (DspCheckSessionLevel(didPtr->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSessionRef)) { /** @req DCM434 */\r
 876                         if (DspCheckSecurityLevel(didPtr->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSecurityLevelRef)) { /** @req DCM435 */\r
 877                                 Std_ReturnType result;\r
 878                                 Dcm_NegativeResponseCodeType errorCode;\r
 879                                 result = didPtr->DspDidConditionCheckReadFnc(&errorCode);\r
 880                                 if ((result == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {        /** @req DCM439 */\r
 881                                         uint16 didLen = 0;\r
 882                                         result = E_NOT_OK;\r
 883                                         if (didPtr->DspDidInfoRef->DspDidFixedLength) { /** @req DCM436 */\r
 884                                                 didLen = didPtr->DspDidSize;\r
 885                                                 result = E_OK;\r
 886                                         }\r
 887                                         else {\r
 888                                                 if (didPtr->DspDidReadDataLengthFnc != NULL) {\r
 889                                                         result = didPtr->DspDidReadDataLengthFnc(&didLen);\r
 890                                                 }\r
 891                                         }\r
 892 \r
 893                                         if (result == E_OK) {\r
 894                                                 // Now ready for reading the data!\r
 895                                                 if ((*txPos + didLen + 2) <= pduTxData->SduLength) {\r
 896                                                         pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFFu;\r
 897                                                         (*txPos)++;\r
 898                                                         pduTxData->SduDataPtr[*txPos] = didPtr->DspDidIdentifier & 0xFFu;\r
 899                                                         (*txPos)++;\r
 900                                                         result = didPtr->DspDidReadDataFnc(&pduTxData->SduDataPtr[*txPos]);     /** @req DCM437 */\r
 901                                                         *txPos += didLen;\r
 902 \r
 903                                                         if (result != E_OK) {\r
 904                                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
 905                                                         }\r
 906                                                 }\r
 907                                                 else { // tx buffer full\r
 908                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 909                                                 }\r
 910                                         }\r
 911                                         else {  // Not possible to obtain did length\r
 912                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
 913                                         }\r
 914                                 }\r
 915                                 else {  // CheckRead failed\r
 916                                         responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
 917                                 }\r
 918                         }\r
 919                         else {  // Not allowed in current security level\r
 920                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
 921                         }\r
 922                 }\r
 923                 else {  // Not allowed in current session\r
 924                         responseCode = DCM_E_SERVICENOTSUPPORTEDINACTIVESESSION;\r
 925                 }\r
 926         }\r
 927         else {  // Read access not configured\r
 928                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 929         }\r
 930 \r
 931         if (responseCode == DCM_E_POSITIVERESPONSE) {\r
 932                 // Recurse trough the rest of the dids.         /** @req DCM440 */\r
 933                 uint16 i;\r
 934                 for (i=0; (!didPtr->DspDidRef[i]->Arc_EOL) && (responseCode == DCM_E_POSITIVERESPONSE); i++) {\r
 935                         responseCode = readDidData(didPtr->DspDidRef[i], pduTxData, txPos);\r
 936                 }\r
 937         }\r
 938 \r
 939         return responseCode;\r
 940 }\r
 941 \r
 942 /**\r
 943 **              This Function for read Dynamically Did data buffer Sourced by Memory address using a didNr\r
 944 **/\r
 945 static Dcm_NegativeResponseCodeType readDDDData( Dcm_DspDDDType *PDidPtr, uint8 *Data,uint16 *Length)\r
 946 {\r
 947         uint8 i;\r
 948         uint8 dataCount;\r
 949         uint8 AddressFormat;\r
 950         uint16 SourceDataLength = 0;\r
 951         const Dcm_DspMemoryIdInfo *SourceMemoryInfoptr = NULL;\r
 952         const Dcm_DspDidType *SourceDidPtr = NULL;\r
 953         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
 954         *Length = 0;\r
 955 \r
 956         for(i = 0;(i < DCM_MAX_DDDSOURCE_NUMBER) && (PDidPtr->DDDSource[i].formatOrPosition != 0)\r
 957                 &&(responseCode == DCM_E_POSITIVERESPONSE);i++)\r
 958         {\r
 959                 if(PDidPtr->DDDSource[i].DDDTpyeID == DCM_DDD_SOURCE_ADDRESS)\r
 960                 {\r
 961 \r
 962                         AddressFormat = PDidPtr->DDDSource[i].formatOrPosition&DCM_FORMAT_HIGH_MASK >> 4;\r
 963                         if(TRUE == lookupReadMemory(PDidPtr->DDDSource[i].SourceAddressOrDid,AddressFormat,\r
 964                                 PDidPtr->DDDSource[i].Size, &SourceMemoryInfoptr))\r
 965                         {\r
 966                                 if(DspCheckSecurityLevel(SourceMemoryInfoptr->pReadMemoryInfo->pSecurityLevel) != TRUE)\r
 967                                 {\r
 968                                         responseCode = DCM_E_SECUTITYACCESSDENIED;\r
 969                                 }\r
 970                         }\r
 971                         else\r
 972                         {\r
 973                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
 974                         }\r
 975                         if(responseCode == DCM_E_POSITIVERESPONSE)\r
 976                         {\r
 977                                 Dcm_ReadMemory(DCM_INITIAL,SourceMemoryInfoptr->MemoryIdValue,\r
 978                                                                                 PDidPtr->DDDSource[i].SourceAddressOrDid,\r
 979                                                                                 PDidPtr->DDDSource[i].Size,\r
 980                                                                                 (Data + *Length));\r
 981                                 *Length = *Length + PDidPtr->DDDSource[i].Size;\r
 982                         }\r
 983                 }\r
 984                 else if(PDidPtr->DDDSource[i].DDDTpyeID == DCM_DDD_SOURCE_DID)\r
 985                 {\r
 986                         \r
 987                         if(lookupDid(PDidPtr->DDDSource[i].SourceAddressOrDid,&SourceDidPtr) == TRUE)\r
 988                         {\r
 989                                 if(DspCheckSecurityLevel(SourceDidPtr->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSecurityLevelRef) != TRUE)\r
 990                                 {\r
 991                                         responseCode = DCM_E_SECUTITYACCESSDENIED;\r
 992                                 }\r
 993                                 if(SourceDidPtr->DspDidInfoRef->DspDidFixedLength == TRUE)\r
 994                                 {\r
 995                                         SourceDataLength = SourceDidPtr->DspDidSize;\r
 996                                 }\r
 997                                 else\r
 998                                 {\r
 999                                         if(SourceDidPtr->DspDidReadDataLengthFnc != NULL)\r
1000                                         {\r
1001                                                 SourceDidPtr->DspDidReadDataLengthFnc(&SourceDataLength);\r
1002                                         }\r
1003                                 }\r
1004                                 if((SourceDidPtr->DspDidReadDataFnc != NULL) && (SourceDataLength != 0) && (DCM_E_POSITIVERESPONSE == responseCode))\r
1005                                 {\r
1006                                 \r
1007                                         SourceDidPtr->DspDidReadDataFnc((Data + *Length));\r
1008                                         for(dataCount = 0;dataCount < SourceDataLength;dataCount++)\r
1009                                         {\r
1010                                                 if(dataCount < PDidPtr->DDDSource[i].Size)\r
1011                                                 {\r
1012                                                         *(Data + *Length + dataCount) = *(Data + *Length + dataCount + PDidPtr->DDDSource[i].formatOrPosition - 1);\r
1013                                                 }\r
1014                                                 else\r
1015                                                 {\r
1016                                                         *(Data + *Length + dataCount) = 0;      \r
1017                                                 }\r
1018                                         }\r
1019                                         *Length = *Length + PDidPtr->DDDSource[i].Size;\r
1020                                 }\r
1021                                 else\r
1022                                 {\r
1023                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1024                                 }\r
1025                         }\r
1026                         else\r
1027                         {\r
1028                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1029                         }\r
1030                 }\r
1031                 else\r
1032                 {\r
1033                         \r
1034                         responseCode = DCM_E_REQUESTOUTOFRANGE; \r
1035                 }\r
1036         }\r
1037         return responseCode;\r
1038 }\r
1039 \r
1040 void DspUdsReadDataByIdentifier(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1041 {\r
1042         /** @req DCM253 */\r
1043         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1044         uint16 nrOfDids;\r
1045         uint16 didNr;\r
1046         const Dcm_DspDidType *didPtr = NULL;\r
1047         Dcm_DspDDDType *DDidPtr=NULL;\r
1048         uint16 txPos = 1;\r
1049         uint16 i;\r
1050         uint16 Length;\r
1051 \r
1052         if ( ((pduRxData->SduLength - 1) % 2) == 0 ) {\r
1053                 nrOfDids = (pduRxData->SduLength - 1) / 2;\r
1054 \r
1055                 for (i = 0; (i < nrOfDids) && (responseCode == DCM_E_POSITIVERESPONSE); i++) \r
1056                         {\r
1057                         didNr = (uint16)((uint16)pduRxData->SduDataPtr[1 + (i * 2)] << 8) + pduRxData->SduDataPtr[2 + (i * 2)];\r
1058                         if (lookupDid(didNr, &didPtr)) {        /** @req DCM438 */\r
1059                                 responseCode = readDidData(didPtr, pduTxData, &txPos);\r
1060                         }\r
1061 \r
1062                         else if(LookupDDD(didNr,(const Dcm_DspDDDType **)&DDidPtr) == TRUE)\r
1063                         {\r
1064                                 /*DCM 651,DCM 652*/\r
1065                                 pduTxData->SduDataPtr[txPos] = (DDidPtr->DynamicallyDid>>8) & 0xFF;\r
1066                                 txPos++;\r
1067                                 pduTxData->SduDataPtr[txPos] = (uint8)(DDidPtr->DynamicallyDid & 0xFF);\r
1068                                 txPos++;\r
1069                                 responseCode = readDDDData(DDidPtr,&(pduTxData->SduDataPtr[txPos]), &Length);\r
1070                                 txPos = txPos + Length;\r
1071                         }\r
1072 \r
1073                         else\r
1074                         { // DID not found\r
1075                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1076                         }\r
1077                 }\r
1078         }\r
1079         else {\r
1080                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1081         }\r
1082 \r
1083         if (responseCode == DCM_E_POSITIVERESPONSE) {\r
1084                 pduTxData->SduLength = txPos;\r
1085         }\r
1086 \r
1087         DsdDspProcessingDone(responseCode);\r
1088 }\r
1089 \r
1090 \r
1091 static Dcm_NegativeResponseCodeType readDidScalingData(const Dcm_DspDidType *didPtr, const PduInfoType *pduTxData, uint16 *txPos)\r
1092 {\r
1093         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1094 \r
1095         if (didPtr->DspDidGetScalingInfoFnc != NULL) {\r
1096                 uint16 scalingInfoLen;\r
1097 \r
1098                 scalingInfoLen = didPtr->DspDidInfoRef->DspDidScalingInfoSize;\r
1099                 if ((*txPos + scalingInfoLen + 2) <= pduTxData->SduLength) {\r
1100                         Std_ReturnType result;\r
1101                         Dcm_NegativeResponseCodeType errorCode;\r
1102 \r
1103                         pduTxData->SduDataPtr[*txPos] = (didPtr->DspDidIdentifier >> 8) & 0xFFu;\r
1104                         (*txPos)++;\r
1105                         pduTxData->SduDataPtr[*txPos] = didPtr->DspDidIdentifier & 0xFFu;\r
1106                         (*txPos)++;\r
1107                         result = didPtr->DspDidGetScalingInfoFnc(&pduTxData->SduDataPtr[*txPos], &errorCode);   /** @req DCM394 */\r
1108                         *txPos += scalingInfoLen;\r
1109 \r
1110                         if ((result != E_OK) || (errorCode != DCM_E_POSITIVERESPONSE)) {\r
1111                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1112                         }\r
1113                 }\r
1114                 else { // tx buffer full\r
1115                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1116                 }\r
1117         }\r
1118         else {  // DspDidGetScalingInfoFnc null pointer\r
1119                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1120         }\r
1121 \r
1122         return responseCode;\r
1123 }\r
1124 \r
1125 void DspUdsReadScalingDataByIdentifier(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1126 {\r
1127         /** @req DCM258 */\r
1128         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1129         uint16 didNr;\r
1130         const Dcm_DspDidType *didPtr = NULL;\r
1131 \r
1132         uint16 txPos = 1;\r
1133 \r
1134         if (pduRxData->SduLength == 3) {\r
1135                 didNr = (uint16)((uint16)pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
1136                 if (lookupDid(didNr, &didPtr)) {\r
1137                         responseCode = readDidScalingData(didPtr, pduTxData, &txPos);\r
1138                 }\r
1139                 else { // DID not found\r
1140                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1141                 }\r
1142 \r
1143                 if (responseCode == DCM_E_POSITIVERESPONSE) {\r
1144                         pduTxData->SduLength = txPos;\r
1145                 }\r
1146         }\r
1147         else {\r
1148                 // Length not ok\r
1149                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1150         }\r
1151 \r
1152         DsdDspProcessingDone(responseCode);\r
1153 }\r
1154 \r
1155 \r
1156 static Dcm_NegativeResponseCodeType writeDidData(const Dcm_DspDidType *didPtr, const PduInfoType *pduRxData, uint16 writeDidLen)\r
1157 {\r
1158         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1159 \r
1160         if ((didPtr->DspDidInfoRef->DspDidAccess.DspDidWrite != NULL) && (didPtr->DspDidConditionCheckWriteFnc != NULL) && (didPtr->DspDidWriteDataFnc != NULL)) {      /** @req DCM468 */\r
1161                 if (DspCheckSessionLevel(didPtr->DspDidInfoRef->DspDidAccess.DspDidWrite->DspDidWriteSessionRef)) { /** @req DCM469 */\r
1162                         if (DspCheckSecurityLevel(didPtr->DspDidInfoRef->DspDidAccess.DspDidWrite->DspDidWriteSecurityLevelRef)) { /** @req DCM470 */\r
1163                                 Std_ReturnType result;\r
1164                                 Dcm_NegativeResponseCodeType errorCode;\r
1165                                 result = didPtr->DspDidConditionCheckWriteFnc(&errorCode);      /** @req DCM471 */\r
1166                                 if ((result == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {\r
1167                                         uint16 didLen = 0;\r
1168                                         result = E_NOT_OK;\r
1169                                         if (didPtr->DspDidInfoRef->DspDidFixedLength) { /** @req DCM472 */\r
1170                                                 didLen = didPtr->DspDidSize;\r
1171                                                 result = E_OK;\r
1172                                         }\r
1173                                         else {\r
1174                                                 if (didPtr->DspDidReadDataLengthFnc != NULL) {\r
1175                                                         result = didPtr->DspDidReadDataLengthFnc(&didLen);\r
1176                                                 }                                       }\r
1177 \r
1178                                         if (result == E_OK) {\r
1179                                                 if (didLen == writeDidLen) {    /** @req DCM473 */\r
1180                                                         result = didPtr->DspDidWriteDataFnc(&pduRxData->SduDataPtr[3], (uint8)didLen, &errorCode);      /** @req DCM395 */\r
1181                                                         if ((result != E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {\r
1182                                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1183                                                         }\r
1184                                                 }\r
1185                                                 else {\r
1186                                                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1187                                                 }\r
1188                                         }\r
1189                                         else {  // Not possible to obtain did length\r
1190                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1191                                         }\r
1192                                 }\r
1193                                 else {  // CheckRead failed\r
1194                                         responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1195                                 }\r
1196                         }\r
1197                         else {  // Not allowed in current security level\r
1198                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
1199                         }\r
1200                 }\r
1201                 else {  // Not allowed in current session\r
1202                         responseCode = DCM_E_SERVICENOTSUPPORTEDINACTIVESESSION;\r
1203                 }\r
1204         }\r
1205         else {  // Read access not configured\r
1206                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1207         }\r
1208 \r
1209         return responseCode;\r
1210 }\r
1211 \r
1212 void DspUdsWriteDataByIdentifier(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1213 {\r
1214         /** @req DCM255 */\r
1215         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1216         uint16 didNr;\r
1217         const Dcm_DspDidType *didPtr = NULL;\r
1218 \r
1219         uint16 didDataLength;\r
1220 \r
1221         didDataLength = pduRxData->SduLength - 3;\r
1222         didNr = (uint16)((uint16)pduRxData->SduDataPtr[1] << 8) + pduRxData->SduDataPtr[2];\r
1223         if (lookupDid(didNr, &didPtr)) {        /** @req DCM467 */\r
1224                 responseCode = writeDidData(didPtr, pduRxData, didDataLength);\r
1225         }\r
1226         else { // DID not found\r
1227                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1228         }\r
1229 \r
1230         if (responseCode == DCM_E_POSITIVERESPONSE) {\r
1231                 pduTxData->SduLength = 3;\r
1232                 pduTxData->SduDataPtr[1] = (didNr >> 8) & 0xFFu;\r
1233                 pduTxData->SduDataPtr[2] = didNr & 0xFFu;\r
1234         }\r
1235 \r
1236         DsdDspProcessingDone(responseCode);\r
1237 }\r
1238 \r
1239 \r
1240 void DspUdsSecurityAccess(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1241 {\r
1242         /** @req DCM252 */\r
1243         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1244 \r
1245         // Check sub function range (0x01 to 0x42)\r
1246         if ((pduRxData->SduDataPtr[1] >= 0x01) && (pduRxData->SduDataPtr[1] <= 0x42)) {\r
1247                 boolean isRequestSeed = pduRxData->SduDataPtr[1] & 0x01u;\r
1248                 Dcm_SecLevelType requestedSecurityLevel = (pduRxData->SduDataPtr[1]-1)/2;\r
1249                 Dcm_NegativeResponseCodeType getSeedErrorCode;\r
1250 \r
1251                 if (isRequestSeed) {\r
1252                         // requestSeed message\r
1253                         // Check if type exist in security table\r
1254                         const Dcm_DspSecurityRowType *securityRow = &DCM_Config.Dsp->DspSecurity->DspSecurityRow[0];\r
1255                         while ((securityRow->DspSecurityLevel != requestedSecurityLevel) && (!securityRow->Arc_EOL)) {\r
1256                                 securityRow++;\r
1257                         }\r
1258                         if (!securityRow->Arc_EOL) {\r
1259                                 // Check length\r
1260                                 if (pduRxData->SduLength == (2 + securityRow->DspSecurityADRSize)) {    /** @req DCM321.RequestSeed */\r
1261                                         Dcm_SecLevelType activeSecLevel;\r
1262                                         Std_ReturnType result;\r
1263                                         result = Dcm_GetSecurityLevel(&activeSecLevel);\r
1264                                         if (result == E_OK) {\r
1265                                                 if (requestedSecurityLevel == activeSecLevel) {         /** @req DCM323 */\r
1266                                                         pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
1267                                                         // If same level set the seed to zeroes\r
1268                                                         memset(&pduTxData->SduDataPtr[2], 0, securityRow->DspSecuritySeedSize);\r
1269                                                         pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
1270                                                 } else {\r
1271                                                         // New security level ask for seed\r
1272                                                         if (securityRow->GetSeed != NULL) {\r
1273                                                                 Std_ReturnType getSeedResult;\r
1274                                                                 getSeedResult = securityRow->GetSeed(&pduRxData->SduDataPtr[2], &pduTxData->SduDataPtr[2], &getSeedErrorCode); /** @req DCM324.RequestSeed */\r
1275                                                                 if ((getSeedResult == E_OK) && (getSeedErrorCode == E_OK)) {\r
1276                                                                         // Everything ok add sub function to tx message and send it.\r
1277                                                                         pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
1278                                                                         pduTxData->SduLength = 2 + securityRow->DspSecuritySeedSize;\r
1279 \r
1280                                                                         dspUdsSecurityAccesData.reqSecLevel = requestedSecurityLevel;\r
1281                                                                         dspUdsSecurityAccesData.reqSecLevelRef = securityRow;\r
1282                                                                         dspUdsSecurityAccesData.reqInProgress = TRUE;\r
1283                                                                 }\r
1284                                                                 else {\r
1285                                                                         // GetSeed returned not ok\r
1286                                                                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1287                                                                 }\r
1288                                                         } else {\r
1289                                                                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1290                                                         }\r
1291                                                 }\r
1292                                         } else {\r
1293                                                 // TODO: What to do?\r
1294                                                 responseCode = DCM_E_GENERALREJECT;\r
1295                                         }\r
1296 \r
1297                                 }\r
1298                                 else {\r
1299                                         // Length not ok\r
1300                                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1301                                 }\r
1302                         }\r
1303                         else {\r
1304                                 // Requested security level not configured\r
1305                                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1306                         }\r
1307                 }\r
1308                 else {\r
1309                         // sendKey message\r
1310                         if (dspUdsSecurityAccesData.reqInProgress) {\r
1311                                 if (pduRxData->SduLength == (2 + dspUdsSecurityAccesData.reqSecLevelRef->DspSecurityKeySize)) { /** @req DCM321.SendKey */\r
1312                                         if (requestedSecurityLevel == dspUdsSecurityAccesData.reqSecLevel) {\r
1313                                                 if (dspUdsSecurityAccesData.reqSecLevelRef->CompareKey != NULL) {\r
1314                                                         Std_ReturnType compareKeyResult;\r
1315                                                         compareKeyResult = dspUdsSecurityAccesData.reqSecLevelRef->CompareKey(&pduRxData->SduDataPtr[2]); /** @req DCM324.SendKey */\r
1316                                                         if (compareKeyResult == E_OK) {\r
1317                                                                 // Request accepted\r
1318                                                                 // Kill timer\r
1319                                                                 DslSetSecurityLevel(dspUdsSecurityAccesData.reqSecLevelRef->DspSecurityLevel); /** @req DCM325 */\r
1320                                                                 dspUdsSecurityAccesData.reqInProgress = FALSE;\r
1321                                                                 pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
1322                                                                 pduTxData->SduLength = 2;\r
1323                                                         }\r
1324                                                         else {\r
1325                                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1326                                                         }\r
1327                                                 } else {\r
1328                                                         responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1329                                                 }\r
1330                                         }\r
1331                                         else {\r
1332                                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1333                                         }\r
1334                                 }\r
1335                                 else {\r
1336                                         // Length not ok\r
1337                                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1338                                 }\r
1339                         }\r
1340                         else {\r
1341                                 // sendKey request without a preceding requestSeed\r
1342                                 responseCode = DCM_E_REQUESTSEQUENCEERROR;\r
1343                         }\r
1344                 }\r
1345         }\r
1346         else {\r
1347                 responseCode = DCM_E_SUBFUNCTIONNOTSUPPORTED;\r
1348         }\r
1349 \r
1350         DsdDspProcessingDone(responseCode);\r
1351 }\r
1352 \r
1353 \r
1354 static boolean lookupRoutine(uint16 routineId, const Dcm_DspRoutineType **routinePtr)\r
1355 {\r
1356         const Dcm_DspRoutineType *dspRoutine = DCM_Config.Dsp->DspRoutine;\r
1357         boolean routineFound = FALSE;\r
1358 \r
1359         while ((dspRoutine->DspRoutineIdentifier != routineId) &&  (!dspRoutine->Arc_EOL)) {\r
1360                 dspRoutine++;\r
1361         }\r
1362 \r
1363         if (!dspRoutine->Arc_EOL) {\r
1364                 routineFound = TRUE;\r
1365                 *routinePtr = dspRoutine;\r
1366         }\r
1367 \r
1368         return routineFound;\r
1369 }\r
1370 \r
1371 \r
1372 static Dcm_NegativeResponseCodeType startRoutine(const Dcm_DspRoutineType *routinePtr, const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1373 {\r
1374         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1375         Std_ReturnType routineResult;\r
1376 \r
1377         // startRoutine\r
1378         if ((routinePtr->DspStartRoutineFnc != NULL) && (routinePtr->DspRoutineInfoRef->DspStartRoutine != NULL)) {\r
1379                 if (((routinePtr->DspRoutineInfoRef->DspStartRoutine->DspStartRoutineCtrlOptRecSize + 4) == pduRxData->SduLength)\r
1380                         && ((routinePtr->DspRoutineInfoRef->DspStartRoutine->DspStartRoutineStsOptRecSize + 4) <= pduTxData->SduLength)) {\r
1381                         pduTxData->SduLength = routinePtr->DspRoutineInfoRef->DspStartRoutine->DspStartRoutineStsOptRecSize + 4;\r
1382                         routineResult = routinePtr->DspStartRoutineFnc(&pduRxData->SduDataPtr[4], &pduTxData->SduDataPtr[4], &responseCode);    /** @req DCM400 */ /** @req DCM401 */\r
1383                         if (routineResult != E_OK) {\r
1384                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1385                         }\r
1386                 }\r
1387                 else {\r
1388                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1389                 }\r
1390         }\r
1391         else {\r
1392                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1393         }\r
1394 \r
1395         return responseCode;\r
1396 }\r
1397 \r
1398 \r
1399 static Dcm_NegativeResponseCodeType stopRoutine(const Dcm_DspRoutineType *routinePtr, const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1400 {\r
1401         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1402         Std_ReturnType routineResult;\r
1403 \r
1404         // stopRoutine\r
1405         if ((routinePtr->DspStopRoutineFnc != NULL) && (routinePtr->DspRoutineInfoRef->DspRoutineStop != NULL)) {\r
1406                 if (((routinePtr->DspRoutineInfoRef->DspRoutineStop->DspStopRoutineCtrlOptRecSize + 4) == pduRxData->SduLength)\r
1407                         && ((routinePtr->DspRoutineInfoRef->DspRoutineStop->DspStopRoutineStsOptRecSize + 4) <= pduTxData->SduLength)) {\r
1408                         pduTxData->SduLength = routinePtr->DspRoutineInfoRef->DspRoutineStop->DspStopRoutineStsOptRecSize + 4;\r
1409                         routineResult = routinePtr->DspStopRoutineFnc(&pduRxData->SduDataPtr[4], &pduTxData->SduDataPtr[4], &responseCode);     /** @req DCM402 */ /** @req DCM403 */\r
1410                         if (routineResult != E_OK) {\r
1411                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1412                         }\r
1413                 }\r
1414                 else {\r
1415                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1416                 }\r
1417         }\r
1418         else {\r
1419                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1420         }\r
1421 \r
1422         return responseCode;\r
1423 }\r
1424 \r
1425 \r
1426 static Dcm_NegativeResponseCodeType requestRoutineResults(const Dcm_DspRoutineType *routinePtr, PduInfoType *pduTxData)\r
1427 {\r
1428         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1429         Std_ReturnType routineResult;\r
1430 \r
1431         // requestRoutineResults\r
1432         if ((routinePtr->DspRequestResultRoutineFnc != NULL) && (routinePtr->DspRoutineInfoRef->DspRoutineRequestRes != NULL)) {\r
1433                 if ((routinePtr->DspRoutineInfoRef->DspRoutineRequestRes->DspReqResRtnCtrlOptRecSize + 4) <= pduTxData->SduLength) {\r
1434                         pduTxData->SduLength = routinePtr->DspRoutineInfoRef->DspRoutineRequestRes->DspReqResRtnCtrlOptRecSize + 4;\r
1435                         routineResult = routinePtr->DspRequestResultRoutineFnc(&pduTxData->SduDataPtr[4], &responseCode);       /** @req DCM404 */ /** @req DCM405 */\r
1436                         if (routineResult != E_OK) {\r
1437                                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1438                         }\r
1439                 }\r
1440                 else {\r
1441                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1442                 }\r
1443         }\r
1444         else {\r
1445                 responseCode = DCM_E_CONDITIONSNOTCORRECT;\r
1446         }\r
1447 \r
1448         return responseCode;\r
1449 }\r
1450 \r
1451 \r
1452 void DspUdsRoutineControl(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1453 {\r
1454         /** @req DCM257 */\r
1455         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1456         uint8 subFunctionNumber = 0;\r
1457         uint16 routineId = 0;\r
1458         const Dcm_DspRoutineType *routinePtr = NULL;\r
1459 \r
1460         if (pduRxData->SduLength >= 4) {\r
1461                 subFunctionNumber = pduRxData->SduDataPtr[1];\r
1462                 if ((subFunctionNumber > 0) && (subFunctionNumber < 4)) {\r
1463                         routineId = (uint16)((uint16)pduRxData->SduDataPtr[2] << 8) + pduRxData->SduDataPtr[3];\r
1464                         if (lookupRoutine(routineId, &routinePtr)) {\r
1465                                 if (DspCheckSessionLevel(routinePtr->DspRoutineInfoRef->DspRoutineAuthorization.DspRoutineSessionRef)) {\r
1466                                         if (DspCheckSecurityLevel(routinePtr->DspRoutineInfoRef->DspRoutineAuthorization.DspRoutineSecurityLevelRef)) {\r
1467                                                 switch (subFunctionNumber) {\r
1468                                                 case 0x01:      // startRoutine\r
1469                                                         responseCode = startRoutine(routinePtr, pduRxData, pduTxData);\r
1470                                                         break;\r
1471 \r
1472                                                 case 0x02:      // stopRoutine\r
1473                                                         responseCode = stopRoutine(routinePtr, pduRxData, pduTxData);\r
1474                                                         break;\r
1475 \r
1476                                                 case 0x03:      // requestRoutineResults\r
1477                                                         responseCode =  requestRoutineResults(routinePtr, pduTxData);\r
1478                                                         break;\r
1479 \r
1480                                                 default:        // This shall never happen\r
1481                                                         responseCode = DCM_E_SUBFUNCTIONNOTSUPPORTED;\r
1482                                                         break;\r
1483                                                 }\r
1484                                         }\r
1485                                         else {  // Not allowed in current security level\r
1486                                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
1487                                         }\r
1488                                 }\r
1489                                 else {  // Not allowed in current session\r
1490                                         responseCode = DCM_E_SERVICENOTSUPPORTEDINACTIVESESSION;\r
1491                                 }\r
1492                         }\r
1493                         else {  // Unknown routine identifier\r
1494                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
1495                         }\r
1496                 }\r
1497                 else {  // Sub function not supported\r
1498                         responseCode = DCM_E_SUBFUNCTIONNOTSUPPORTED;\r
1499                 }\r
1500         }\r
1501         else {\r
1502                 // Wrong length\r
1503                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
1504         }\r
1505 \r
1506         if (responseCode == DCM_E_POSITIVERESPONSE) {\r
1507                 // Add header to the positive response message\r
1508                 pduTxData->SduDataPtr[1] = subFunctionNumber;\r
1509                 pduTxData->SduDataPtr[2] = (routineId >> 8) & 0xFFu;\r
1510                 pduTxData->SduDataPtr[3] = routineId & 0xFFu;\r
1511         }\r
1512 \r
1513         DsdDspProcessingDone(responseCode);\r
1514 }\r
1515 \r
1516 \r
1517 void DspUdsTesterPresent(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1518 {\r
1519         /** @req DCM251 */\r
1520         if (pduRxData->SduLength == 2) {\r
1521                 switch (pduRxData->SduDataPtr[1])\r
1522                 {\r
1523                 case ZERO_SUB_FUNCTION:\r
1524                         DslResetSessionTimeoutTimer();\r
1525                         // Create positive response\r
1526                         pduTxData->SduDataPtr[1] = ZERO_SUB_FUNCTION;\r
1527                         pduTxData->SduLength = 2;\r
1528                         DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
1529                         break;\r
1530 \r
1531                 default:\r
1532                         DsdDspProcessingDone(DCM_E_SUBFUNCTIONNOTSUPPORTED);\r
1533                         break;\r
1534                 }\r
1535         }\r
1536         else {\r
1537                 // Wrong length\r
1538                 DsdDspProcessingDone(DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT);\r
1539         }\r
1540 }\r
1541 \r
1542 \r
1543 void DspUdsControlDtcSetting(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1544 {\r
1545         /** @req DCM249 */\r
1546         Dem_ReturnControlDTCStorageType resultCode;\r
1547 \r
1548         if (pduRxData->SduLength == 2) {\r
1549                 switch (pduRxData->SduDataPtr[1])\r
1550                 {\r
1551                 case 0x01:      // ON\r
1552                         resultCode = Dem_EnableDTCStorage(DEM_DTC_GROUP_ALL_DTCS, DEM_DTC_KIND_ALL_DTCS);               /** @req DCM304 */\r
1553                         if (resultCode == DEM_CONTROL_DTC_STORAGE_OK) {\r
1554                                 pduTxData->SduDataPtr[1] = 0x01;\r
1555                                 pduTxData->SduLength = 2;\r
1556                                 DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
1557                         }\r
1558                         else {\r
1559                                 DsdDspProcessingDone(DCM_E_REQUESTOUTOFRANGE);\r
1560                         }\r
1561                         break;\r
1562 \r
1563                 case 0x02:      // OFF\r
1564                         resultCode = Dem_DisableDTCStorage(DEM_DTC_GROUP_ALL_DTCS, DEM_DTC_KIND_ALL_DTCS);              /** @req DCM406 */\r
1565                         if (resultCode == DEM_CONTROL_DTC_STORAGE_OK) {\r
1566                                 pduTxData->SduDataPtr[1] = 0x02;\r
1567                                 pduTxData->SduLength = 2;\r
1568                                 DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
1569                         }\r
1570                         else {\r
1571                                 DsdDspProcessingDone(DCM_E_REQUESTOUTOFRANGE);\r
1572                         }\r
1573                         break;\r
1574 \r
1575                 default:\r
1576                         DsdDspProcessingDone(DCM_E_SUBFUNCTIONNOTSUPPORTED);\r
1577                         break;\r
1578                 }\r
1579         }\r
1580         else {\r
1581                 // Wrong length\r
1582                 DsdDspProcessingDone(DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT);\r
1583         }\r
1584 }\r
1585 \r
1586 \r
1587 void DspDcmConfirmation(PduIdType confirmPduId)\r
1588 {\r
1589         if (dspUdsEcuResetData.resetPending) {\r
1590                 if (confirmPduId == dspUdsEcuResetData.resetPduId) {\r
1591                         dspUdsEcuResetData.resetPending = FALSE;\r
1592 #if defined(USE_MCU) && ( MCU_PERFORM_RESET_API == STD_ON )\r
1593                         Mcu_PerformReset();\r
1594 #else\r
1595                         DET_REPORTERROR(MODULE_ID_DCM, 0, DCM_UDS_RESET_ID, DCM_E_NOT_SUPPORTED);\r
1596 #endif\r
1597                 }\r
1598         }\r
1599 }\r
1600 \r
1601 \r
1602 static boolean CheckReadMemoryByAddress( boolean useId,uint32 memoryAddress,\r
1603                                                                                 uint8 memoryAddressFormat,\r
1604                                                                                 uint32 memorySize,\r
1605                                                                                 const Dcm_DspMemoryIdInfo  *dspMemory)\r
1606 {\r
1607         boolean ret = FALSE;\r
1608         uint8 MemoryId;\r
1609 \r
1610         if(useId == FALSE)\r
1611         {\r
1612                 /*@req DCM493*/\r
1613                 if((memoryAddress >= dspMemory->pReadMemoryInfo->MemoryAddressLow)\r
1614                         && (memoryAddress <= dspMemory->pReadMemoryInfo->MemoryAddressHigh)\r
1615                         && (memoryAddress + memorySize - 1 <= dspMemory->pReadMemoryInfo->MemoryAddressHigh))\r
1616                 {\r
1617                         ret = TRUE;\r
1618                 }\r
1619         }\r
1620         else\r
1621         {\r
1622                 MemoryId = (uint8)(memoryAddress >> ((memoryAddressFormat - 1)*8));\r
1623                 memoryAddress = (uint32)(memoryAddress & DCM_MEMORY_ADDRESS_MASK);\r
1624 \r
1625                 if((MemoryId == dspMemory->MemoryIdValue)&&\r
1626                         (memoryAddress >= dspMemory->pReadMemoryInfo->MemoryAddressLow)\r
1627                         && (memoryAddress <= dspMemory->pReadMemoryInfo->MemoryAddressHigh)\r
1628                         && (memoryAddress + memorySize - 1 <= dspMemory->pReadMemoryInfo->MemoryAddressHigh))\r
1629                 {\r
1630                         ret = TRUE;\r
1631                 }\r
1632         }\r
1633         \r
1634         return ret;\r
1635 }\r
1636 \r
1637 static boolean lookupReadMemory(uint32 memoryAddress,\r
1638                                                                 uint8  memoryAddressFormat,\r
1639                                                                 uint32 memorySize,\r
1640                                                                 const Dcm_DspMemoryIdInfo  **MemoryInfoPtr)\r
1641 {\r
1642         uint8 i;\r
1643         boolean memoryFound = FALSE;\r
1644         const Dcm_DspMemoryIdInfo *dspMemoryInfo = DCM_Config.Dsp->DspMemory->DspMemoryIdInfo;\r
1645 \r
1646         for(i = 0; (dspMemoryInfo->Arc_EOL == FALSE) && (memoryFound == FALSE); i++)\r
1647         {\r
1648                 if(TRUE == CheckReadMemoryByAddress(DCM_Config.Dsp->DspMemory->DcmDspUseMemoryId,memoryAddress,memoryAddressFormat,memorySize,dspMemoryInfo))\r
1649                 {\r
1650                         memoryFound = TRUE;\r
1651                 }\r
1652                 else\r
1653                 {\r
1654                         dspMemoryInfo++;\r
1655                 }\r
1656         }\r
1657         if (memoryFound == TRUE)\r
1658         {\r
1659                 *MemoryInfoPtr = dspMemoryInfo;\r
1660         }\r
1661         \r
1662         return memoryFound;\r
1663 }\r
1664 \r
1665 static Dcm_NegativeResponseCodeType readMemoryData( Dcm_OpStatusType *OpStatus,\r
1666                                                                                                         const Dcm_DspMemoryIdInfo *MemoryPtr,\r
1667                                                                                                         uint32 MemoryAddress,\r
1668                                                                                                         uint32 MemorySize,\r
1669                                                                                                         PduInfoType *pduTxData)\r
1670 {\r
1671         Dcm_ReturnReadMemoryType ReadRet;\r
1672         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1673         ReadRet = Dcm_ReadMemory(*OpStatus,MemoryPtr->MemoryIdValue,\r
1674                                                                         MemoryAddress,\r
1675                                                                         MemorySize,\r
1676                                                                         &pduTxData->SduDataPtr[1]);\r
1677         if(DCM_READ_FAILED == ReadRet)\r
1678         {\r
1679                 responseCode = DCM_E_GENERALPROGRAMMINGFAILURE;  /*@req Dcm644*/\r
1680         }\r
1681         if (DCM_READ_PENDING == ReadRet)\r
1682         {\r
1683                 *OpStatus = DCM_READ_PENDING;\r
1684         }       \r
1685         return responseCode;\r
1686 }\r
1687 \r
1688 /*@req Dcm442,DCM492*/\r
1689 void DspUdsReadMemoryByAddress(const PduInfoType *pduRxData, PduInfoType *pduTxData)\r
1690 {\r
1691         typedef struct{\r
1692                 uint32 MemoryAddressStart;                                      /*  low  address of a  memory block to read or write*/\r
1693                 uint32 MemoryIdValue;                                           /*  memory ID  to read or write uint used by parameter */\r
1694                 const Dcm_DspMemoryIdInfo *MemoryIdConfigPtr;           \r
1695                 Dcm_NegativeResponseCodeType ResponseCode; \r
1696                 uint8 MemorySizeFormat;\r
1697                 uint8 MemoryAddressFormat;\r
1698                 uint32 MemorySize;\r
1699                 uint16 MessageLength;\r
1700         }DspUdsReadMemoryByAddressType; /*the typed used for  SID read memory by address*/\r
1701         uint8 i;\r
1702         DspUdsReadMemoryByAddressType dspReadMemoryByAddress;\r
1703         Dcm_OpStatusType OpStatus = 0;\r
1704         dspReadMemoryByAddress.MemoryAddressStart = 0;\r
1705         dspReadMemoryByAddress.MemorySize = 0;\r
1706         dspReadMemoryByAddress.MemoryIdConfigPtr = NULL;\r
1707         dspReadMemoryByAddress.ResponseCode = DCM_E_POSITIVERESPONSE;\r
1708         dspReadMemoryByAddress.MemorySizeFormat = ((uint8)(pduRxData->SduDataPtr[1] & DCM_FORMAT_HIGH_MASK)) >> 4;      /*@req UDS_REQ_0x23_1 & UDS_REQ_0x23_5*/\r
1709         dspReadMemoryByAddress.MemoryAddressFormat = ((uint8)(pduRxData->SduDataPtr[1])) & 0x0Fu;   /*@req UDS_REQ_0x23_1 & UDS_REQ_0x23_5*/\r
1710 \r
1711         if((dspReadMemoryByAddress.MemoryAddressFormat == 0)||(dspReadMemoryByAddress.MemorySizeFormat == 0))\r
1712         {\r
1713                 dspReadMemoryByAddress.ResponseCode = DCM_E_REQUESTOUTOFRANGE;  /*UDS_REQ_0x23_10*/\r
1714         }\r
1715         else\r
1716         {\r
1717                 dspReadMemoryByAddress.MessageLength = (uint16)(dspReadMemoryByAddress.MemoryAddressFormat + dspReadMemoryByAddress.MemorySizeFormat + SID_AND_ALFID_LEN2);\r
1718                 if(dspReadMemoryByAddress.MessageLength == (uint16)(pduRxData->SduLength))\r
1719                 {\r
1720                         /*take start address out */\r
1721                         for(i = 0; i < dspReadMemoryByAddress.MemoryAddressFormat; i++)\r
1722                         {\r
1723                                 dspReadMemoryByAddress.MemoryAddressStart <<= 8;\r
1724                                 dspReadMemoryByAddress.MemoryAddressStart += (uint32)(pduRxData->SduDataPtr[SID_AND_ALFID_LEN2 + i]);\r
1725                         }\r
1726 \r
1727                         /*take value of MemorySize out */\r
1728                         for(i = 0; i < dspReadMemoryByAddress.MemorySizeFormat; i++)\r
1729                         {\r
1730                                 dspReadMemoryByAddress.MemorySize <<= 8;\r
1731                                 dspReadMemoryByAddress.MemorySize += (uint32)(pduRxData->SduDataPtr[2 + i + dspReadMemoryByAddress.MemoryAddressFormat]);\r
1732                         }\r
1733                         if(dspReadMemoryByAddress.MemorySize < DCM_PROTOCAL_TP_MAX_LENGTH)\r
1734                         {\r
1735                                 if(TRUE == lookupReadMemory(dspReadMemoryByAddress.MemoryAddressStart,\r
1736                                                                                         dspReadMemoryByAddress.MemoryAddressFormat,\r
1737                                                                                         dspReadMemoryByAddress.MemorySize,\r
1738                                                                                         &dspReadMemoryByAddress.MemoryIdConfigPtr))\r
1739                                 {\r
1740                                         if (DspCheckSecurityLevel(dspReadMemoryByAddress.MemoryIdConfigPtr->pReadMemoryInfo->pSecurityLevel) == TRUE)\r
1741                                         {\r
1742                                                 dspReadMemoryByAddress.ResponseCode = readMemoryData(&OpStatus,dspReadMemoryByAddress.MemoryIdConfigPtr,\r
1743                                                                                                                                                         dspReadMemoryByAddress.MemoryAddressStart,\r
1744                                                                                                                                                         dspReadMemoryByAddress.MemorySize,pduTxData);/*@req UDS_REQ_0x23_9*/\r
1745                                         \r
1746                                         }\r
1747                                         else\r
1748                                         {\r
1749                                                 dspReadMemoryByAddress.ResponseCode = DCM_E_SECUTITYACCESSDENIED;/*@req UDS_REQ_0x23_11,@req DCM494*/\r
1750                                         }\r
1751                                 }\r
1752                                 else\r
1753                                 {\r
1754                                         dspReadMemoryByAddress.ResponseCode = DCM_E_REQUESTOUTOFRANGE;      /*@req UDS_REQ_0x23_7,UDS_REQ_0x23_8*/\r
1755                                 }\r
1756                         }\r
1757                         else\r
1758                         {\r
1759                                 dspReadMemoryByAddress.ResponseCode = DCM_E_REQUESTOUTOFRANGE;\r
1760                         }\r
1761                 }\r
1762                 else\r
1763                 {\r
1764                         dspReadMemoryByAddress.ResponseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT; /*@req UDS_REQ_0x23_6*/\r
1765                 }\r
1766         }\r
1767         if(DCM_E_POSITIVERESPONSE == dspReadMemoryByAddress.ResponseCode)\r
1768         {\r
1769                 pduTxData->SduLength = 1 + dspReadMemoryByAddress.MemorySize;\r
1770                 if(OpStatus == DCM_READ_PENDING)\r
1771                 {\r
1772                         dspMemoryState = DCM_MEMORY_READ;\r
1773                 }\r
1774                 else\r
1775                 {\r
1776                         DsdDspProcessingDone(DCM_E_POSITIVERESPONSE);\r
1777                 }\r
1778         }\r
1779         else\r
1780         {\r
1781                 DsdDspProcessingDone(dspReadMemoryByAddress.ResponseCode);\r
1782         }\r
1783 }\r
1784 \r
1785 static boolean checkWriteMemoryByAddress(boolean useId,uint32 memoryAddress,\r
1786                                                                                 uint8 memoryAddressFormat,\r
1787                                                                                 uint32 memorySize,\r
1788                                                                                 const Dcm_DspMemoryIdInfo *dspMemory)\r
1789 {\r
1790         boolean ret = FALSE;\r
1791         uint8 MemoryId;\r
1792         \r
1793         if(useId == FALSE)\r
1794         {\r
1795                 if((memoryAddress >= dspMemory->pWriteMemoryInfo->MemoryAddressLow)\r
1796                         && (memoryAddress <= dspMemory->pWriteMemoryInfo->MemoryAddressHigh)\r
1797                         && (memoryAddress + memorySize - 1 <= dspMemory->pWriteMemoryInfo->MemoryAddressHigh))\r
1798                 {\r
1799                         ret = TRUE;\r
1800                 }\r
1801         }\r
1802         else\r
1803         {\r
1804                 MemoryId = (uint8)(memoryAddress >> ((memoryAddressFormat - 1)*8));\r
1805                 memoryAddress = memoryAddress & DCM_MEMORY_ADDRESS_MASK;\r
1806 \r
1807                 if((MemoryId == dspMemory->MemoryIdValue) &&\r
1808                         (memoryAddress >= dspMemory->pWriteMemoryInfo->MemoryAddressLow)\r
1809                         && (memoryAddress <= dspMemory->pWriteMemoryInfo->MemoryAddressHigh)\r
1810                         && (memoryAddress + memorySize -1 <= dspMemory->pWriteMemoryInfo->MemoryAddressHigh))\r
1811                 {\r
1812                         ret = TRUE;\r
1813                 }\r
1814 \r
1815         }\r
1816         \r
1817         return ret;\r
1818 }\r
1819 \r
1820 static boolean lookupWriteMemory(uint32 memoryAddress,\r
1821                                                                 uint8 memoryAddressFormat,\r
1822                                                                 uint32 memorySize,\r
1823                                                                 const Dcm_DspMemoryIdInfo **MemoryIdConfigPtr)\r
1824 {\r
1825         uint8 i;\r
1826         const Dcm_DspMemoryIdInfo *dspMemoryInfo = DCM_Config.Dsp->DspMemory->DspMemoryIdInfo;\r
1827         boolean memoryFound = FALSE;\r
1828 \r
1829         for(i = 0;(dspMemoryInfo->Arc_EOL == FALSE) && (memoryFound == FALSE);i++)\r
1830         {\r
1831                 if(TRUE == checkWriteMemoryByAddress(DCM_Config.Dsp->DspMemory->DcmDspUseMemoryId, memoryAddress,memoryAddressFormat,memorySize,dspMemoryInfo))\r
1832                 {\r
1833                         memoryFound = TRUE;\r
1834                 }\r
1835                 else\r
1836                 {\r
1837                         dspMemoryInfo++;\r
1838                 }\r
1839         }\r
1840         if (memoryFound == TRUE)\r
1841         {\r
1842                 *MemoryIdConfigPtr = dspMemoryInfo;\r
1843         }\r
1844         \r
1845         return memoryFound;\r
1846 }\r
1847 \r
1848 static Dcm_NegativeResponseCodeType writeMemoryData(Dcm_OpStatusType* OpStatus,\r
1849                                                                                                 const Dcm_DspMemoryIdInfo *MemoryIdConfigPtr,\r
1850                                                                                                 uint32 MemoryAddress,\r
1851                                                                                                 uint32 MemorySize,\r
1852                                                                                                 uint8 *SourceData)\r
1853 {\r
1854         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
1855         Dcm_ReturnWriteMemoryType writeRet;\r
1856         writeRet = Dcm_WriteMemory(*OpStatus,\r
1857                                                                 MemoryIdConfigPtr->MemoryIdValue,\r
1858                                                                 MemoryAddress,\r
1859                                                                 MemorySize,\r
1860                                                                 SourceData);\r
1861         if(DCM_READ_FAILED == writeRet)\r
1862         {\r
1863                 responseCode = DCM_E_GENERALPROGRAMMINGFAILURE;   /*@req UDS_REQ_0X3D_16,DCM643*/\r
1864         }\r
1865         else if(DCM_WRITE_PENDING == writeRet)\r
1866         {\r
1867                 *OpStatus = DCM_PENDING;\r
1868         }\r
1869         else\r
1870         {\r
1871                 responseCode = DCM_E_POSITIVERESPONSE;\r
1872         }\r
1873         \r
1874         return responseCode;\r
1875 }\r
1876 \r
1877 void DspUdsWriteMemoryByAddress(const PduInfoType* pduRxData, PduInfoType* pduTxData)\r
1878 {\r
1879           typedef struct{\r
1880                 uint32 MemoryAddressStart;\r
1881                 uint32 MemoryIdValue;\r
1882                 const Dcm_DspMemoryIdInfo *MemoryIdConfigPtr;\r
1883                 Dcm_NegativeResponseCodeType ResponseCode;\r
1884                 uint8 MemorySizeFormat;\r
1885                 uint8 MemoryAddressFormat;\r
1886                 uint32 MemorySize ;\r
1887                 uint16 MessageLength;\r
1888           }DspUdsWriteMemoryType;\r
1889         uint8 i;\r
1890         DspUdsWriteMemoryType dspUdsWriteMemory;\r
1891         Dcm_OpStatusType OpStatus = DCM_INITIAL;\r
1892         dspUdsWriteMemory.MemoryAddressStart = 0;\r
1893         dspUdsWriteMemory.MemoryIdConfigPtr = NULL;\r
1894         dspUdsWriteMemory.ResponseCode = DCM_E_POSITIVERESPONSE;\r
1895         dspUdsWriteMemory.MemorySizeFormat = ((uint8)(pduRxData->SduDataPtr[1] & DCM_FORMAT_HIGH_MASK)) >> 4;   /*@req UDS_REQ_0x3D_3 & UDS_REQ_0x3D_5*/\r
1896         dspUdsWriteMemory.MemoryAddressFormat = ((uint8)pduRxData->SduDataPtr[1]) & DCM_FORMAT_LOW_MASK;                /*@req UDS_REQ_0x3D_3& UDS_REQ_0x3D_4*/\r
1897         dspUdsWriteMemory.MemorySize = 0;\r
1898 \r
1899         if((dspUdsWriteMemory.MemoryAddressFormat == 0) || (dspUdsWriteMemory.MemorySizeFormat == 0))  /*@req UDS_REQ_0x3D_14*/\r
1900         {\r
1901                 dspUdsWriteMemory.ResponseCode = DCM_E_REQUESTOUTOFRANGE;\r
1902         }\r
1903         else\r
1904         {\r
1905                 /*take value of MemorySize out */\r
1906                 for(i = 0; i < dspUdsWriteMemory.MemorySizeFormat; i++)\r
1907                 {\r
1908                         dspUdsWriteMemory.MemorySize <<= 8;\r
1909                         dspUdsWriteMemory.MemorySize += (uint32)(pduRxData->SduDataPtr[2 + i +dspUdsWriteMemory.MemoryAddressFormat]);\r
1910                 }\r
1911                 dspUdsWriteMemory.MessageLength = (uint16)(2 + dspUdsWriteMemory.MemoryAddressFormat + dspUdsWriteMemory.MemorySizeFormat + dspUdsWriteMemory.MemorySize);\r
1912                 if(dspUdsWriteMemory.MessageLength == pduRxData->SduLength)\r
1913                 {\r
1914                         /*take Start Address out */\r
1915                         for(i = 0; i < dspUdsWriteMemory.MemoryAddressFormat; i++)\r
1916                         {\r
1917                                 dspUdsWriteMemory.MemoryAddressStart <<= 8;\r
1918                                 dspUdsWriteMemory.MemoryAddressStart += (uint32)(pduRxData->SduDataPtr[2 + i]);\r
1919                         }\r
1920                         if(TRUE == lookupWriteMemory(dspUdsWriteMemory.MemoryAddressStart,\r
1921                                                                                 dspUdsWriteMemory.MemoryAddressFormat,\r
1922                                                                                 dspUdsWriteMemory.MemorySize,\r
1923                                                                                 &dspUdsWriteMemory.MemoryIdConfigPtr))\r
1924                         {\r
1925                                 if (DspCheckSecurityLevel(dspUdsWriteMemory.MemoryIdConfigPtr->pReadMemoryInfo->pSecurityLevel) == TRUE)\r
1926                                 {\r
1927                                         dspUdsWriteMemory.ResponseCode = writeMemoryData(&OpStatus,\r
1928                                                                                                                                         dspUdsWriteMemory.MemoryIdConfigPtr, \r
1929                                                                                                                                         dspUdsWriteMemory.MemoryAddressStart,\r
1930                                                                                                                                         dspUdsWriteMemory.MemorySize,\r
1931                                                                                                                                         &pduRxData->SduDataPtr[2 + dspUdsWriteMemory.MemoryAddressFormat + dspUdsWriteMemory.MemorySizeFormat]);\r
1932                                 }\r
1933                                 else\r
1934                                 {\r
1935                                         dspUdsWriteMemory.ResponseCode = DCM_E_SECUTITYACCESSDENIED;    /*@req UDS_REQ_0X3D_15,Dcm490*/\r
1936                                 }\r
1937                         }\r
1938                         else\r
1939                         {\r
1940                                 dspUdsWriteMemory.ResponseCode = DCM_E_REQUESTOUTOFRANGE;                /*@req UDS_REQ_0x3D_11,UDS_REQ_0x3D_12,Dcm489*/\r
1941                         }\r
1942                 }\r
1943                 else\r
1944                 {\r
1945                         dspUdsWriteMemory.ResponseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;/*@req UDS_REQ_0x3D_9*/\r
1946                 }       \r
1947         }\r
1948         if(DCM_E_POSITIVERESPONSE == dspUdsWriteMemory.ResponseCode)\r
1949         {\r
1950                 pduTxData->SduLength = 2 + dspUdsWriteMemory.MemorySizeFormat + dspUdsWriteMemory.MemoryAddressFormat;\r
1951                 pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
1952                 for(i = 0; i < dspUdsWriteMemory.MemorySizeFormat + dspUdsWriteMemory.MemoryAddressFormat; i++)\r
1953                 {\r
1954                         pduTxData->SduDataPtr[2 + i] = pduRxData->SduDataPtr[2 + i];\r
1955                         if(OpStatus != DCM_PENDING)\r
1956                         {\r
1957                                 DsdDspProcessingDone(dspUdsWriteMemory.ResponseCode);\r
1958                         }\r
1959                         else\r
1960                         {\r
1961                         dspMemoryState=DCM_MEMORY_WRITE;\r
1962                         }\r
1963                 }\r
1964         }\r
1965         else\r
1966         {\r
1967                 DsdDspProcessingDone(dspUdsWriteMemory.ResponseCode);\r
1968         }\r
1969 }\r
1970 \r
1971 static boolean checkPeriodicIdentifierBuffer(uint8 PeriodicDid,uint8 Length,uint8 *postion)\r
1972 {\r
1973         uint8 i;\r
1974         boolean ret = FALSE;\r
1975         for(i = 0;(i < Length) && (ret == FALSE);i++)\r
1976         {\r
1977                 if(PeriodicDid == dspPDidRef.dspPDid[i].PeriodicDid)\r
1978                 {\r
1979                         ret = TRUE;\r
1980                         *postion = i;\r
1981                 }\r
1982         }\r
1983         \r
1984         return ret;\r
1985 }\r
1986 \r
1987 static void ClearPeriodicIdentifierBuffer(uint8 BufferEnd,uint8 postion)\r
1988 {\r
1989         dspPDidRef.dspPDid[postion].PeriodicDid = dspPDidRef.dspPDid[BufferEnd ].PeriodicDid;\r
1990         dspPDidRef.dspPDid[postion].PDidTxCounter = dspPDidRef.dspPDid[BufferEnd].PDidTxCounter;\r
1991         dspPDidRef.dspPDid[postion].PDidTxCounterNumber = dspPDidRef.dspPDid[BufferEnd].PDidTxCounterNumber;\r
1992         dspPDidRef.dspPDid[BufferEnd].PeriodicDid = 0;\r
1993         dspPDidRef.dspPDid[BufferEnd].PDidTxCounter = 0;\r
1994         dspPDidRef.dspPDid[BufferEnd ].PDidTxCounterNumber = 0;\r
1995 }\r
1996 \r
1997 static Dcm_NegativeResponseCodeType readPeriodDidData(const Dcm_DspDidType *PDidPtr, uint8 *Data,uint16 *Length)\r
1998 {\r
1999         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2000         if ((PDidPtr->DspDidInfoRef->DspDidAccess.DspDidRead != NULL) \r
2001                 && (PDidPtr->DspDidConditionCheckReadFnc != NULL) \r
2002                 && (PDidPtr->DspDidReadDataFnc != NULL) ) \r
2003         {       \r
2004                 if (DspCheckSessionLevel(PDidPtr->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSessionRef)) \r
2005                 { \r
2006                         if (DspCheckSecurityLevel(PDidPtr->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSecurityLevelRef)) \r
2007                         {\r
2008                                 Std_ReturnType result = E_NOT_OK;\r
2009                                 Dcm_NegativeResponseCodeType errorCode = DCM_E_POSITIVERESPONSE;\r
2010                                 result = PDidPtr->DspDidConditionCheckReadFnc(&errorCode);\r
2011                                 if ((result == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE))\r
2012                                 {\r
2013                                         result = E_NOT_OK;\r
2014                                         if (PDidPtr->DspDidInfoRef->DspDidFixedLength)\r
2015                                         {       \r
2016                                                 *Length= PDidPtr->DspDidSize;\r
2017                                                 result = E_OK;\r
2018                                         }\r
2019                                         else\r
2020                                         {\r
2021                                                 if(PDidPtr->DspDidReadDataLengthFnc!=NULL)\r
2022                                                 {\r
2023                                                         result = PDidPtr->DspDidReadDataLengthFnc(Length);\r
2024                                                 }\r
2025                                                 else\r
2026                                                 {\r
2027                                                         responseCode = DCM_E_GENERALREJECT;\r
2028                                                 }\r
2029                                         }\r
2030                                         if (result == E_OK) \r
2031                                         {\r
2032                                                 result = PDidPtr->DspDidReadDataFnc(Data);\r
2033                                                 if (result != E_OK)\r
2034                                                 {\r
2035                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2036                                                 }\r
2037                                         }\r
2038                                         else\r
2039                                         {\r
2040                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2041                                         }\r
2042                                 }\r
2043                                 else\r
2044                                 {\r
2045                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2046                                 }\r
2047                         }\r
2048                         else\r
2049                         {\r
2050                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
2051                         }\r
2052                 }\r
2053                 else\r
2054                 {\r
2055                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2056                 }\r
2057         }\r
2058         else\r
2059         {\r
2060                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2061         }\r
2062         return responseCode;\r
2063 }\r
2064 \r
2065 static Dcm_NegativeResponseCodeType DspSavePeriodicData(uint16 didNr, uint32 periodicTransmitCounter,uint8 PdidBufferNr)\r
2066 {\r
2067         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2068         const Dcm_DspDidType *SourceDid = NULL;\r
2069         Dcm_DspDDDType *DDidPtr = NULL;\r
2070 \r
2071         if (TRUE == lookupDid(didNr, &SourceDid))\r
2072         {\r
2073                 if(DspCheckSessionLevel(SourceDid->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSessionRef) == TRUE)\r
2074                 {\r
2075                         if(DspCheckSecurityLevel(SourceDid->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSecurityLevelRef) == TRUE)\r
2076                         {\r
2077                                 Std_ReturnType result = E_NOT_OK;\r
2078                                 Dcm_NegativeResponseCodeType errorCode = DCM_E_POSITIVERESPONSE;\r
2079                                 \r
2080                                 if(SourceDid->DspDidConditionCheckReadFnc != NULL)\r
2081                                 {\r
2082                                         result = SourceDid->DspDidConditionCheckReadFnc(&errorCode);\r
2083                                 }\r
2084                                 if ((result != E_OK) || (errorCode != DCM_E_POSITIVERESPONSE))\r
2085                                 {\r
2086                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2087                                 }\r
2088                                 if((SourceDid->DspDidInfoRef->DspDidFixedLength!=TRUE) && (SourceDid->DspDidReadDataLengthFnc == NULL))\r
2089                                 {\r
2090                                         responseCode = DCM_E_GENERALREJECT;\r
2091                                 }\r
2092                         }\r
2093                         else\r
2094                         {\r
2095                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
2096                         }\r
2097                 }\r
2098                 else\r
2099                 {\r
2100                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2101                 }\r
2102         }\r
2103         else if(LookupDDD(didNr, (const Dcm_DspDDDType **)&DDidPtr) == TRUE)\r
2104         {\r
2105                 responseCode = DCM_E_POSITIVERESPONSE;\r
2106         }\r
2107         else\r
2108         {\r
2109                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2110         }\r
2111         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2112         {\r
2113                 dspPDidRef.dspPDid[PdidBufferNr].PeriodicDid = (uint8)didNr & DCM_DID_LOW_MASK;\r
2114                 dspPDidRef.dspPDid[PdidBufferNr].PDidTxCounter = 0;\r
2115                 dspPDidRef.dspPDid[PdidBufferNr].PDidTxCounterNumber = periodicTransmitCounter;\r
2116         }\r
2117         return responseCode;\r
2118 }\r
2119 static void ClearPeriodicIdentifier(const PduInfoType *pduRxData,PduInfoType *pduTxData )\r
2120 {\r
2121         uint16 PdidNumber;\r
2122         uint8 PDidLowByte;\r
2123         uint8 PdidPostion;\r
2124         uint8 i;\r
2125         if( pduRxData->SduDataPtr[1] == DCM_PERIODICTRANSMIT_STOPSENDING_MODE )\r
2126         {\r
2127                 PdidNumber = pduRxData->SduLength - 2;\r
2128                 for(i = 0;i < PdidNumber;i++)\r
2129                 {\r
2130                         PDidLowByte = pduRxData->SduDataPtr[2];\r
2131                         if(checkPeriodicIdentifierBuffer(PDidLowByte,dspPDidRef.PDidNr,&PdidPostion) == TRUE)\r
2132                         {\r
2133                                 dspPDidRef.PDidNr--;\r
2134                                 ClearPeriodicIdentifierBuffer(dspPDidRef.PDidNr, PdidPostion);\r
2135                                 \r
2136                         }               \r
2137                 }\r
2138                 pduTxData->SduLength = 1;\r
2139         }\r
2140 }\r
2141 /*\r
2142         DESCRIPTION:\r
2143                  UDS Service 0x2a - Read Data By Periodic Identifier\r
2144 */\r
2145 void DspReadDataByPeriodicIdentifier(const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2146 {\r
2147         /** @req DCM254 */\r
2148         uint8 PDidLowByte;\r
2149         uint16 PdidNumber;\r
2150         uint8 PdidPostion;\r
2151         uint16 i;\r
2152         uint8 PdidBufferNr;\r
2153         uint32 periodicTransmitCounter;\r
2154         uint16 DataLength;\r
2155         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2156         const Dcm_DspDidType *PDidPtr = NULL;\r
2157         Dcm_DspDDDType *DDidPtr = NULL;\r
2158         PdidBufferNr = dspPDidRef.PDidNr;\r
2159         if(pduRxData->SduLength > 2)\r
2160         {\r
2161                 \r
2162                 switch(pduRxData->SduDataPtr[1])\r
2163                 {\r
2164                         case DCM_PERIODICTRANSMIT_DEFAULT_MODE:\r
2165                                 periodicTransmitCounter = 0;\r
2166                                 break;\r
2167                         case DCM_PERIODICTRANSMIT_SLOWRATE_MODE:\r
2168                                 periodicTransmitCounter = DCM_PERIODICTRANSMIT_SLOW;\r
2169                                 break;\r
2170                                 case DCM_PERIODICTRANSMIT_MEDIUM_MODE:\r
2171                                         periodicTransmitCounter = DCM_PERIODICTRANSMIT_MEDIUM;\r
2172                                 break;\r
2173                         case DCM_PERIODICTRANSMIT_FAST_MODE:\r
2174                                 periodicTransmitCounter = DCM_PERIODICTRANSMIT_FAST;\r
2175                                 break;\r
2176                         case DCM_PERIODICTRANSMIT_STOPSENDING_MODE:\r
2177                                 ClearPeriodicIdentifier(pduRxData,pduTxData);\r
2178                                 break;\r
2179                         default:\r
2180                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2181                                 break;\r
2182                 }\r
2183                 if(pduRxData->SduDataPtr[1] != DCM_PERIODICTRANSMIT_STOPSENDING_MODE)\r
2184                 {\r
2185                         PdidNumber = pduRxData->SduLength - 2;\r
2186                         if(1 == PdidNumber)\r
2187                         {\r
2188                                 PDidLowByte = pduRxData->SduDataPtr[2];                 \r
2189                                 if(checkPeriodicIdentifierBuffer(PDidLowByte,dspPDidRef.PDidNr,&PdidPostion) == TRUE)\r
2190                                 {\r
2191                                         if(0 == periodicTransmitCounter)\r
2192                                         {\r
2193                                                 if (TRUE == lookupDid(((uint16)PDidLowByte + 0xF200), &PDidPtr))   /*UDS_REQ_0x2A_1*/\r
2194                                                 {\r
2195                                                         pduTxData->SduDataPtr[1] = PDidLowByte; \r
2196                                                         responseCode = readPeriodDidData(PDidPtr,&pduTxData->SduDataPtr[2],&DataLength);\r
2197                                                         pduTxData->SduLength = DataLength + 2;\r
2198                                                 }\r
2199                                                 else if(TRUE == LookupDDD((0xF200 + (uint16)PDidLowByte), (const Dcm_DspDDDType **)&DDidPtr))\r
2200                                                 {\r
2201                                                         pduTxData->SduDataPtr[1] = PDidLowByte;\r
2202                                                         responseCode = readDDDData(DDidPtr,&pduTxData->SduDataPtr[2],&DataLength);\r
2203                                                         pduTxData->SduLength = DataLength + 2;\r
2204                                                 }\r
2205                                                 else\r
2206                                                 {\r
2207                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2208                                                 }\r
2209                                                 if(responseCode != DCM_E_POSITIVERESPONSE)\r
2210                                                 {\r
2211                                                         dspPDidRef.PDidNr--;\r
2212                                                         ClearPeriodicIdentifierBuffer(dspPDidRef.PDidNr,PdidPostion);\r
2213                                                 }\r
2214                                         }\r
2215                                         else\r
2216                                         {\r
2217                                                 dspPDidRef.dspPDid[PdidPostion].PDidTxCounterNumber = periodicTransmitCounter;\r
2218                                                 pduTxData->SduLength = 1;\r
2219                                         }\r
2220                                 }\r
2221                                 else\r
2222                                 {       \r
2223                                         responseCode = DspSavePeriodicData((DCM_PERODICDID_HIHG_MASK + (uint16)PDidLowByte),periodicTransmitCounter,PdidBufferNr);\r
2224                                         PdidBufferNr++;\r
2225                                         pduTxData->SduLength = 1;\r
2226                                 }\r
2227                         }\r
2228                         else if((PdidNumber + PdidBufferNr) <= DCM_LIMITNUMBER_PERIODDATA)      /*UDS_REQ_0x2A_6*/\r
2229                         {       \r
2230                                 for(i = 0;(i < PdidNumber)&&(responseCode == DCM_E_POSITIVERESPONSE);i++)\r
2231                                 {\r
2232                                         PDidLowByte = pduRxData->SduDataPtr[2 + i];\r
2233                                         if(checkPeriodicIdentifierBuffer(PDidLowByte,PdidBufferNr,&PdidPostion) == TRUE)\r
2234                                         {\r
2235                                                 if(dspPDidRef.dspPDid[PdidPostion].PDidTxCounterNumber != periodicTransmitCounter)\r
2236                                                 {\r
2237                                                         dspPDidRef.dspPDid[PdidPostion].PDidTxCounterNumber = periodicTransmitCounter;\r
2238                                                 }\r
2239                                         }\r
2240                                         else\r
2241                                         {\r
2242                                                 responseCode = DspSavePeriodicData((0xF200 + (uint16)PDidLowByte),periodicTransmitCounter,PdidBufferNr);\r
2243                                                 PdidBufferNr++;\r
2244                                         }\r
2245                                                 pduTxData->SduLength = 1;\r
2246                                 }\r
2247                         }\r
2248                         else\r
2249                         {\r
2250                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2251                         }\r
2252                         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2253                         {                                       \r
2254                                 dspPDidRef.PDidNr = PdidBufferNr;                               \r
2255                         }\r
2256                 }                                                       \r
2257         }\r
2258         else if((pduRxData->SduLength == 2)&&(pduRxData->SduDataPtr[1] == DCM_PERIODICTRANSMIT_STOPSENDING_MODE))\r
2259         {\r
2260                 memset(&dspPDidRef,0,sizeof(dspPDidRef));\r
2261                 pduTxData->SduLength = 1;\r
2262         }\r
2263         else\r
2264         {\r
2265                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2266         }\r
2267         DsdDspProcessingDone(responseCode);\r
2268 }\r
2269 \r
2270 static Dcm_NegativeResponseCodeType dynamicallyDefineDataIdentifierbyDid(uint16 DDIdentifier,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2271 {\r
2272         uint8 i;\r
2273         uint16 SourceDidNr;\r
2274         const Dcm_DspDidType *SourceDid = NULL;\r
2275         Dcm_DspDDDType *DDid = NULL;\r
2276         uint16 SourceLength = 0;\r
2277         uint16 DidLength = 0;\r
2278         uint16 Length = 0;\r
2279         uint8 Num = 0;\r
2280         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2281 \r
2282         if(FALSE == LookupDDD(DDIdentifier, (const Dcm_DspDDDType **)&DDid))\r
2283         {\r
2284                 while((Num < DCM_MAX_DDD_NUMBER) && (dspDDD[Num].DynamicallyDid != 0 ))\r
2285                 {\r
2286                         Num++;\r
2287                 }\r
2288                 if(Num >= DCM_MAX_DDD_NUMBER)\r
2289                 {\r
2290                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2291                 }\r
2292                 else\r
2293                 {\r
2294                         DDid = &dspDDD[Num];\r
2295                 }\r
2296         }\r
2297         else\r
2298         {\r
2299                 while((SourceLength < DCM_MAX_DDDSOURCE_NUMBER) && (DDid->DDDSource[SourceLength].formatOrPosition != 0 ))\r
2300                 {\r
2301                         SourceLength++;\r
2302                 }\r
2303                 if(SourceLength > DCM_MAX_DDDSOURCE_NUMBER)\r
2304                 {\r
2305                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2306                 }\r
2307         }\r
2308         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2309         {\r
2310                 Length = (pduRxData->SduLength - SID_AND_ALFID_LEN4) /SID_AND_ALFID_LEN4;\r
2311                 if(((Length*SID_AND_ALFID_LEN4) == (pduRxData->SduLength - SID_AND_ALFID_LEN4)) && (Length != 0))\r
2312                 {\r
2313                         if((Length + SourceLength) <= DCM_MAX_DDDSOURCE_NUMBER)\r
2314                         {\r
2315                                 for(i = 0;(i < Length) && (responseCode == DCM_E_POSITIVERESPONSE);i++)\r
2316                                 {\r
2317                                         SourceDidNr = (((uint16)pduRxData->SduDataPtr[SID_AND_ALFID_LEN4 + i*SID_AND_ALFID_LEN4] << 8) & DCM_DID_HIGH_MASK) + (((uint16)pduRxData->SduDataPtr[(5 + i*SID_AND_ALFID_LEN4)]) & DCM_DID_LOW_MASK);\r
2318                                         if(TRUE == lookupDid(SourceDidNr, &SourceDid))/*UDS_REQ_0x2C_4*/\r
2319                                         {       \r
2320                                                 if(DspCheckSessionLevel(SourceDid->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSessionRef))\r
2321                                                 {\r
2322                                                         if(DspCheckSecurityLevel(SourceDid->DspDidInfoRef->DspDidAccess.DspDidRead->DspDidReadSecurityLevelRef))\r
2323                                                         {\r
2324                                                                 if(SourceDid->DspDidInfoRef->DspDidFixedLength == TRUE)\r
2325                                                                 {\r
2326                                                                         DidLength = SourceDid->DspDidSize;\r
2327                                                                 }\r
2328                                                                 else\r
2329                                                                 {\r
2330                                                                         if(     SourceDid->DspDidReadDataLengthFnc != NULL)\r
2331                                                                         {\r
2332                                                                                 SourceDid->DspDidReadDataLengthFnc(&DidLength);\r
2333                                                                         }\r
2334                                                                 }\r
2335                                                                 if(DidLength != 0)\r
2336                                                                 {\r
2337                                                                         if((pduRxData->SduDataPtr[SID_AND_ALFID_LEN6 + i*SID_AND_ALFID_LEN4] != 0) &&\r
2338                                                                                 (pduRxData->SduDataPtr[SID_AND_ALFID_LEN7 + i*SID_AND_ALFID_LEN4] != 0) &&\r
2339                                                                                 (((uint16)pduRxData->SduDataPtr[SID_AND_ALFID_LEN6 + i*SID_AND_ALFID_LEN4] + (uint16)pduRxData->SduDataPtr[SID_AND_ALFID_LEN7 + i*SID_AND_ALFID_LEN4] - 1) <= DidLength))\r
2340                                                                         {\r
2341                                                                                 DDid->DDDSource[i + SourceLength].formatOrPosition = pduRxData->SduDataPtr[SID_AND_ALFID_LEN6 + i*SID_AND_ALFID_LEN4];\r
2342                                                                                 DDid->DDDSource[i + SourceLength].Size = pduRxData->SduDataPtr[SID_AND_ALFID_LEN7 + i*SID_AND_ALFID_LEN4];\r
2343                                                                                 DDid->DDDSource[i + SourceLength].SourceAddressOrDid = SourceDid->DspDidIdentifier;\r
2344                                                                                 DDid->DDDSource[i + SourceLength].DDDTpyeID = DCM_DDD_SOURCE_DID;\r
2345                                                                         }\r
2346                                                                         else\r
2347                                                                         {\r
2348                                                                                 /*UDS_REQ_0x2C_6*/\r
2349                                                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2350                                                                         }\r
2351                                                                         \r
2352                                                                 }\r
2353                                                                 else\r
2354                                                                 {\r
2355                                                                         /*UDS_REQ_0x2C_14*/\r
2356                                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2357                                                                 }\r
2358                                                         }\r
2359                                                         else\r
2360                                                         {\r
2361                                                                 responseCode = DCM_E_SECUTITYACCESSDENIED;\r
2362                                                         }\r
2363                                                 }\r
2364                                                 else\r
2365                                                 {\r
2366                                                         /*UDS_REQ_0x2C_19,DCM726*/\r
2367                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2368                                                 }\r
2369                                         }\r
2370                                         else\r
2371                                         {\r
2372                                                 /*DCM725*/\r
2373                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2374                                         }\r
2375                                 }\r
2376                         }\r
2377                         else\r
2378                         {\r
2379                                 /*UDS_REQ_0x2C_13*/\r
2380                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2381                         }\r
2382                 }\r
2383                 else\r
2384                 {\r
2385                         /*UDS_REQ_0x2C_11*/\r
2386                         responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2387                 }\r
2388                 if(responseCode == DCM_E_POSITIVERESPONSE)\r
2389                 {\r
2390                         DDid->DynamicallyDid = DDIdentifier;\r
2391                         pduTxData->SduDataPtr[1] = DCM_DDD_SUBFUNCTION_DEFINEBYDID;\r
2392                 }\r
2393         }\r
2394         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2395         {\r
2396                 pduTxData->SduDataPtr[1] = DCM_DDD_SUBFUNCTION_DEFINEBYDID;\r
2397         }\r
2398         \r
2399         return responseCode;\r
2400 }\r
2401 \r
2402 static Dcm_NegativeResponseCodeType dynamicallyDefineDataIdentifierbyAddress(uint16 DDIdentifier,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2403 {\r
2404         uint8 LengthCount;\r
2405         uint8 SourceCount;\r
2406         uint16 Length;\r
2407         uint8 AddressFormat;\r
2408         uint8 MemorySizeFormat;\r
2409         uint32 MemoryAddress = 0;\r
2410         uint16 MemorySize = 0;\r
2411         uint16 SourceLength = 0;\r
2412         Dcm_DspDDDType *DDid = NULL;\r
2413         const Dcm_DspMemoryIdInfo *SourceMemoryInfo = NULL;\r
2414         uint8 Num = 0;\r
2415         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2416         \r
2417         if(FALSE == LookupDDD(DDIdentifier, (const Dcm_DspDDDType **)&DDid))\r
2418         {\r
2419                 while((Num < DCM_MAX_DDD_NUMBER) && (dspDDD[Num].DynamicallyDid != 0 ))\r
2420                 {\r
2421                         Num++;\r
2422                 }\r
2423                 if(Num >= DCM_MAX_DDD_NUMBER)\r
2424                 {\r
2425                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2426                 }\r
2427                 else\r
2428                 {\r
2429                         DDid = &dspDDD[Num];\r
2430                 }\r
2431         }\r
2432         else\r
2433         {\r
2434                 while((SourceLength < DCM_MAX_DDDSOURCE_NUMBER) && (DDid->DDDSource[SourceLength].formatOrPosition != 0 ))\r
2435                 {\r
2436                         SourceLength++;\r
2437                 }\r
2438                 if(SourceLength >= DCM_MAX_DDDSOURCE_NUMBER)\r
2439                 {\r
2440                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2441                 }\r
2442         }\r
2443         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2444         {\r
2445                 AddressFormat = (uint8)pduRxData->SduDataPtr[4] & DCM_FORMAT_LOW_MASK;\r
2446                 MemorySizeFormat = (uint8)(pduRxData->SduDataPtr[4] >> 4) & DCM_FORMAT_LOW_MASK;\r
2447                 if((AddressFormat+MemorySizeFormat) != 0)\r
2448                 {\r
2449                         Length = (pduRxData->SduLength - SID_AND_ALFID_LEN5) / (AddressFormat + MemorySizeFormat);\r
2450                 }\r
2451                 if((AddressFormat != 0) && (MemorySizeFormat != 0) && ((SourceLength+Length) <= DCM_MAX_DDDSOURCE_NUMBER))\r
2452                 {\r
2453                         if((Length != 0)&&( Length * (AddressFormat + MemorySizeFormat) == (pduRxData->SduLength - 5) ))\r
2454                         {\r
2455                                 for(LengthCount = 0; (LengthCount < Length) && (responseCode == DCM_E_POSITIVERESPONSE); LengthCount++)\r
2456                                 {\r
2457                                         MemoryAddress = 0;\r
2458                                         for(SourceCount = 0; SourceCount < AddressFormat; SourceCount++)\r
2459                                         {\r
2460                                                 MemoryAddress = MemoryAddress << 8;\r
2461                                                 MemoryAddress += (uint32)(pduRxData->SduDataPtr[5 + SourceCount + LengthCount * (AddressFormat + MemorySizeFormat)]);\r
2462                                         }\r
2463 \r
2464                                         /*take value of MemorySize out */\r
2465                                         MemorySize = 0;\r
2466                                         for(SourceCount = 0; SourceCount < MemorySizeFormat; SourceCount++)\r
2467                                         {\r
2468                                                 MemorySize = MemorySize << 8;\r
2469                                                 MemorySize += (uint32)(pduRxData->SduDataPtr[5 + SourceCount + AddressFormat + LengthCount * (AddressFormat + MemorySizeFormat)]);\r
2470                                         }\r
2471                                         if(TRUE == lookupReadMemory(MemoryAddress, AddressFormat,MemorySize,&SourceMemoryInfo))\r
2472                                         {\r
2473                                                 if(DspCheckSecurityLevel(SourceMemoryInfo->pReadMemoryInfo->pSecurityLevel) == TRUE)\r
2474                                                 {\r
2475                                                         DDid->DDDSource[LengthCount + SourceLength].formatOrPosition = pduRxData->SduDataPtr[4];\r
2476                                                         DDid->DDDSource[LengthCount + SourceLength].SourceAddressOrDid = MemoryAddress;\r
2477                                                         DDid->DDDSource[LengthCount + SourceLength].Size = MemorySize;\r
2478                                                         DDid->DDDSource[LengthCount + SourceLength].DDDTpyeID = DCM_DDD_SOURCE_ADDRESS;\r
2479                                                         /*UDS_REQ_0x2C_6*/\r
2480                                                 }\r
2481                                                 else\r
2482                                                 {\r
2483                                                         /*UDS_REQ_0x2C_19,DCM726*/\r
2484                                                         responseCode = DCM_E_SECUTITYACCESSDENIED;\r
2485                                                 }\r
2486                                         }\r
2487                                         else\r
2488                                         {\r
2489                                                 /*UDS_REQ_0x2C_15,UDS_REQ_0x2C_16*/\r
2490                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2491                                         }\r
2492                                 }\r
2493                                 if(responseCode == DCM_E_POSITIVERESPONSE)\r
2494                                 {\r
2495                                         DDid->DynamicallyDid = DDIdentifier;\r
2496                                 }\r
2497                         }\r
2498                         else\r
2499                         {\r
2500                                 /*UDS_REQ_0x2C_11*/\r
2501                                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2502                         }\r
2503                 }\r
2504                 else\r
2505                 {\r
2506                         /*UDS_REQ_0x2C_17, UDS_REQ_0x2C_18*/\r
2507                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2508                 }\r
2509 \r
2510         }\r
2511         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2512         {\r
2513                 pduTxData->SduDataPtr[1] = DCM_DDD_SUBFUNCTION_DEFINEBYADDRESS;\r
2514         }\r
2515         \r
2516         return responseCode;\r
2517 }\r
2518 \r
2519 \r
2520 /*\r
2521         DESCRIPTION:\r
2522                  UDS Service 0x2c - Clear dynamically Did\r
2523 */\r
2524 static Dcm_NegativeResponseCodeType CleardynamicallyDid(uint16 DDIdentifier,const PduInfoType *pduRxData, PduInfoType * pduTxData)\r
2525 {\r
2526         /*UDS_REQ_0x2C_5*/\r
2527         uint8 i;\r
2528         uint8 ClearCount;\r
2529         uint8 position;\r
2530         uint8 ClearNum = 0;\r
2531         Dcm_DspDDDType *DDid = NULL;\r
2532         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2533         \r
2534         if(pduRxData->SduLength == 4)\r
2535         {\r
2536                 if(TRUE == LookupDDD(DDIdentifier, (const Dcm_DspDDDType **)&DDid))\r
2537                 {\r
2538                         \r
2539                         if((checkPeriodicIdentifierBuffer(pduRxData->SduDataPtr[3], dspPDidRef.PDidNr, &position) == TRUE)&&(pduRxData->SduDataPtr[2] == 0xF2))\r
2540                         {\r
2541                                 /*UDS_REQ_0x2C_9*/\r
2542                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2543                         }\r
2544                         else\r
2545                         {\r
2546                                 for(i = 1;i < DCM_MAX_DDD_NUMBER;i++)\r
2547                                 {\r
2548                                         if(0 == dspDDD[i].DynamicallyDid)\r
2549                                         {\r
2550                                                 ClearNum = i - 1;\r
2551                                                 DDid->DynamicallyDid = dspDDD[ClearNum].DynamicallyDid;\r
2552                                                 dspDDD[ClearNum].DynamicallyDid = 0;\r
2553                                                 for(ClearCount = 0;ClearCount < DCM_MAX_DDDSOURCE_NUMBER;ClearCount++)\r
2554                                                 {\r
2555                                                         /*DCM647*/\r
2556                                                         DDid->DDDSource[ClearCount].DDDTpyeID = dspDDD[ClearNum].DDDSource[ClearCount].DDDTpyeID;\r
2557                                                         DDid->DDDSource[ClearCount].formatOrPosition = dspDDD[ClearNum].DDDSource[ClearCount].formatOrPosition;\r
2558                                                         DDid->DDDSource[ClearCount].SourceAddressOrDid = dspDDD[ClearNum].DDDSource[ClearCount].SourceAddressOrDid;\r
2559                                                         DDid->DDDSource[ClearCount].Size = dspDDD[ClearNum].DDDSource[ClearCount].Size;\r
2560                                                         dspDDD[ClearNum].DDDSource[ClearCount].DDDTpyeID = 0;\r
2561                                                         dspDDD[ClearNum].DDDSource[ClearCount].formatOrPosition = 0;\r
2562                                                         dspDDD[ClearNum].DDDSource[ClearCount].SourceAddressOrDid = 0;\r
2563                                                         dspDDD[ClearNum].DDDSource[ClearCount].Size = 0;\r
2564                                                 }       \r
2565                                         }       \r
2566                                 }\r
2567                         }\r
2568                 }               \r
2569         }\r
2570         else\r
2571         {\r
2572                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2573         }\r
2574         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2575         {\r
2576                 pduTxData->SduDataPtr[1] = DCM_DDD_SUBFUNCTION_CLEAR;\r
2577                 pduTxData->SduLength = 2;\r
2578         }\r
2579         \r
2580         return responseCode;\r
2581 }\r
2582 \r
2583 void DspDynamicallyDefineDataIdentifier(const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2584 {\r
2585         /*UDS_REQ_0x2C_1,DCM 259*/\r
2586         uint16 i;\r
2587         uint8 Position;\r
2588         boolean PeriodicdUse = FALSE;\r
2589         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2590         uint16 DDIdentifier = ((((uint16)pduRxData->SduDataPtr[2]) << 8) & DCM_DID_HIGH_MASK) + (pduRxData->SduDataPtr[3] & DCM_DID_LOW_MASK);\r
2591         if(pduRxData->SduLength > 2)\r
2592         {\r
2593                 /* Check if DDID equals 0xF2 or 0xF3 */\r
2594                 if((pduRxData->SduDataPtr[2] & 0xF2) == 0xF2)\r
2595                 {\r
2596                         switch(pduRxData->SduDataPtr[1])        /*UDS_REQ_0x2C_2,DCM 646*/\r
2597                         {\r
2598                                 case DCM_DDD_SUBFUNCTION_DEFINEBYDID:\r
2599                                         responseCode  = dynamicallyDefineDataIdentifierbyDid(DDIdentifier,pduRxData,pduTxData);\r
2600                                         break;\r
2601                                 case DCM_DDD_SUBFUNCTION_DEFINEBYADDRESS:\r
2602                                         responseCode = dynamicallyDefineDataIdentifierbyAddress(DDIdentifier,pduRxData,pduTxData);\r
2603                                         break;\r
2604                                 case DCM_DDD_SUBFUNCTION_CLEAR:\r
2605                                         responseCode = CleardynamicallyDid(DDIdentifier,pduRxData,pduTxData);\r
2606                                         break;\r
2607                                 default:\r
2608                                         responseCode = DCM_E_SUBFUNCTIONNOTSUPPORTED;\r
2609                                         /*UDS_REQ_0x2C_10*/\r
2610                                         break;          \r
2611                         }\r
2612                 }\r
2613                 else\r
2614                 {\r
2615                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2616                 }\r
2617                 if(responseCode == DCM_E_POSITIVERESPONSE)\r
2618                 {\r
2619                         pduTxData->SduDataPtr[2] = pduRxData->SduDataPtr[2];\r
2620                         pduTxData->SduDataPtr[3] = pduRxData->SduDataPtr[3];\r
2621                         pduTxData->SduLength = 4;\r
2622                 }\r
2623         }\r
2624         else if((pduRxData->SduLength == 2)&&(pduRxData->SduDataPtr[1] == DCM_DDD_SUBFUNCTION_CLEAR))\r
2625         {\r
2626                 /*UDS_REQ_0x2C_7*/\r
2627                 for(i = 0;i < DCM_MAX_DDD_NUMBER;i++)\r
2628                 {\r
2629                         if(checkPeriodicIdentifierBuffer((uint8)(dspDDD[i].DynamicallyDid & DCM_DID_LOW_MASK),dspPDidRef.PDidNr,&Position) == TRUE)\r
2630                         {\r
2631                                 PeriodicdUse = TRUE;\r
2632                         }\r
2633                 }\r
2634                 if(PeriodicdUse == FALSE)\r
2635                 {\r
2636                         memset(dspDDD,0,sizeof(dspDDD));\r
2637                         pduTxData->SduDataPtr[1] = DCM_DDD_SUBFUNCTION_CLEAR;\r
2638                         pduTxData->SduLength = 2;\r
2639                 }\r
2640                 else\r
2641                 {\r
2642                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2643                 }\r
2644         }\r
2645         else\r
2646         {\r
2647                 /*UDS_REQ_0x2C_11*/\r
2648                 responseCode =  DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2649         }\r
2650         DsdDspProcessingDone(responseCode);\r
2651 }\r
2652 \r
2653 static Dcm_NegativeResponseCodeType DspIOControlReturnControlToECU(const Dcm_DspDidType *DidPtr,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2654 {\r
2655         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2656         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidReturnControlToEcu == TRUE)\r
2657         {\r
2658                 if(pduRxData->SduLength > 4)\r
2659                 {\r
2660                         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl != NULL)\r
2661                         {\r
2662                                 if(((DidPtr->DspDidControlRecordSize->DspDidControlRecordSize + 7) >> 3) == (pduRxData->SduLength - 4))\r
2663                                 {\r
2664                                         if(DidPtr->DspDidReturnControlToEcuFnc != NULL)\r
2665                                         {\r
2666                                                 DidPtr->DspDidReturnControlToEcuFnc(NULL,&pduRxData->SduDataPtr[4],&pduTxData->SduDataPtr[4],&responseCode);\r
2667                                                 \r
2668                                         }\r
2669                                         else\r
2670                                         {\r
2671                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2672                                         }\r
2673                                 }\r
2674                                 else\r
2675                                 {\r
2676                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2677                                 }\r
2678                         }\r
2679                         else\r
2680                         {\r
2681                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2682                         }\r
2683                 }\r
2684                 else\r
2685                 {\r
2686                         if(DidPtr->DspDidReturnControlToEcuFnc != NULL)\r
2687                         {\r
2688 \r
2689                                 if(DidPtr->DspDidControlRecordSize != NULL)\r
2690                                 {\r
2691                                         DidPtr->DspDidReturnControlToEcuFnc(NULL,NULL,&pduTxData->SduDataPtr[4],&responseCode);\r
2692                                         pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2693                                 }\r
2694                                 else\r
2695                                 {\r
2696                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2697                                 }\r
2698                         }\r
2699                         else\r
2700                         {\r
2701                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2702                         }\r
2703                 }\r
2704         }\r
2705         else\r
2706         {\r
2707                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2708         }\r
2709         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2710         {\r
2711                 pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2712                 pduTxData->SduDataPtr[3] = DCM_RETURN_CONTROL_TO_ECU;\r
2713         }\r
2714         \r
2715         return responseCode;\r
2716 }\r
2717 \r
2718 static Dcm_NegativeResponseCodeType DspIOControlResetToDefault(const Dcm_DspDidType *DidPtr,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2719 {\r
2720         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2721         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidResetToDefault == TRUE)\r
2722         {\r
2723                 if(pduRxData->SduLength > 4)\r
2724                 {\r
2725                         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl != NULL)\r
2726                         {\r
2727                                 if(((DidPtr->DspDidControlRecordSize->DspDidControlRecordSize + 7) >> 3) == (pduRxData->SduLength - 4))\r
2728                                 {\r
2729                                         if(DidPtr->DspDidReturnControlToEcuFnc != NULL)\r
2730                                         {\r
2731                                                 DidPtr->DspDidResetToDeaultFnc(NULL,&pduRxData->SduDataPtr[4],&pduTxData->SduDataPtr[4],&responseCode);\r
2732                                         }\r
2733                                         else\r
2734                                         {\r
2735                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2736                                         }\r
2737                                 }\r
2738                                 else\r
2739                                 {\r
2740                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2741                                 }\r
2742                         }\r
2743                         else\r
2744                         {\r
2745                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2746                         }\r
2747                 }\r
2748                 else\r
2749                 {\r
2750                         if(DidPtr->DspDidResetToDeaultFnc != NULL)\r
2751                         {\r
2752 \r
2753                                 if(DidPtr->DspDidControlRecordSize != NULL)\r
2754                                 {\r
2755                                         DidPtr->DspDidResetToDeaultFnc(NULL,NULL,&pduTxData->SduDataPtr[4],&responseCode);\r
2756                                         pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2757                                 }\r
2758                                 else\r
2759                                 {\r
2760                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2761                                 }\r
2762                         }\r
2763                         else\r
2764                         {\r
2765                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2766                         }\r
2767                 }\r
2768         }\r
2769         else\r
2770         {\r
2771                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2772         }\r
2773         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2774         {\r
2775                 pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize+4;\r
2776                 pduTxData->SduDataPtr[3] = DCM_RESET_TO_DEFAULT;\r
2777         }\r
2778         return responseCode;\r
2779 }\r
2780 /*\r
2781         DESCRIPTION:\r
2782                  UDS Service 0x2F -  IOControl Freeze Current State\r
2783 */\r
2784 static Dcm_NegativeResponseCodeType DspIOControlFreezeCurrentState(const Dcm_DspDidType *DidPtr,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2785 {\r
2786         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2787         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidFreezeCurrentState == TRUE)\r
2788         {\r
2789                 if(pduRxData->SduLength > 4)\r
2790                 {\r
2791                         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl != NULL)\r
2792                         {\r
2793                                 if(((DidPtr->DspDidControlRecordSize->DspDidControlRecordSize + 7) >> 3) == (pduRxData->SduLength - 4))\r
2794                                 {\r
2795                                         if(DidPtr->DspDidFreezeCurrentStateFnc != NULL)\r
2796                                         {\r
2797                                                 DidPtr->DspDidFreezeCurrentStateFnc(NULL,&pduRxData->SduDataPtr[4],&pduTxData->SduDataPtr[4],&responseCode);\r
2798                                         }\r
2799                                         else\r
2800                                         {\r
2801                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2802                                         }\r
2803                                 }\r
2804                                 else\r
2805                                 {\r
2806                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2807                                 }\r
2808                         }\r
2809                         else\r
2810                         {\r
2811                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2812                         }\r
2813                 }\r
2814                 else\r
2815                 {\r
2816                         if(DidPtr->DspDidFreezeCurrentStateFnc != NULL)\r
2817                         {\r
2818 \r
2819                                 if(DidPtr->DspDidControlRecordSize != 0)\r
2820                                 {\r
2821                                         DidPtr->DspDidFreezeCurrentStateFnc(NULL,NULL,&pduTxData->SduDataPtr[4],&responseCode);\r
2822                                         pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2823                                 }\r
2824                                 else\r
2825                                 {\r
2826                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2827                                 }\r
2828                         }\r
2829                         else\r
2830                         {\r
2831                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2832                         }\r
2833                 }\r
2834         }\r
2835         else\r
2836         {\r
2837                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2838         }\r
2839         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2840         {\r
2841                 pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2842                 pduTxData->SduDataPtr[3] = DCM_FREEZE_CURRENT_STATE;\r
2843         }\r
2844         \r
2845         return responseCode;\r
2846 }\r
2847 \r
2848 static Dcm_NegativeResponseCodeType DspIOControlShortTeamAdjustment(const Dcm_DspDidType *DidPtr,const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2849 {\r
2850         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2851         uint8 didControlOptionRecordSize = DidPtr->DspDidControlRecordSize->DspDidControlOptionRecordSize;\r
2852         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidShortTermAdjustment == TRUE)\r
2853         {\r
2854                 if(pduRxData->SduLength > 4)\r
2855                 {\r
2856                         if(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl != NULL)\r
2857                         {\r
2858                                 if(((((DidPtr->DspDidControlRecordSize->DspDidControlRecordSize + 7)) >> 3) + (didControlOptionRecordSize)) == (pduRxData->SduLength - 4))\r
2859                                 {\r
2860                                         if(DidPtr->DspDidShortTermAdjustmentFnc != NULL)\r
2861                                         {\r
2862                                                 DidPtr->DspDidShortTermAdjustmentFnc(&pduRxData->SduDataPtr[4],&pduRxData->SduDataPtr[4 + didControlOptionRecordSize],&pduTxData->SduDataPtr[4],&responseCode);\r
2863                                         }\r
2864                                         else\r
2865                                         {\r
2866                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2867                                         }\r
2868                                 }\r
2869                                 else if((didControlOptionRecordSize) == (pduRxData->SduLength - 4))\r
2870                                 {\r
2871                                         if(DidPtr->DspDidShortTermAdjustmentFnc != NULL)\r
2872                                         {\r
2873                                                 DidPtr->DspDidShortTermAdjustmentFnc(&pduRxData->SduDataPtr[4],NULL,&pduTxData->SduDataPtr[4],&responseCode);\r
2874                                         }\r
2875                                         else\r
2876                                         {\r
2877                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2878                                         }\r
2879                                 }\r
2880                                 else\r
2881                                 {\r
2882                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2883                                 }\r
2884                         }\r
2885                         else \r
2886                         {\r
2887                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2888                         }\r
2889                 }\r
2890                 else\r
2891                 {\r
2892                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2893                 }\r
2894         }\r
2895         else\r
2896         {\r
2897                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2898         }\r
2899         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2900         {\r
2901                 pduTxData->SduLength = DidPtr->DspDidControlRecordSize->DspDidControlStatusRecordSize + 4;\r
2902                 pduTxData->SduDataPtr[3] = DCM_SHORT_TERM_ADJUSTMENT;\r
2903         }\r
2904         \r
2905         return responseCode;\r
2906 }\r
2907 \r
2908 void DspIOControlByDataIdentifier(const PduInfoType *pduRxData,PduInfoType *pduTxData)\r
2909 {\r
2910         uint16 didNr;\r
2911         const Dcm_DspDidType *DidPtr = NULL;\r
2912         Dcm_NegativeResponseCodeType responseCode = DCM_E_POSITIVERESPONSE;\r
2913         didNr = (pduRxData->SduDataPtr[1] << 8 & DCM_DID_HIGH_MASK) + (pduRxData->SduDataPtr[2] & DCM_DID_LOW_MASK);\r
2914         if(pduRxData->SduLength > 3)\r
2915         {\r
2916                 if(TRUE == lookupDid(didNr, &DidPtr))\r
2917                 {\r
2918                         if(FALSE == DidPtr->DspDidUsePort)\r
2919                         {\r
2920                                 if(NULL != DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl)\r
2921                                 {\r
2922                                         if(TRUE == DspCheckSessionLevel(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidControlSessionRef))\r
2923                                         {\r
2924                                                 if(TRUE == DspCheckSecurityLevel(DidPtr->DspDidInfoRef->DspDidAccess.DspDidControl->DspDidControlSecurityLevelRef))\r
2925                                                 {\r
2926                                                         switch(pduRxData->SduDataPtr[3])\r
2927                                                         {\r
2928                                                                 case DCM_RETURN_CONTROL_TO_ECU:\r
2929                                                                         responseCode = DspIOControlReturnControlToECU(DidPtr,pduRxData,pduTxData);\r
2930                                                                         break;\r
2931                                                                 case DCM_RESET_TO_DEFAULT:\r
2932                                                                         responseCode = DspIOControlResetToDefault(DidPtr,pduRxData,pduTxData);                                                          \r
2933                                                                         break;\r
2934                                                                 case DCM_FREEZE_CURRENT_STATE:\r
2935                                                                         responseCode = DspIOControlFreezeCurrentState(DidPtr,pduRxData,pduTxData);\r
2936                                                                         break;\r
2937                                                                 case DCM_SHORT_TERM_ADJUSTMENT:\r
2938                                                                         responseCode = DspIOControlShortTeamAdjustment(DidPtr,pduRxData,pduTxData);\r
2939                                                                         break;\r
2940                                                                 default:\r
2941                                                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2942                                                                         break;\r
2943                                                                 \r
2944                                                         }\r
2945                                                 }\r
2946                                                 else\r
2947                                                 {\r
2948                                                         responseCode = DCM_E_SECUTITYACCESSDENIED;\r
2949                                                 }\r
2950                                         }\r
2951                                         else\r
2952                                         {\r
2953                                                 responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2954                                         }\r
2955                                 }\r
2956                                 else\r
2957                                 {\r
2958                                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2959                                 }\r
2960                         }\r
2961                         else\r
2962                         {\r
2963                                 /* if UsePort == True, NRC 0x10 */\r
2964                                 responseCode = DCM_E_GENERALREJECT;\r
2965                         }\r
2966                 }\r
2967                 else\r
2968                 {\r
2969                         responseCode = DCM_E_REQUESTOUTOFRANGE;\r
2970                 }\r
2971         }\r
2972         else\r
2973         {\r
2974                 responseCode = DCM_E_INCORRECTMESSAGELENGTHORINVALIDFORMAT;\r
2975         }\r
2976         if(responseCode == DCM_E_POSITIVERESPONSE)\r
2977         {\r
2978                 pduTxData->SduDataPtr[1] = pduRxData->SduDataPtr[1];\r
2979                 pduTxData->SduDataPtr[2] = pduRxData->SduDataPtr[2];\r
2980         }\r
2981         DsdDspProcessingDone(responseCode);\r
2982 }\r