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