diagnostic/Dem/Dem.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 // 904 PC-Lint MISRA 14.7: OK. Allow VALIDATE, VALIDATE_RV and VALIDATE_NO_RV to return value.\r
  17 //lint -emacro(904,VALIDATE_RV,VALIDATE_NO_RV,VALIDATE)\r
  18 \r
  19 // 522 PC-Lint exception for empty functions\r
  20 //lint -esym(522,storeFreezeFrameDataEvtMem)\r
  21 //lint -esym(522,deleteFreezeFrameDataPriMem)\r
  22 //lint -esym(522,storeFreezeFrameDataPreInit)\r
  23 //lint -esym(522,storeFreezeFrameDataPriMem)\r
  24 //lint -esym(522,updateFreezeFrameOccurrencePreInit)\r
  25 \r
  26 // PC-Lint misunderstanding of MISRA 8.12, 18.1: Empty arrays are OK as long as size 0 is specified.\r
  27 //lint -esym(85,preInitFreezeFrameBuffer)\r
  28 //lint -esym(85,priMemFreezeFrameBuffer)\r
  29 \r
  30 \r
  31 /*\r
  32  *  General requirements\r
  33  */\r
  34 /** @req DEM126 */\r
  35 /** @req DEM151.partially */\r
  36 /** @req DEM152 */\r
  37 /** @req DEM013.14229-1 */\r
  38 /** @req DEM277 */\r
  39 /** @req DEM363 */\r
  40 /** @req DEM113 */ /** @req DEM174 */\r
  41 /** @req DEM286 */\r
  42 /** @req DEM267 */\r
  43 /** @req DEM364 */\r
  44 /** @req DEM114 */\r
  45 /** @req DEM124 */\r
  46 /** @req DEM370 */\r
  47 \r
  48 \r
  49 \r
  50 #include <string.h>\r
  51 #include "Dem.h"\r
  52 //#include "Fim.h"\r
  53 #include "NvM.h"\r
  54 //#include "SchM_Dem.h"\r
  55 #include "MemMap.h"\r
  56 #include "Cpu.h"\r
  57 #include "Dem_Types.h"\r
  58 #include "Dem_Lcfg.h"\r
  59 \r
  60 #define USE_DEBUG_PRINTF\r
  61 #include "debug.h"\r
  62 /*\r
  63  * Local defines\r
  64  */\r
  65 #define DEBOUNCE_FDC_TEST_FAILED  127\r
  66 #define DEBOUNCE_FDC_TEST_PASSED -128\r
  67 \r
  68 #if  ( DEM_DEV_ERROR_DETECT == STD_ON )\r
  69 #include "Det.h"\r
  70 /** @req DEM117 */\r
  71 #define VALIDATE_RV(_exp,_api,_err,_rv ) \\r
  72         if( !(_exp) ) { \\r
  73           Det_ReportError(MODULE_ID_DEM, 0, _api, _err); \\r
  74           return _rv; \\r
  75         }\r
  76 \r
  77 #define VALIDATE_NO_RV(_exp,_api,_err ) \\r
  78   if( !(_exp) ) { \\r
  79           Det_ReportError(MODULE_ID_DEM, 0, _api, _err); \\r
  80           return; \\r
  81         }\r
  82 #define DET_REPORTERROR(_x,_y,_z,_q) Det_ReportError(_x, _y, _z, _q)\r
  83 \r
  84 #else\r
  85 #define VALIDATE_RV(_exp,_api,_err,_rv )\r
  86 #define VALIDATE_NO_RV(_exp,_api,_err )\r
  87 #define DET_REPORTERROR(_x,_y,_z,_q)\r
  88 #endif\r
  89 \r
  90 #if (DEM_OBD_SUPPORT == STD_ON)\r
  91 #error "DEM_OBD_SUPPORT is set to STD_ON, this is not supported by the code."\r
  92 #endif\r
  93 \r
  94 #if (DEM_PTO_SUPPORT == STD_ON)\r
  95 #error "DEM_PTO_SUPPORT is set to STD_ON, this is not supported by the code."\r
  96 #endif\r
  97 \r
  98 #if (DEM_TYPE_OF_DTC_SUPPORTED != 0x01)\r
  99 #error "DEM_TYPE_OF_DTC_SUPPORTED is not set to 1 (ISO14229-1), only ISO14229-1 is currently supported by the code."\r
 100 #endif\r
 101 \r
 102 \r
 103 /*\r
 104  * Local types\r
 105  */\r
 106 #if !defined(USE_DCM)\r
 107 typedef uint8 Dcm_NegativeResponseCodeType;\r
 108 #define DCM_E_POSITIVERESPONSE ((Dcm_NegativeResponseCodeType)0x00)\r
 109 #endif\r
 110 \r
 111 // DtcFilterType\r
 112 typedef struct {\r
 113         Dem_EventStatusExtendedType dtcStatusMask;\r
 114         Dem_DTCKindType                         dtcKind;\r
 115         Dem_DTCOriginType                       dtcOrigin;\r
 116         Dem_FilterWithSeverityType      filterWithSeverity;\r
 117         Dem_DTCSeverityType                     dtcSeverityMask;\r
 118         Dem_FilterForFDCType            filterForFaultDetectionCounter;\r
 119         uint16                                          faultIndex;\r
 120 } DtcFilterType;\r
 121 \r
 122 // DisableDtcStorageType\r
 123 typedef struct {\r
 124         boolean                                         storageDisabled;\r
 125         Dem_DTCGroupType                        dtcGroup;\r
 126         Dem_DTCKindType                         dtcKind;\r
 127 } DisableDtcStorageType;\r
 128 \r
 129 // For keeping track of the events status\r
 130 typedef struct {\r
 131         Dem_EventIdType                         eventId;\r
 132         const Dem_EventParameterType *eventParamRef;\r
 133         sint8                                           faultDetectionCounter;\r
 134         uint16                                          occurrence;                             /** @req DEM011 */\r
 135         Dem_EventStatusExtendedType     eventStatusExtended;    /** @req DEM006 */\r
 136         boolean                                         errorStatusChanged;\r
 137 } EventStatusRecType;\r
 138 \r
 139 // Types for storing different event data on event memory\r
 140 typedef struct {\r
 141         Dem_EventIdType                         eventId;\r
 142         uint16                                          occurrence;\r
 143         Dem_EventStatusExtendedType eventStatusExtended;\r
 144         ChecksumType                            checksum;\r
 145 } EventRecType;\r
 146 \r
 147 typedef struct {\r
 148         Dem_EventIdType         eventId;\r
 149         uint16                          dataSize;\r
 150         uint8                           data[DEM_MAX_SIZE_EXT_DATA];\r
 151         ChecksumType            checksum;\r
 152 } ExtDataRecType;\r
 153 \r
 154 \r
 155 // State variable\r
 156 typedef enum\r
 157 {\r
 158   DEM_UNINITIALIZED = 0,\r
 159   DEM_PREINITIALIZED,\r
 160   DEM_INITIALIZED\r
 161 } Dem_StateType; /** @req DEM169 */\r
 162 \r
 163 \r
 164 static Dem_StateType demState = DEM_UNINITIALIZED;\r
 165 \r
 166 // Help pointer to configuration set\r
 167 static const Dem_ConfigSetType *configSet;\r
 168 \r
 169 /*\r
 170  * Allocation of DTC filter parameters\r
 171  */\r
 172 static DtcFilterType dtcFilter;\r
 173 \r
 174 /*\r
 175  * Allocation of Disable/Enable DTC storage parameters\r
 176  */\r
 177 static DisableDtcStorageType disableDtcStorage;\r
 178 \r
 179 /*\r
 180  * Allocation of operation cycle state list\r
 181  */\r
 182 static Dem_OperationCycleStateType operationCycleStateList[DEM_OPERATION_CYCLE_ID_ENDMARK];\r
 183 \r
 184 /*\r
 185  * Allocation of local event status buffer\r
 186  */\r
 187 static EventStatusRecType       eventStatusBuffer[DEM_MAX_NUMBER_EVENT];\r
 188 \r
 189 /*\r
 190  * Allocation of pre-init event memory (used between pre-init and init)\r
 191  */\r
 192 /** @req DEM207 */\r
 193 static FreezeFrameRecType       preInitFreezeFrameBuffer[DEM_MAX_NUMBER_FF_DATA_PRE_INIT];\r
 194 static ExtDataRecType           preInitExtDataBuffer[DEM_MAX_NUMBER_EXT_DATA_PRE_INIT];\r
 195 \r
 196 /*\r
 197  * Allocation of primary event memory ramlog (after init) in uninitialized memory\r
 198  */\r
 199 /** @req DEM162 */\r
 200 EventRecType                    priMemEventBuffer[DEM_MAX_NUMBER_EVENT_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 201 static FreezeFrameRecType       priMemFreezeFrameBuffer[DEM_MAX_NUMBER_FF_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 202 //FreezeFrameRecType        FreezeFrameMirrorBuffer[DEM_MAX_NUMBER_FF_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 203 extern FreezeFrameRecType*  FreezeFrameMirrorBuffer[];\r
 204 static ExtDataRecType           priMemExtDataBuffer[DEM_MAX_NUMBER_EXT_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 205 HealingRecType                  priMemAgingBuffer[DEM_MAX_NUMBER_AGING_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 206 extern HealingRecType                   HealingMirrorBuffer[DEM_MAX_NUMBER_AGING_PRI_MEM];\r
 207 \r
 208 /* block in NVRam, use for freezeframe */\r
 209 extern const NvM_BlockIdType FreezeFrameBlockId[DEM_MAX_NUMBER_FF_DATA_PRI_MEM];\r
 210 /* block in NVRam, use for aging */\r
 211 extern const NvM_BlockIdType HealingBlockId;\r
 212 \r
 213 \r
 214 /*\r
 215 *Allocation of freezeFrame storage timestamp,record the time order\r
 216 */\r
 217 /**private variable for freezeframe */\r
 218 static uint32 FF_TimeStamp = 0;\r
 219 \r
 220 /*\r
 221  * TRUE:        priMemFreezeFrameBuffer changed,\r
 222  * FALSE:       priMemFreezeFrameBuffer not changed\r
 223  */\r
 224 static boolean FFIsModified = FALSE;\r
 225 \r
 226 /*\r
 227  * TRUE:        priMemAgingBuffer changed,\r
 228  * FALSE:       priMemAgingBuffer not changed\r
 229  */\r
 230 static boolean AgingIsModified = FALSE;\r
 231 \r
 232 /*\r
 233  * Procedure:   zeroPriMemBuffers\r
 234  * Description: Fill the primary buffers with zeroes\r
 235  */\r
 236 //lint -save\r
 237 //lint -e84 //PC-Lint exception, size 0 is OK.\r
 238 //lint -e957    PC-Lint exception - Used only by DemTest\r
 239 void demZeroPriMemBuffers(void)\r
 240 {\r
 241         memset(priMemEventBuffer, 0, sizeof(priMemEventBuffer));\r
 242         memset(priMemFreezeFrameBuffer, 0, sizeof(priMemFreezeFrameBuffer));\r
 243         memset(priMemExtDataBuffer, 0, sizeof(priMemExtDataBuffer));\r
 244 }\r
 245 //lint -restore\r
 246 \r
 247 /*\r
 248  * Procedure:   calcChecksum\r
 249  * Description: Calculate checksum over *data to *(data+nrOfBytes-1) area\r
 250  */\r
 251 static ChecksumType calcChecksum(void *data, uint16 nrOfBytes)\r
 252 {\r
 253         uint16 i;\r
 254         uint8 *byte = (uint8*)data;\r
 255         ChecksumType sum = 0;\r
 256 \r
 257         for (i = 0; i < nrOfBytes; i++) {\r
 258                 sum += byte[i];\r
 259         }\r
 260         sum ^= 0xaaaau;\r
 261         return sum;\r
 262 }\r
 263 \r
 264 \r
 265 /*\r
 266  * Procedure:   checkDtcKind\r
 267  * Description: Return TRUE if "dtcKind" match the events DTCKind or "dtcKind"\r
 268  *                              is "DEM_DTC_KIND_ALL_DTCS" otherwise FALSE.\r
 269  */\r
 270 static boolean checkDtcKind(Dem_DTCKindType dtcKind, const Dem_EventParameterType *eventParam)\r
 271 {\r
 272         boolean result = FALSE;\r
 273 \r
 274         if (dtcKind == DEM_DTC_KIND_ALL_DTCS) {\r
 275                 result = TRUE;\r
 276         }\r
 277         else {\r
 278                 if (eventParam->DTCClassRef != NULL) {\r
 279                         if (eventParam->DTCClassRef->DTCKind == dtcKind) {\r
 280                                 result = TRUE;\r
 281                         }\r
 282                 }\r
 283         }\r
 284         return result;\r
 285 }\r
 286 \r
 287 \r
 288 /*\r
 289  * Procedure:   checkDtcGroup\r
 290  * Description: Return TRUE if "dtc" match the events DTC or "dtc" is\r
 291  *                              "DEM_DTC_GROUP_ALL_DTCS" otherwise FALSE.\r
 292  */\r
 293 static boolean checkDtcGroup(uint32 dtc, const Dem_EventParameterType *eventParam)\r
 294 {\r
 295         boolean result = FALSE;\r
 296 \r
 297         if (dtc == DEM_DTC_GROUP_ALL_DTCS) {\r
 298                 result = TRUE;\r
 299         }\r
 300         else {\r
 301                 if (eventParam->DTCClassRef != NULL) {\r
 302                         if (eventParam->DTCClassRef->DTC == dtc) {\r
 303                                 result = TRUE;\r
 304                         }\r
 305                 }\r
 306         }\r
 307         return result;\r
 308 }\r
 309 \r
 310 \r
 311 /*\r
 312  * Procedure:   checkDtcOrigin\r
 313  * Description: Return TRUE if "dtcOrigin" match any of the events DTCOrigin otherwise FALSE.\r
 314  */\r
 315 static boolean checkDtcOrigin(Dem_DTCOriginType dtcOrigin, const Dem_EventParameterType *eventParam)\r
 316 {\r
 317         boolean result = FALSE;\r
 318         boolean dtcOriginFound = FALSE;\r
 319         uint16 i;\r
 320 \r
 321         for (i = 0;(i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (!dtcOriginFound); i++){\r
 322                 dtcOriginFound = (eventParam->EventClass->EventDestination[i] == dtcOrigin);\r
 323         }\r
 324 \r
 325         if (dtcOriginFound) {\r
 326                 result = TRUE;\r
 327         }\r
 328 \r
 329         return result;\r
 330 }\r
 331 \r
 332 /*\r
 333  * Procedure:   checkDtcSeverityMask\r
 334  * Description: Return TRUE if "dtcSeverityMask" match any of the events DTC severity otherwise FALSE.\r
 335  */\r
 336 // PC-Lint (715 etc): Remove errors until function is filled.\r
 337 //lint -e{715}          Symbol not referenced\r
 338 static boolean checkDtcSeverityMask(Dem_DTCSeverityType dtcSeverityMask, const Dem_EventParameterType *eventParam)\r
 339 {\r
 340         boolean result = TRUE;\r
 341 \r
 342         // TODO: This function is optional, may be implemented here.\r
 343 \r
 344         return result;\r
 345 }\r
 346 \r
 347 \r
 348 /*\r
 349  * Procedure:   checkDtcFaultDetectionCounterMask\r
 350  * Description: TBD.\r
 351  */\r
 352 // PC-Lint (715 etc): Remove errors until function is filled.\r
 353 //lint -e{715}          Symbol not referenced\r
 354 static boolean checkDtcFaultDetectionCounter(const Dem_EventParameterType *eventParam)\r
 355 {\r
 356         boolean result = TRUE;\r
 357 \r
 358         // TODO: Not implemented yet.\r
 359 \r
 360         return result;\r
 361 }\r
 362 \r
 363 \r
 364 /*\r
 365  * Procedure:   lookupEventStatusRec\r
 366  * Description: Returns the pointer to event id parameters of "eventId" in "*eventStatusBuffer",\r
 367  *                              if not found NULL is returned.\r
 368  */\r
 369 static void lookupEventStatusRec(Dem_EventIdType eventId, EventStatusRecType **const eventStatusRec)\r
 370 {\r
 371         uint8 i;\r
 372         boolean eventIdFound = FALSE;\r
 373 \r
 374         for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && (!eventIdFound); i++) {\r
 375                 eventIdFound = (eventStatusBuffer[i].eventId == eventId);\r
 376         }\r
 377 \r
 378         if (eventIdFound) {\r
 379                 *eventStatusRec = &eventStatusBuffer[i-1];\r
 380         } else {\r
 381                 *eventStatusRec = NULL;\r
 382         }\r
 383 }\r
 384 \r
 385 \r
 386 /*\r
 387  * Procedure:   lookupEventIdParameter\r
 388  * Description: Returns the pointer to event id parameters of "eventId" in "*eventIdParam",\r
 389  *                              if not found NULL is returned.\r
 390  */\r
 391 static void lookupEventIdParameter(Dem_EventIdType eventId, const Dem_EventParameterType **const eventIdParam)\r
 392 {\r
 393         const Dem_EventParameterType *EventIdParamList = configSet->EventParameter;\r
 394 \r
 395         /* Lookup the correct event id parameters */\r
 396         uint16 i=0;\r
 397         while ((EventIdParamList[i].EventID != eventId) && (!EventIdParamList[i].Arc_EOL)) {\r
 398                 i++;\r
 399         }\r
 400 \r
 401         if (!EventIdParamList[i].Arc_EOL) {\r
 402                 *eventIdParam = &EventIdParamList[i];\r
 403         } else {\r
 404                 *eventIdParam = NULL;\r
 405         }\r
 406 }\r
 407 /*\r
 408  * Procedure:   checkEntryValid\r
 409  * Description: Returns whether event id "eventId" is a valid entry in primary memory\r
 410  */\r
 411 static boolean checkEntryValid(Dem_EventIdType eventId){\r
 412         const Dem_EventParameterType *EventIdParamList = configSet->EventParameter;\r
 413         boolean isValid = FALSE;\r
 414         uint16 i=0;\r
 415         while ((EventIdParamList[i].EventID != eventId) && (!EventIdParamList[i].Arc_EOL)) {\r
 416                 i++;\r
 417         }\r
 418 \r
 419         if (!EventIdParamList[i].Arc_EOL) {\r
 420                 // Event was found\r
 421                 uint16 index = 0;\r
 422                 for (index = 0; (index < DEM_MAX_NR_OF_EVENT_DESTINATION)\r
 423                                          && (EventIdParamList[i].EventClass->EventDestination[index] != DEM_EVENT_DESTINATION_END_OF_LIST); index++) {\r
 424                         if( DEM_DTC_ORIGIN_PRIMARY_MEMORY == EventIdParamList[i].EventClass->EventDestination[index]){\r
 425                                 // Event should be stored in primary memory.\r
 426                                 isValid = TRUE;\r
 427                         }\r
 428                 }\r
 429 \r
 430         } else {\r
 431                 // The event did not exist\r
 432         }\r
 433         return isValid;\r
 434 }\r
 435 /*\r
 436  * Procedure:   preDebounceNone\r
 437  * Description: Returns the result of the debouncing.\r
 438  */\r
 439 static Dem_EventStatusType preDebounceNone(const Dem_EventStatusType reportedStatus, const EventStatusRecType* statusRecord) {\r
 440         Dem_EventStatusType returnCode;\r
 441         (void)statusRecord;             // Just to get rid of PC-Lint warnings\r
 442 \r
 443         switch (reportedStatus) {\r
 444         case DEM_EVENT_STATUS_FAILED: /** @req DEM091.NoneFailed */\r
 445         case DEM_EVENT_STATUS_PASSED: /** @req DEM091.NonePassed */\r
 446                 // Already debounced, do nothing.\r
 447                 break;\r
 448 \r
 449         default:\r
 450                 // TODO: What to do with PREFAIL and PREPASSED on no debouncing?\r
 451                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_PREDEBOUNCE_NONE_ID, DEM_E_PARAM_DATA);\r
 452                 break;\r
 453         }\r
 454 \r
 455         returnCode = reportedStatus;\r
 456         return returnCode;\r
 457 }\r
 458 \r
 459 \r
 460 /*\r
 461  * Procedure:   preDebounceCounterBased\r
 462  * Description: Returns the result of the debouncing.\r
 463  */\r
 464 static Dem_EventStatusType preDebounceCounterBased(Dem_EventStatusType reportedStatus, EventStatusRecType* statusRecord) {\r
 465         Dem_EventStatusType returnCode;\r
 466         const Dem_PreDebounceCounterBasedType* pdVars = statusRecord->eventParamRef->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceCounterBased;\r
 467 \r
 468         switch (reportedStatus) {\r
 469         case DEM_EVENT_STATUS_PREFAILED:\r
 470                 if (statusRecord->faultDetectionCounter < DEBOUNCE_FDC_TEST_FAILED) {\r
 471                         if ((pdVars->JumpUp) && (statusRecord->faultDetectionCounter < 0)) {\r
 472                                 statusRecord->faultDetectionCounter = 0;\r
 473                         } else {\r
 474                                 if (((sint16)statusRecord->faultDetectionCounter + (sint8)pdVars->CountInStepSize) < DEBOUNCE_FDC_TEST_FAILED) {\r
 475                                         statusRecord->faultDetectionCounter += (sint8)pdVars->CountInStepSize;\r
 476                                 } else {\r
 477                                         statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_FAILED;\r
 478                                 }\r
 479                         }\r
 480                 }\r
 481                 break;\r
 482 \r
 483         case DEM_EVENT_STATUS_PREPASSED:\r
 484                 if (statusRecord->faultDetectionCounter > DEBOUNCE_FDC_TEST_PASSED) {\r
 485                         if ((pdVars->JumpDown) && (statusRecord->faultDetectionCounter > 0)) {\r
 486                                 statusRecord->faultDetectionCounter = 0;\r
 487                         } else {\r
 488                                 if (((sint16)statusRecord->faultDetectionCounter - (sint8)pdVars->CountOutStepSize) > DEBOUNCE_FDC_TEST_PASSED) {\r
 489                                         statusRecord->faultDetectionCounter -= (sint8)pdVars->CountOutStepSize;\r
 490                                 } else {\r
 491                                         statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_PASSED;\r
 492                                 }\r
 493                         }\r
 494                 }\r
 495                 break;\r
 496 \r
 497         case DEM_EVENT_STATUS_FAILED:\r
 498                 statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_FAILED; /** @req DEM091.CounterFailed */\r
 499                 break;\r
 500 \r
 501         case DEM_EVENT_STATUS_PASSED:\r
 502                 statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_PASSED; /** @req DEM091.CounterPassed */\r
 503                 break;\r
 504 \r
 505         default:\r
 506                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_PREDEBOUNCE_COUNTER_BASED_ID, DEM_E_PARAM_DATA);\r
 507                 break;\r
 508 \r
 509         }\r
 510 \r
 511         switch (statusRecord->faultDetectionCounter) {\r
 512         case DEBOUNCE_FDC_TEST_FAILED:\r
 513                 returnCode = DEM_EVENT_STATUS_FAILED;\r
 514                 break;\r
 515 \r
 516         case DEBOUNCE_FDC_TEST_PASSED:\r
 517                 returnCode = DEM_EVENT_STATUS_PASSED;\r
 518                 break;\r
 519 \r
 520         default:\r
 521                 returnCode = reportedStatus;\r
 522                 break;\r
 523         }\r
 524 \r
 525         return returnCode;\r
 526 }\r
 527 \r
 528 \r
 529 /*\r
 530  * Procedure:   updateEventStatusRec\r
 531  * Description: Update the status of "eventId", if not exist and "createIfNotExist" is\r
 532  *                              true a new record is created\r
 533  */\r
 534 static void updateEventStatusRec(const Dem_EventParameterType *eventParam, Dem_EventStatusType eventStatus, boolean createIfNotExist, EventStatusRecType *eventStatusRec)\r
 535 {\r
 536         EventStatusRecType *eventStatusRecPtr;\r
 537         sint8 faultCounterBeforeDebounce = 0;\r
 538         sint8 faultCounterAfterDebounce = 0;\r
 539         imask_t state;\r
 540     Irq_Save(state);\r
 541 \r
 542         lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
 543 \r
 544         if ((eventStatusRecPtr == NULL) && (createIfNotExist)) {\r
 545                 lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
 546                 if (eventStatusRecPtr != NULL) {\r
 547                         eventStatusRecPtr->eventId = eventParam->EventID;\r
 548                         eventStatusRecPtr->eventParamRef = eventParam;\r
 549                         eventStatusRecPtr->faultDetectionCounter = 0;\r
 550                         eventStatusRecPtr->occurrence = 0;\r
 551                         eventStatusRecPtr->eventStatusExtended = DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE;\r
 552                         eventStatusRecPtr->errorStatusChanged = FALSE;\r
 553                 }\r
 554                 else {\r
 555                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_EVENT_STATUS_BUFF_FULL);\r
 556                 }\r
 557         }\r
 558 \r
 559 \r
 560         if (eventStatusRecPtr != NULL) {\r
 561                 faultCounterBeforeDebounce = eventStatusRecPtr->faultDetectionCounter;\r
 562 \r
 563                 if (eventParam->EventClass->PreDebounceAlgorithmClass != NULL) {\r
 564                         switch (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceName) { /** @req DEM004 */ /** @req DEM342 */\r
 565                         case DEM_NO_PRE_DEBOUNCE:\r
 566                                 eventStatus = preDebounceNone(eventStatus, eventStatusRecPtr);\r
 567                                 break;\r
 568 \r
 569                         case DEM_PRE_DEBOUNCE_COUNTER_BASED:\r
 570                                 eventStatus = preDebounceCounterBased(eventStatus, eventStatusRecPtr);\r
 571                                 break;\r
 572 \r
 573                         default:\r
 574                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
 575                                 break;\r
 576                         }\r
 577                 }\r
 578                 faultCounterAfterDebounce = eventStatusRecPtr->faultDetectionCounter;\r
 579                 \r
 580                 eventStatusRecPtr->errorStatusChanged = FALSE;\r
 581 \r
 582                 if (eventStatus == DEM_EVENT_STATUS_FAILED) {\r
 583                         if (!(eventStatusRecPtr->eventStatusExtended & DEM_TEST_FAILED)) {\r
 584                                 eventStatusRecPtr->occurrence++;\r
 585                                 eventStatusRecPtr->errorStatusChanged = TRUE;\r
 586                         }\r
 587                         /** @req DEM036 */ /** @req DEM379.PendingSet */\r
 588                         eventStatusRecPtr->eventStatusExtended |= (DEM_TEST_FAILED | DEM_TEST_FAILED_THIS_OPERATION_CYCLE | DEM_TEST_FAILED_SINCE_LAST_CLEAR | DEM_PENDING_DTC | DEM_CONFIRMED_DTC);\r
 589                         eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
 590                 }\r
 591 \r
 592                 if (eventStatus == DEM_EVENT_STATUS_PASSED) {\r
 593                         if (eventStatusRecPtr->eventStatusExtended & (DEM_TEST_FAILED | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE)) {\r
 594                                 eventStatusRecPtr->errorStatusChanged = TRUE;\r
 595                         }\r
 596                         /** @req DEM036 */\r
 597                         eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED;\r
 598                         eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
 599                 }\r
 600 \r
 601                 if ((eventStatus == DEM_EVENT_STATUS_PREFAILED)\\r
 602                         && (faultCounterBeforeDebounce <= 0) && (faultCounterAfterDebounce > 0)){\r
 603                         eventStatusRecPtr->errorStatusChanged = TRUE;\r
 604                 }\r
 605 \r
 606                 memcpy(eventStatusRec, eventStatusRecPtr, sizeof(EventStatusRecType));\r
 607         }\r
 608         else {\r
 609                 eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
 610                 eventStatusRec->faultDetectionCounter = 0;\r
 611                 eventStatusRec->occurrence = 0;\r
 612                 eventStatusRec->eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
 613                 eventStatusRec->errorStatusChanged = FALSE;\r
 614         }\r
 615 \r
 616     Irq_Restore(state);\r
 617 }\r
 618 \r
 619 \r
 620 /*\r
 621  * Procedure:   mergeEventStatusRec\r
 622  * Description: Update the occurrence counter of status, if not exist a new record is created\r
 623  */\r
 624 static void mergeEventStatusRec(const EventRecType *eventRec)\r
 625 {\r
 626         EventStatusRecType *eventStatusRecPtr;\r
 627         imask_t state;\r
 628     Irq_Save(state);\r
 629 \r
 630         // Lookup event ID\r
 631         lookupEventStatusRec(eventRec->eventId, &eventStatusRecPtr);\r
 632 \r
 633         if (eventStatusRecPtr != NULL) {\r
 634                 // Update occurrence counter.\r
 635                 eventStatusRecPtr->occurrence += eventRec->occurrence;\r
 636                 // Merge event status extended with stored\r
 637                 // TEST_FAILED_SINCE_LAST_CLEAR should be set if set if set in either\r
 638                 eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & DEM_TEST_FAILED_SINCE_LAST_CLEAR);\r
 639                 // DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR should cleared if cleared in either\r
 640                 eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & eventStatusRecPtr->eventStatusExtended & DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR);\r
 641                 // DEM_PENDING_DTC and DEM_CONFIRMED_DTC should be set if set in either\r
 642                 eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & (DEM_PENDING_DTC | DEM_CONFIRMED_DTC));\r
 643 \r
 644         }\r
 645 \r
 646     Irq_Restore(state);\r
 647 }\r
 648 \r
 649 /*\r
 650  * Procedure:   resetEventStatusRec\r
 651  * Description: Reset the status record of "eventParam->eventId" from "eventStatusBuffer".\r
 652  */\r
 653 static void resetEventStatusRec(const Dem_EventParameterType *eventParam)\r
 654 {\r
 655         EventStatusRecType *eventStatusRecPtr;\r
 656         imask_t state;\r
 657         Irq_Save(state);\r
 658 \r
 659         // Lookup event ID\r
 660         lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
 661 \r
 662         if (eventStatusRecPtr != NULL) {\r
 663                 // Reset event record\r
 664                 eventStatusRecPtr->faultDetectionCounter = 0;\r
 665                 eventStatusRecPtr->eventStatusExtended = (DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR);\r
 666                 eventStatusRecPtr->errorStatusChanged = FALSE;\r
 667                 eventStatusRecPtr->occurrence = 0;\r
 668         }\r
 669 \r
 670         Irq_Restore(state);\r
 671 }\r
 672 \r
 673 /*\r
 674  * Procedure:   getEventStatusRec\r
 675  * Description: Returns the status record of "eventId" in "eventStatusRec"\r
 676  */\r
 677 static void getEventStatusRec(Dem_EventIdType eventId, EventStatusRecType *eventStatusRec)\r
 678 {\r
 679         EventStatusRecType *eventStatusRecPtr;\r
 680 \r
 681         // Lookup event ID\r
 682         lookupEventStatusRec(eventId, &eventStatusRecPtr);\r
 683 \r
 684         if (eventStatusRecPtr != NULL) {\r
 685                 // Copy the record\r
 686                 memcpy(eventStatusRec, eventStatusRecPtr, sizeof(EventStatusRecType));\r
 687         }\r
 688         else {\r
 689                 eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
 690         }\r
 691 }\r
 692 \r
 693 \r
 694 /*\r
 695  * Procedure:   lookupDtcEvent\r
 696  * Description: Returns TRUE if the DTC was found and "eventStatusRec" points\r
 697  *                              to the event record found.\r
 698  */\r
 699 static boolean lookupDtcEvent(uint32 dtc, EventStatusRecType **eventStatusRec)\r
 700 {\r
 701         boolean dtcFound = FALSE;\r
 702         uint16 i;\r
 703 \r
 704         *eventStatusRec = NULL;\r
 705 \r
 706         for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && (!dtcFound); i++) {\r
 707                 if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
 708                         if (eventStatusBuffer[i].eventParamRef->DTCClassRef != NULL) {\r
 709 \r
 710                                 // Check DTC\r
 711                                 if (eventStatusBuffer[i].eventParamRef->DTCClassRef->DTC == dtc) {\r
 712                                         *eventStatusRec = &eventStatusBuffer[i];\r
 713                                         dtcFound = TRUE;\r
 714                                 }\r
 715                         }\r
 716                 }\r
 717         }\r
 718 \r
 719         return dtcFound;\r
 720 }\r
 721 \r
 722 \r
 723 /*\r
 724  * Procedure:   matchEventWithDtcFilter\r
 725  * Description: Returns TRUE if the event pointed by "event" fulfill\r
 726  *                              the "dtcFilter" global filter settings.\r
 727  */\r
 728 static boolean matchEventWithDtcFilter(const EventStatusRecType *eventRec)\r
 729 {\r
 730         boolean dtcMatch = FALSE;\r
 731 \r
 732         // Check status\r
 733         if ((dtcFilter.dtcStatusMask == DEM_DTC_STATUS_MASK_ALL) || (eventRec->eventStatusExtended & dtcFilter.dtcStatusMask)) {\r
 734                 if (eventRec->eventParamRef != NULL) {\r
 735 \r
 736                         // Check dtcKind\r
 737                         if (checkDtcKind(dtcFilter.dtcKind, eventRec->eventParamRef)) {\r
 738 \r
 739                                 // Check dtcOrigin\r
 740                                 if (checkDtcOrigin(dtcFilter.dtcOrigin, eventRec->eventParamRef)) {\r
 741 \r
 742                                         // Check severity\r
 743                                         if ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
 744                                                 || ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES) && (checkDtcSeverityMask(dtcFilter.dtcSeverityMask, eventRec->eventParamRef)))) {\r
 745 \r
 746                                                 // Check fault detection counter\r
 747                                                 if ((dtcFilter.filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_NO)\r
 748                                                         || ((dtcFilter.filterWithSeverity == DEM_FILTER_FOR_FDC_YES) && (checkDtcFaultDetectionCounter(eventRec->eventParamRef)))) {\r
 749                                                         dtcMatch = TRUE;\r
 750                                                 }\r
 751                                         }\r
 752                                 }\r
 753                         }\r
 754                 }\r
 755         }\r
 756 \r
 757         return dtcMatch;\r
 758 }\r
 759 /*\r
 760  * Procedure:   bubbleSort\r
 761  * Description: bubble sort\r
 762  */\r
 763 static void bubbleSort(FreezeFrameRecType *freezeFrameBuf, uint16 length)\r
 764 {\r
 765         FreezeFrameRecType temp;\r
 766         uint16 i = 0;\r
 767         uint16 j = 0;\r
 768 \r
 769         //Bubble sort:rearrange priMemFreezeFrameBuffer from little to big\r
 770         for(i=0;i<length;i++){\r
 771                 for(j=length-1; j > i; j--){\r
 772                         if(freezeFrameBuf[i].timeStamp > freezeFrameBuf[j].timeStamp){\r
 773                                 //exchange buffer data\r
 774                                 memcpy(&temp,&freezeFrameBuf[i],sizeof(FreezeFrameRecType));\r
 775                                 memcpy(&freezeFrameBuf[i],&freezeFrameBuf[j],sizeof(FreezeFrameRecType));\r
 776                                 memcpy(&freezeFrameBuf[j],&temp,sizeof(FreezeFrameRecType));            \r
 777                         }\r
 778                 }\r
 779         }\r
 780 \r
 781 }\r
 782 \r
 783 /*\r
 784  * Procedure:   retrieveEventStatusBit\r
 785  * Description: retrieve Event Status Bit\r
 786  */\r
 787 static boolean retrieveEventStatusBit(FreezeFrameRecType *freezeFrameBuf, \r
 788                                                                                         uint16 length , \r
 789                                                                                         Dem_EventStatusExtendedType nBit, \r
 790                                                                                         FreezeFrameRecType **freezeFrame)\r
 791 {\r
 792         boolean freezeFrameFound = FALSE;\r
 793         uint16 i = 0;\r
 794         uint16 j = 0;\r
 795 \r
 796         for(i=0;i<length;i++){\r
 797                 for(j=0; (j < DEM_MAX_NUMBER_EVENT) && (!freezeFrameFound); j++){\r
 798                         freezeFrameFound = (eventStatusBuffer[j].eventId == freezeFrameBuf[i].eventId)\\r
 799                                                  && (!(eventStatusBuffer[j].eventStatusExtended & nBit));\r
 800                         if(freezeFrameFound == TRUE){\r
 801                                 *freezeFrame = &freezeFrameBuf[i];\r
 802                         }\r
 803                 }               \r
 804         }\r
 805 \r
 806         return freezeFrameFound;\r
 807 \r
 808 }\r
 809 \r
 810 /*\r
 811  * Procedure:   lookupFreezeFrameForDisplacementPreInit\r
 812  * Description: implement displacement strategy preinit:1.find out the oldest "not confirmed" DTC\r
 813  *                                                                                                 2.find out the oldest inactive DTC,inactive:testFailed is not set\r
 814  *                                                                                                3.find ou the oldest active DTC,active:testFailed is set\r
 815  */\r
 816 static boolean lookupFreezeFrameForDisplacementPreInit(FreezeFrameRecType **freezeFrame)\r
 817 {\r
 818         boolean freezeFrameFound = FALSE;\r
 819                 \r
 820         /* Bubble sort:rearrange priMemFreezeFrameBuffer from little to big */\r
 821         bubbleSort(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT);\r
 822 \r
 823         /* find out the oldest not confirmed dtc */\r
 824         freezeFrameFound = retrieveEventStatusBit(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT, DEM_CONFIRMED_DTC, freezeFrame);\r
 825 \r
 826         /* if all confirmed,lookup the oldest inactive dtc */\r
 827         if(freezeFrameFound == FALSE){\r
 828                 freezeFrameFound = retrieveEventStatusBit(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT, DEM_TEST_FAILED, freezeFrame);\r
 829         }\r
 830         \r
 831         /* if all confirmed,lookup the oldest active dtc */\r
 832         if(freezeFrameFound == FALSE){\r
 833                 *freezeFrame = &preInitFreezeFrameBuffer[0];\r
 834                 freezeFrameFound = TRUE;\r
 835         }                       \r
 836 \r
 837         return freezeFrameFound;\r
 838 }\r
 839 \r
 840 /*\r
 841  * Procedure:   lookupFreezeFrameForDisplacement\r
 842  * Description: implement displacement strategy:1.find out the oldest "not confirmed" DTC\r
 843  *                                                                                      2.find out the oldest inactive DTC,inactive:testFailed is not set\r
 844  *                                                                                      3.find ou the oldest active DTC,active:testFailed is set\r
 845  */\r
 846 static boolean lookupFreezeFrameForDisplacement(FreezeFrameRecType **freezeFrame)\r
 847 {\r
 848         boolean freezeFrameFound = FALSE;\r
 849         \r
 850         bubbleSort(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM);\r
 851 \r
 852         /* Find out the oldest not confirmed dtc */\r
 853         freezeFrameFound = retrieveEventStatusBit(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM, DEM_CONFIRMED_DTC, freezeFrame);\r
 854 \r
 855         /* If all confirmed, lookup the oldest inactive dtc */\r
 856         if(freezeFrameFound == FALSE){\r
 857                 freezeFrameFound = retrieveEventStatusBit(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM, DEM_TEST_FAILED, freezeFrame);\r
 858         }\r
 859 \r
 860         /* If all confirmed,lookup the oldest active dtc */\r
 861         if(freezeFrameFound == FALSE){  \r
 862                 *freezeFrame = &priMemFreezeFrameBuffer[0];\r
 863                 freezeFrameFound = TRUE;        \r
 864         }\r
 865 \r
 866         return freezeFrameFound;\r
 867 }\r
 868 /*\r
 869  * Procedure:   rearrangeFreezeFrameTimeStamp\r
 870  * Description: rearrange FF timestamp when timestamp is beyond DEM_MAX_TIMESTAMP_FOR_REARRANGEMENT                     \r
 871  */\r
 872 static void rearrangeFreezeFrameTimeStamp(uint32 *timeStamp)\r
 873 {\r
 874         FreezeFrameRecType temp;\r
 875         uint32 i = 0;\r
 876         uint32 j = 0;\r
 877         uint32 k = 0;\r
 878         \r
 879         /* Bubble sort:rearrange priMemFreezeFrameBuffer from little to big */\r
 880         for(i=0;i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM;i++){\r
 881                 if(priMemFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
 882                         for(j=DEM_MAX_NUMBER_FF_DATA_PRI_MEM-1; j > i; j--){\r
 883                                 if(priMemFreezeFrameBuffer[j].eventId != DEM_EVENT_ID_NULL){\r
 884                                         if(priMemFreezeFrameBuffer[i].timeStamp > priMemFreezeFrameBuffer[j].timeStamp){\r
 885                                                 //exchange buffer data\r
 886                                                 memcpy(&temp,&priMemFreezeFrameBuffer[i],sizeof(FreezeFrameRecType));\r
 887                                                 memcpy(&priMemFreezeFrameBuffer[i],&priMemFreezeFrameBuffer[j],sizeof(FreezeFrameRecType));\r
 888                                                 memcpy(&priMemFreezeFrameBuffer[j],&temp,sizeof(FreezeFrameRecType));           \r
 889                                         }\r
 890 \r
 891                                 }\r
 892                                 \r
 893                         }\r
 894                         priMemFreezeFrameBuffer[i].timeStamp = k++;\r
 895                 }\r
 896                 \r
 897         }\r
 898         /* update the current timeStamp */\r
 899         *timeStamp = k;\r
 900 \r
 901 }\r
 902 /*\r
 903  * Procedure:   getFreezeFrameData\r
 904  * Description: get FF data according configuration                     \r
 905  */\r
 906 static void getFreezeFrameData(const Dem_EventParameterType *eventParam, \r
 907                                FreezeFrameRecType *freezeFrame,\r
 908                                Dem_EventStatusType eventStatus,\r
 909                                EventStatusRecType *eventStatusRec)\r
 910 {\r
 911         Dem_FreezeFrameStorageConditonType prefailedOrFailed;\r
 912         Std_ReturnType callbackReturnCode;\r
 913         uint16 i = 0;\r
 914         uint16 storeIndex = 0;\r
 915         uint16 recordSize = 0;\r
 916         imask_t state;\r
 917         const Dem_FreezeFrameClassType *FreezeFrameLocal = NULL;\r
 918         Dcm_NegativeResponseCodeType errorCode;//should include Dcm_Lcfg.h\r
 919 \r
 920         /* clear FF data record */\r
 921         memset(freezeFrame, 0, sizeof(FreezeFrameRecType ));\r
 922 \r
 923         /* check if prefailed or failed */\r
 924         if(eventStatusRec->eventStatusExtended & DEM_TEST_FAILED){\r
 925                 prefailedOrFailed = FAILED;//confirm the FF is stored for failed\r
 926 \r
 927         }\r
 928         else{\r
 929                  if(eventStatus == DEM_EVENT_STATUS_PREFAILED){\r
 930                         prefailedOrFailed = PREFAILED;//confirm the FF is stored for prefailed\r
 931                  }\r
 932                  else{\r
 933                         prefailedOrFailed = FF_STORAGE_CONDITION_WRONG;\r
 934                         freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
 935                         return;\r
 936                  }\r
 937         }\r
 938 \r
 939         /* Find out the corresponding FF class */\r
 940         for(i = 0;(i<DEM_MAX_NR_OF_CLASSES_IN_FREEZEFRAME_DATA) && (eventParam->FreezeFrameClassRef[i] != NULL);i++){\r
 941                 if(eventParam->FreezeFrameClassRef[i]->FFStorageCondition == prefailedOrFailed){\r
 942                         FreezeFrameLocal = eventParam->FreezeFrameClassRef[i];\r
 943                         break;\r
 944                 }\r
 945         }\r
 946         /* get the dids */\r
 947         if(FreezeFrameLocal != NULL){\r
 948                 if(FreezeFrameLocal->FFIdClassRef != NULL){\r
 949                         for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FreezeFrameLocal->FFIdClassRef[i].Arc_EOL)); i++) {\r
 950                                 if(FreezeFrameLocal->FFIdClassRef[i].PidOrDidUsePort == FALSE){\r
 951                                         if(FreezeFrameLocal->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
 952                                                 callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidReadDataLengthFnc(&recordSize);\r
 953                                                 if(callbackReturnCode != E_OK){\r
 954                                                         //if fail to read data length,discard the storage of FF\r
 955                                                         freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
 956                                                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_READ_DATA_LENGTH_FAILED);\r
 957                                                         return;\r
 958                                                 }\r
 959                                         }\r
 960                                         /* if no readDidDataLengthFunction, then try the PidOrDidSize. */\r
 961                                         else{\r
 962                                                 recordSize = FreezeFrameLocal->FFIdClassRef[i].PidOrDidSize;\r
 963                                         }\r
 964                                         /* read out the did data */\r
 965                                         if ((storeIndex + recordSize + DEM_DID_IDENTIFIER_SIZE_OF_BYTES) <= DEM_MAX_SIZE_FF_DATA) {\r
 966                                                 /* store DID */\r
 967                                                 freezeFrame->data[storeIndex] = (FreezeFrameLocal->FFIdClassRef[i].DidIdentifier>> 8) & 0xFFu;\r
 968                                                 storeIndex++;\r
 969                                                 freezeFrame->data[storeIndex] = FreezeFrameLocal->FFIdClassRef[i].DidIdentifier & 0xFFu;\r
 970                                                 storeIndex++;\r
 971                                                 /* store data */\r
 972                                                 if(FreezeFrameLocal->FFIdClassRef[i].DidConditionCheckReadFnc != NULL){\r
 973                                                         callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidConditionCheckReadFnc(&errorCode);\r
 974                                                         if ((callbackReturnCode == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {\r
 975                                                                 if(FreezeFrameLocal->FFIdClassRef[i].DidReadFnc!= NULL){\r
 976                                                                         callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidReadFnc(&freezeFrame->data[storeIndex]);\r
 977                                                                         if (callbackReturnCode != E_OK) {\r
 978                                                                                 memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
 979                                                                         }\r
 980                                                                         storeIndex += recordSize;\r
 981 \r
 982                                                                 }\r
 983                                                                 else{\r
 984                                                                         memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
 985                                                                         storeIndex += recordSize;\r
 986                                                                 }\r
 987 \r
 988                                                         }\r
 989                                                         else{\r
 990                                                                 memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
 991                                                                 storeIndex += recordSize;\r
 992                                                         }\r
 993                                                 }\r
 994                                                 else{\r
 995                                                         memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
 996                                                         storeIndex += recordSize;\r
 997                                                 }\r
 998 \r
 999                                         }\r
1000                                         else{\r
1001                                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_E_FF_TOO_BIG);\r
1002                                                 break;\r
1003                                         }       \r
1004                                 }\r
1005                                 else{\r
1006                                         //TODO:RTE should provide the port\r
1007                                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_DSP_DID_USE_PORT_IS_TRUE);\r
1008                                 }\r
1009                         }       \r
1010                 }\r
1011 \r
1012         }\r
1013         else{\r
1014                 /* create an empty FF */\r
1015                 freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
1016         }\r
1017 \r
1018         /* Check if any data has been stored */\r
1019         if (storeIndex != 0) {\r
1020                 freezeFrame->eventId = eventParam->EventID;\r
1021                 freezeFrame->occurrence = eventStatusRec->occurrence;\r
1022                 freezeFrame->dataSize = storeIndex;\r
1023                 freezeFrame->recordNumber = FreezeFrameLocal->FFRecordNumber;\r
1024                 Irq_Save(state);\r
1025 \r
1026                 if(FF_TimeStamp > DEM_MAX_TIMESTAMP_FOR_REARRANGEMENT){\r
1027                         rearrangeFreezeFrameTimeStamp(&FF_TimeStamp);\r
1028                 }\r
1029                 \r
1030                 freezeFrame->timeStamp = FF_TimeStamp;\r
1031 \r
1032                 FF_TimeStamp++;\r
1033 \r
1034                 Irq_Restore(state);\r
1035 \r
1036                 freezeFrame->checksum = calcChecksum(freezeFrame, sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
1037         }\r
1038         else{\r
1039                 freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
1040                 freezeFrame->dataSize = storeIndex;\r
1041                 freezeFrame->checksum = 0;\r
1042         }       \r
1043 }\r
1044 \r
1045 \r
1046 /*\r
1047  * Procedure:   storeFreezeFrameDataPreInit\r
1048  * Description: store FF in before  preInitFreezeFrameBuffer DEM's full initialization                          \r
1049  */\r
1050 static void storeFreezeFrameDataPreInit(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
1051 {\r
1052         boolean eventIdFound = FALSE;\r
1053         boolean eventIdFreePositionFound=FALSE;\r
1054         FreezeFrameRecType *freezeFrameLocal = NULL;\r
1055         uint16 i;\r
1056         imask_t state;\r
1057 \r
1058         Irq_Save(state);\r
1059 \r
1060         /* Check if already stored */\r
1061         for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT) && (!eventIdFound); i++){\r
1062                 eventIdFound = ((preInitFreezeFrameBuffer[i].eventId == eventParam->EventID) && (preInitFreezeFrameBuffer[i].recordNumber== freezeFrame->recordNumber));\r
1063         }\r
1064 \r
1065         if(eventIdFound){\r
1066                 /* overwrite existing */\r
1067                 memcpy(&preInitFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
1068         }\r
1069         else{\r
1070                 /* lookup first free position */\r
1071                 for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT) && (!eventIdFreePositionFound); i++){\r
1072                         if(preInitFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL){\r
1073                                 eventIdFreePositionFound=TRUE;\r
1074                         }\r
1075                 }\r
1076 \r
1077                 if (eventIdFreePositionFound) {\r
1078                         memcpy(&preInitFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
1079                 }\r
1080                 else {                  \r
1081                         /* do displacement */\r
1082                         if(lookupFreezeFrameForDisplacementPreInit(&freezeFrameLocal)){\r
1083                                 memcpy(freezeFrameLocal, freezeFrame, sizeof(FreezeFrameRecType));\r
1084                         }\r
1085                         else{\r
1086                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_FF_DATA_PRE_INIT_ID, DEM_E_PRE_INIT_FF_DATA_BUFF_FULL);\r
1087                         }\r
1088                 }\r
1089         }\r
1090 \r
1091         Irq_Restore(state);\r
1092 }\r
1093 \r
1094 \r
1095 /*\r
1096  * Procedure:   updateFreezeFrameOccurrencePreInit\r
1097  * Description: update the occurrence in preInitFreezeFrameBuffer according to the occurrence stored in priMemEventBuffer                               \r
1098  */\r
1099 static void updateFreezeFrameOccurrencePreInit(const EventRecType *EventBuffer)\r
1100 {\r
1101         uint16 i;\r
1102 \r
1103         for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++){\r
1104                 if(preInitFreezeFrameBuffer[i].eventId == EventBuffer->eventId){\r
1105                         preInitFreezeFrameBuffer[i].occurrence += EventBuffer->occurrence;\r
1106                 }\r
1107         }\r
1108         \r
1109 }\r
1110 /*\r
1111  * Procedure:   initCurrentFreezeFrameTimeStamp\r
1112  * Description: initialize current timestamp and update the corresponding timestamp in preInitFreezeFrameBuffer         \r
1113  */\r
1114 static void initCurrentFreezeFrameTimeStamp(uint32 *timeStampPtr)\r
1115 {\r
1116         uint16 i = 0;\r
1117         uint32 temp = 0;\r
1118         imask_t state;\r
1119 \r
1120         Irq_Save(state);\r
1121 \r
1122         /* Find out the biggest timestamp in the last power on */\r
1123         for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
1124                 if((priMemFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) && \r
1125                   (priMemFreezeFrameBuffer[i].timeStamp > temp)){\r
1126                         temp = priMemFreezeFrameBuffer[i].timeStamp;\r
1127                 }\r
1128         }\r
1129         temp++;\r
1130         for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++){\r
1131                 if(preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
1132                         preInitFreezeFrameBuffer[i].timeStamp += temp;\r
1133                 }\r
1134         }\r
1135         *timeStampPtr += temp;  \r
1136         Irq_Restore(state);\r
1137 }\r
1138 \r
1139 /*\r
1140  * Procedure:   getExtendedData\r
1141  * Description: Collects the extended data according to "eventParam" and return it in "extData",\r
1142  *                              if not found eventId is set to DEM_EVENT_ID_NULL.\r
1143  */\r
1144 static void getExtendedData(const Dem_EventParameterType *eventParam, ExtDataRecType *extData)\r
1145 {\r
1146         Std_ReturnType callbackReturnCode;\r
1147         uint16 i;\r
1148         uint16 storeIndex = 0;\r
1149         uint16 recordSize;\r
1150 \r
1151         // Clear ext data record\r
1152         memset(extData, 0, sizeof(ExtDataRecType));\r
1153 \r
1154         // Check if any pointer to extended data class\r
1155         if (eventParam->ExtendedDataClassRef != NULL) {\r
1156                 // Request extended data and copy it to the buffer\r
1157                 for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i] != NULL); i++) {\r
1158                         recordSize = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->DataSize;\r
1159                         if ((storeIndex + recordSize) <= DEM_MAX_SIZE_EXT_DATA) {\r
1160                                 callbackReturnCode = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->CallbackGetExtDataRecord(&extData->data[storeIndex]); /** @req DEM282 */\r
1161                                 if (callbackReturnCode != E_OK) {\r
1162                                         // Callback data currently not available, clear space.\r
1163                                         memset(&extData->data[storeIndex], 0xFF, recordSize);\r
1164                                 }\r
1165                                 storeIndex += recordSize;\r
1166                         }\r
1167                         else {\r
1168                                 // Error: Size of extended data record is bigger than reserved space.\r
1169                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_EXTENDED_DATA_ID, DEM_E_EXT_DATA_TOO_BIG);\r
1170                                 break;  // Break the loop\r
1171                         }\r
1172                 }\r
1173         }\r
1174 \r
1175         // Check if any data has been stored\r
1176         if (storeIndex != 0) {\r
1177                 extData->eventId = eventParam->EventID;\r
1178                 extData->dataSize = storeIndex;\r
1179                 extData->checksum = calcChecksum(extData, sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
1180         }\r
1181         else {\r
1182                 extData->eventId = DEM_EVENT_ID_NULL;\r
1183                 extData->dataSize = storeIndex;\r
1184                 extData->checksum = 0;\r
1185         }\r
1186 }\r
1187 \r
1188 \r
1189 /*\r
1190  * Procedure:   storeExtendedDataPreInit\r
1191  * Description: Store the extended data pointed by "extendedData" to the "preInitExtDataBuffer",\r
1192  *                              if non existent a new entry is created.\r
1193  */\r
1194 static void storeExtendedDataPreInit(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData)\r
1195 {\r
1196         boolean eventIdFound = FALSE;\r
1197         boolean eventIdFreePositionFound=FALSE;\r
1198         uint16 i;\r
1199         imask_t state;\r
1200     Irq_Save(state);\r
1201 \r
1202         // Check if already stored\r
1203         for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) && (!eventIdFound); i++){\r
1204                 eventIdFound = (preInitExtDataBuffer[i].eventId == eventParam->EventID);\r
1205         }\r
1206 \r
1207         if(eventIdFound){\r
1208                 // Yes, overwrite existing\r
1209                 memcpy(&preInitExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
1210         }\r
1211         else{\r
1212                 // No, lookup first free position\r
1213                 for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) && (!eventIdFreePositionFound); i++){\r
1214                         if(preInitExtDataBuffer[i].eventId ==0){\r
1215                                 eventIdFreePositionFound=TRUE;\r
1216                         }\r
1217                 }\r
1218 \r
1219                 if (eventIdFreePositionFound) {\r
1220                         memcpy(&preInitExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
1221                 }\r
1222                 else {\r
1223                         // Error: Pre init extended data buffer full\r
1224                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_EXT_DATA_PRE_INIT_ID, DEM_E_PRE_INIT_EXT_DATA_BUFF_FULL);\r
1225                 }\r
1226         }\r
1227 \r
1228     Irq_Restore(state);\r
1229 }\r
1230 \r
1231 /*\r
1232  * Procedure:   storeEventPriMem\r
1233  * Description: Store the event data of "eventStatus->eventId" in "priMemEventBuffer",\r
1234  *                              if non existent a new entry is created.\r
1235  */\r
1236 static void storeEventPriMem(const Dem_EventParameterType *eventParam, const EventStatusRecType *eventStatus)\r
1237 {\r
1238         boolean eventIdFound = FALSE;\r
1239         boolean eventIdFreePositionFound=FALSE;\r
1240         uint16 i;\r
1241         imask_t state;\r
1242     Irq_Save(state);\r
1243 \r
1244         (void)*eventParam;      // Currently not used, do this to avoid warning\r
1245 \r
1246         // Lookup event ID\r
1247         for (i = 0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFound); i++){\r
1248                 eventIdFound = (priMemEventBuffer[i].eventId == eventStatus->eventId);\r
1249         }\r
1250 \r
1251         if (eventIdFound) {\r
1252                 // Update event found\r
1253                 priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
1254                 priMemEventBuffer[i-1].eventStatusExtended = eventStatus->eventStatusExtended;\r
1255                 priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
1256         }\r
1257         else {\r
1258                 // Search for free position\r
1259                 for (i=0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFreePositionFound); i++){\r
1260                         eventIdFreePositionFound = (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
1261                 }\r
1262 \r
1263 \r
1264                 if (eventIdFreePositionFound) {\r
1265                         priMemEventBuffer[i-1].eventId = eventStatus->eventId;\r
1266                         priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
1267                         priMemEventBuffer[i-1].eventStatusExtended = eventStatus->eventStatusExtended;\r
1268                         priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
1269                 }\r
1270                 else {\r
1271                         // Error: Pri mem event buffer full\r
1272                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_EVENT_PRI_MEM_ID, DEM_E_PRI_MEM_EVENT_BUFF_FULL);\r
1273                 }\r
1274         }\r
1275 \r
1276     Irq_Restore(state);\r
1277 }\r
1278 \r
1279 /*\r
1280  * Procedure:   deleteEventPriMem\r
1281  * Description: Delete the event data of "eventParam->eventId" from "priMemEventBuffer".\r
1282  */\r
1283 static void deleteEventPriMem(const Dem_EventParameterType *eventParam)\r
1284 {\r
1285         boolean eventIdFound = FALSE;\r
1286         uint16 i;\r
1287         imask_t state;\r
1288     Irq_Save(state);\r
1289 \r
1290         for (i = 0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFound); i++){\r
1291                 eventIdFound = (priMemEventBuffer[i].eventId == eventParam->EventID);\r
1292         }\r
1293 \r
1294         if (eventIdFound) {\r
1295                 memset(&priMemEventBuffer[i-1], 0, sizeof(EventRecType));\r
1296         }\r
1297 \r
1298     Irq_Restore(state);\r
1299 }\r
1300 \r
1301 /*\r
1302  * Procedure:   storeEventEvtMem\r
1303  * Description: Store the event data of "eventStatus->eventId" in event memory according to\r
1304  *                              "eventParam" destination option.\r
1305  */\r
1306 static void storeEventEvtMem(const Dem_EventParameterType *eventParam, const EventStatusRecType *eventStatus)\r
1307 {\r
1308         uint16 i;\r
1309 \r
1310         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION)\r
1311                                  && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
1312                 switch (eventParam->EventClass->EventDestination[i])\r
1313                 {\r
1314                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
1315                         storeEventPriMem(eventParam, eventStatus);      /** @req DEM010 */\r
1316                         break;\r
1317 \r
1318                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
1319                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
1320                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
1321                         // Not yet supported\r
1322                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
1323                         break;\r
1324                 default:\r
1325                         break;\r
1326                 }\r
1327         }\r
1328 }\r
1329 \r
1330 \r
1331 /*\r
1332  * Procedure:   storeExtendedDataPriMem\r
1333  * Description: Store the extended data pointed by "extendedData" to the "priMemExtDataBuffer",\r
1334  *                              if non existent a new entry is created.\r
1335  */\r
1336 static void storeExtendedDataPriMem(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData) /** @req DEM041 */\r
1337 {\r
1338         boolean eventIdFound = FALSE;\r
1339         boolean eventIdFreePositionFound=FALSE;\r
1340         uint16 i;\r
1341         imask_t state;\r
1342     Irq_Save(state);\r
1343 \r
1344         // Check if already stored\r
1345         for (i = 0; (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++){\r
1346                 eventIdFound = (priMemExtDataBuffer[i].eventId == eventParam->EventID);\r
1347         }\r
1348 \r
1349         if (eventIdFound) {\r
1350                 // Yes, overwrite existing\r
1351                 memcpy(&priMemExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
1352         }\r
1353         else {\r
1354                 // No, lookup first free position\r
1355                 for (i = 0; (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFreePositionFound); i++){\r
1356                         eventIdFreePositionFound =  (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
1357                 }\r
1358                 if (eventIdFreePositionFound) {\r
1359                         memcpy(&priMemExtDataBuffer[i-1], extendedData, sizeof(ExtDataRecType));\r
1360                 }\r
1361                 else {\r
1362                         // Error: Pri mem extended data buffer full\r
1363                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_EXT_DATA_PRI_MEM_ID, DEM_E_PRI_MEM_EXT_DATA_BUFF_FULL);\r
1364                 }\r
1365         }\r
1366 \r
1367     Irq_Restore(state);\r
1368 }\r
1369 \r
1370 /*\r
1371  * Procedure:   deleteExtendedDataPriMem\r
1372  * Description: Delete the extended data of "eventParam->eventId" from "priMemExtDataBuffer".\r
1373  */\r
1374 static void deleteExtendedDataPriMem(const Dem_EventParameterType *eventParam)\r
1375 {\r
1376         boolean eventIdFound = FALSE;\r
1377         uint16 i;\r
1378         imask_t state;\r
1379     Irq_Save(state);\r
1380 \r
1381         // Check if already stored\r
1382         for (i = 0;(i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++){\r
1383                 eventIdFound = (priMemExtDataBuffer[i].eventId == eventParam->EventID);\r
1384         }\r
1385 \r
1386         if (eventIdFound) {\r
1387                 // Yes, clear record\r
1388                 memset(&priMemExtDataBuffer[i-1], 0, sizeof(ExtDataRecType));\r
1389         }\r
1390 \r
1391     Irq_Restore(state);\r
1392 }\r
1393 \r
1394 /*\r
1395  * Procedure:   storeExtendedDataEvtMem\r
1396  * Description: Store the extended data in event memory according to\r
1397  *                              "eventParam" destination option\r
1398  */\r
1399 static void storeExtendedDataEvtMem(const Dem_EventParameterType *eventParam, const ExtDataRecType *extendedData)\r
1400 {\r
1401         uint16 i;\r
1402 \r
1403         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
1404                 switch (eventParam->EventClass->EventDestination[i])\r
1405                 {\r
1406                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
1407                         storeExtendedDataPriMem(eventParam, extendedData);\r
1408                         break;\r
1409 \r
1410                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
1411                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
1412                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
1413                         // Not yet supported\r
1414                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
1415                         break;\r
1416 \r
1417                 default:\r
1418                         break;\r
1419                 }\r
1420         }\r
1421 }\r
1422 \r
1423 \r
1424 /*\r
1425  * Procedure:   lookupExtendedDataRecNumParam\r
1426  * Description: Returns TRUE if the requested extended data number was found among the configured records for the event.\r
1427  *                              "extDataRecClassPtr" returns a pointer to the record class, "posInExtData" returns the position in stored extended data.\r
1428  */\r
1429 static boolean lookupExtendedDataRecNumParam(uint8 extendedDataNumber, const Dem_EventParameterType *eventParam, Dem_ExtendedDataRecordClassType const **extDataRecClassPtr, uint16 *posInExtData)\r
1430 {\r
1431         boolean recNumFound = FALSE;\r
1432 \r
1433         if (eventParam->ExtendedDataClassRef != NULL) {\r
1434                 uint16  byteCnt = 0;\r
1435                 uint16 i;\r
1436 \r
1437                 // Request extended data and copy it to the buffer\r
1438                 for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i] != NULL) && (!recNumFound); i++) {\r
1439                         if (eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->RecordNumber == extendedDataNumber) {\r
1440                                 *extDataRecClassPtr =  eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i];\r
1441                                 *posInExtData = byteCnt;\r
1442                                 recNumFound = TRUE;\r
1443                         }\r
1444                         byteCnt += eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->DataSize;\r
1445                 }\r
1446         }\r
1447 \r
1448         return recNumFound;\r
1449 }\r
1450 \r
1451 \r
1452 /*\r
1453  * Procedure:   lookupExtendedDataPriMem\r
1454  * Description: Returns TRUE if the requested event id is found, "extData" points to the found data.\r
1455  */\r
1456 static boolean lookupExtendedDataPriMem(Dem_EventIdType eventId, ExtDataRecType **extData)\r
1457 {\r
1458         boolean eventIdFound = FALSE;\r
1459         sint16 i;\r
1460 \r
1461         // Lookup corresponding extended data\r
1462         for (i = 0; (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) && (!eventIdFound); i++) {\r
1463                 eventIdFound = (priMemExtDataBuffer[i].eventId == eventId);\r
1464         }\r
1465 \r
1466         if (eventIdFound) {\r
1467                 // Yes, return pointer\r
1468                 *extData = &priMemExtDataBuffer[i-1];\r
1469         }\r
1470 \r
1471         return eventIdFound;\r
1472 }\r
1473 /*\r
1474  * Procedure:   copyNvmMirror\r
1475  * Description: Copies Nvram to buffer\r
1476  */\r
1477 \r
1478 Std_ReturnType copyNvmMirror(const NvM_BlockIdType BlockId, uint8 *dstPtr, const uint8 *srcPtr, uint8 len)\r
1479 {\r
1480 \r
1481 #if (DEM_USE_NVM == STD_ON)\r
1482         Std_ReturnType blockReadStatus = E_NOT_OK;\r
1483         NvM_RequestResultType requestResult;\r
1484 \r
1485     if( BlockId != 0 ) {\r
1486                 NvM_GetErrorStatus(BlockId, &requestResult);\r
1487                 if(requestResult != NVM_REQ_PENDING ) {\r
1488                         memcpy(dstPtr, srcPtr, len);\r
1489                         blockReadStatus = E_OK;\r
1490                 }\r
1491     }\r
1492 \r
1493     return blockReadStatus;\r
1494 #else\r
1495     return E_OK;\r
1496 #endif\r
1497 }\r
1498 /*\r
1499  * Procedure:   writeNvmMirror\r
1500  * Description: store data in NVRam\r
1501  */\r
1502 Std_ReturnType writeNvmMirror(const NvM_BlockIdType BlockId, uint8 *dstPtr, const uint8 *srcPtr, uint8 len)\r
1503 {\r
1504 #if (DEM_USE_NVM == STD_ON)\r
1505         Std_ReturnType blockWriteStatus = E_NOT_OK;\r
1506         NvM_RequestResultType requestResult;\r
1507 \r
1508     if( BlockId != 0 ) {\r
1509         NvM_GetErrorStatus(BlockId, &requestResult);\r
1510                 if(requestResult != NVM_REQ_PENDING ) {\r
1511                         memcpy(dstPtr, srcPtr, len);\r
1512                         (void)NvM_WriteBlock(BlockId, (const uint8*)dstPtr);\r
1513                         blockWriteStatus = E_OK;\r
1514                 }\r
1515     }\r
1516 \r
1517     return blockWriteStatus;\r
1518 #else\r
1519     return E_OK;\r
1520 #endif\r
1521 }\r
1522 \r
1523 /*\r
1524  * Procedure:   storeAgingRecPerMem\r
1525  * Description: store aging records in NVRam\r
1526  */\r
1527 static void storeAgingRecPerMem(const NvM_BlockIdType AgingBlockId)\r
1528 {\r
1529         imask_t state;\r
1530 \r
1531         Irq_Save(state);\r
1532 \r
1533         if( E_NOT_OK == writeNvmMirror(AgingBlockId, (uint8 *)HealingMirrorBuffer, (const uint8 *)priMemAgingBuffer, sizeof(priMemAgingBuffer)) ){\r
1534                 AgingIsModified = TRUE;\r
1535         }\r
1536 \r
1537         Irq_Restore(state);\r
1538 }\r
1539 /*\r
1540  * Procedure:   deleteAgingRecPriMem\r
1541  * Description: delete aging record in primary memory\r
1542  */\r
1543 static void deleteAgingRecPriMem(const Dem_EventParameterType *eventParam)\r
1544 {\r
1545         uint16 i;\r
1546         imask_t state;\r
1547 \r
1548         Irq_Save(state);\r
1549 \r
1550         for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
1551                 if (priMemAgingBuffer[i].eventId == eventParam->EventID){\r
1552                         memset(&priMemAgingBuffer[i], 0, sizeof(HealingRecType));\r
1553                 }\r
1554         }\r
1555 \r
1556         Irq_Restore(state);\r
1557 }\r
1558 \r
1559 /*\r
1560  * Procedure:   storeFreezeFrameDataPriMem\r
1561  * Description: store FreezeFrame data record in primary memory\r
1562  */\r
1563 static void storeFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
1564 {\r
1565         boolean eventIdFound = FALSE;\r
1566         boolean eventIdFreePositionFound=FALSE;\r
1567         boolean displacementPositionFound=FALSE;\r
1568         FreezeFrameRecType *freezeFrameLocal;\r
1569         uint16 i;\r
1570         imask_t state;\r
1571 \r
1572         Irq_Save(state);\r
1573 \r
1574         /* Check if already stored */\r
1575         for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFound); i++){\r
1576                 eventIdFound = ((priMemFreezeFrameBuffer[i].eventId == eventParam->EventID) && (priMemFreezeFrameBuffer[i].recordNumber == freezeFrame->recordNumber));\r
1577         }\r
1578 \r
1579         if (eventIdFound) {\r
1580                 memcpy(&priMemFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
1581         }\r
1582         else {\r
1583                 for (i = 0; (i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFreePositionFound); i++){\r
1584                         eventIdFreePositionFound =  (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
1585                 }\r
1586                 if (eventIdFreePositionFound) {\r
1587                         memcpy(&priMemFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
1588                 }\r
1589                 else {\r
1590                         displacementPositionFound = lookupFreezeFrameForDisplacement(&freezeFrameLocal);\r
1591                         if(displacementPositionFound){\r
1592                                 memcpy(freezeFrameLocal, freezeFrame, sizeof(FreezeFrameRecType));\r
1593                         }\r
1594                         else{\r
1595                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_FF_DATA_PRI_MEM_ID, DEM_E_PRI_MEM_FF_DATA_BUFF_FULL);\r
1596                         }                       \r
1597                 }\r
1598         }\r
1599 \r
1600         Irq_Restore(state);\r
1601 }\r
1602 /*\r
1603  * Procedure:   storeFreezeFrameDataPerMem\r
1604  * Description: Store the freeze frame data in NVRam\r
1605  * \r
1606  */\r
1607 static void storeFreezeFrameDataPerMem()\r
1608 {\r
1609         imask_t state;\r
1610 \r
1611         Irq_Save(state);\r
1612 \r
1613         for(uint16 i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
1614                 if(memcmp(&priMemFreezeFrameBuffer[i], FreezeFrameMirrorBuffer[i], sizeof(FreezeFrameRecType))){\r
1615                         if( E_NOT_OK == writeNvmMirror(FreezeFrameBlockId[i], (uint8 *)FreezeFrameMirrorBuffer[i], (const uint8 *)&priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType)) ) {\r
1616                                 FFIsModified = TRUE;\r
1617                         }\r
1618                 }\r
1619         }\r
1620 \r
1621         Irq_Restore(state);\r
1622 }\r
1623 \r
1624 // PC-Lint (715 etc): Remove errors until function is filled.\r
1625 //lint -e{715}          Symbol not referenced\r
1626 static void deleteFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam)\r
1627 {\r
1628         uint16 i;\r
1629         imask_t state;\r
1630 \r
1631         Irq_Save(state);\r
1632 \r
1633         for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
1634                 if (priMemFreezeFrameBuffer[i].eventId == eventParam->EventID){\r
1635                         memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
1636 \r
1637                 }\r
1638         }\r
1639 \r
1640         Irq_Restore(state);\r
1641 }\r
1642 \r
1643 /*\r
1644  * Procedure:   storeFreezeFrameDataEvtMem\r
1645  * Description: Store the freeze frame data in event memory according to\r
1646  *                              "eventParam" destination option\r
1647  */\r
1648 static void storeFreezeFrameDataEvtMem(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
1649 {\r
1650         uint16 i;\r
1651 \r
1652         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
1653                 switch (eventParam->EventClass->EventDestination[i])\r
1654                 {\r
1655                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
1656                         storeFreezeFrameDataPriMem(eventParam, freezeFrame);\r
1657                         storeFreezeFrameDataPerMem();\r
1658                         break;\r
1659 \r
1660                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
1661                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
1662                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
1663                         // Not yet supported\r
1664                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
1665                         break;\r
1666 \r
1667                 default:\r
1668                         break;\r
1669                 }\r
1670         }\r
1671 }\r
1672 \r
1673 /*\r
1674  * Procedure:   lookupFreezeFrameDataRecNumParam\r
1675  * Description: Returns TRUE if the requested freezeFrame data number was found among the configured records for the event.\r
1676  *                              "freezeFrameClassPtr" returns a pointer to the record class.\r
1677  */\r
1678 static boolean lookupFreezeFrameDataRecNumParam(uint8 recordNumber, const Dem_EventParameterType *eventParam, Dem_FreezeFrameClassType const **freezeFrameClassPtr)\r
1679 {\r
1680         boolean recNumFound = FALSE;\r
1681         uint16 i;\r
1682 \r
1683         if (eventParam->FreezeFrameClassRef != NULL) {\r
1684                 for (i = 0; (i < DEM_MAX_NR_OF_CLASSES_IN_FREEZEFRAME_DATA) && (eventParam->FreezeFrameClassRef[i] != NULL) && (!recNumFound); i++) {\r
1685                         if (eventParam->FreezeFrameClassRef[i]->FFRecordNumber == recordNumber) {\r
1686                                 *freezeFrameClassPtr =  eventParam->FreezeFrameClassRef[i];\r
1687                                 recNumFound = TRUE;\r
1688                         }\r
1689                 }\r
1690         }\r
1691 \r
1692         return recNumFound;\r
1693 }\r
1694 \r
1695 /*\r
1696  * Procedure:   lookupFreezeFrameDataSize\r
1697  * Description: Returns TRUE if the requested freezeFrame data size was obtained successfully from the configuration.\r
1698  *                              "dataSize" returns a pointer to the data size.\r
1699  */\r
1700 static boolean lookupFreezeFrameDataSize(uint8 recordNumber, Dem_FreezeFrameClassType const  **freezeFrameClassPtr, uint16 *dataSize)\r
1701 {\r
1702         Std_ReturnType callbackReturnCode;\r
1703         boolean dataSizeFound = TRUE;\r
1704         uint16 dataSizeLocal = 0;\r
1705         uint16 i;\r
1706 \r
1707         if (*freezeFrameClassPtr != NULL) {\r
1708                 for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && ((*freezeFrameClassPtr)->FFIdClassRef[i].Arc_EOL != TRUE); i++) { \r
1709                         if((*freezeFrameClassPtr)->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
1710                                 callbackReturnCode = (*freezeFrameClassPtr)->FFIdClassRef[i].DidReadDataLengthFnc(&dataSizeLocal);\r
1711                                 if(callbackReturnCode != E_OK){\r
1712                                         return (dataSizeFound = FALSE); \r
1713                                 }\r
1714                         }\r
1715                         else{\r
1716                                 dataSizeLocal = (*freezeFrameClassPtr)->FFIdClassRef[i].PidOrDidSize;\r
1717                         }\r
1718                         \r
1719                         *dataSize += dataSizeLocal + DEM_DID_IDENTIFIER_SIZE_OF_BYTES;\r
1720                 }\r
1721 \r
1722         }\r
1723 \r
1724         return dataSizeFound;\r
1725 }\r
1726 \r
1727 /*\r
1728  * Procedure:   lookupFreezeFrameDataPriMem\r
1729  * Description: Returns TRUE if the requested event id is found, "freezeFrame" points to the found data.\r
1730  */\r
1731 static boolean lookupFreezeFrameDataPriMem(Dem_EventIdType eventId,uint8 recordNumber, FreezeFrameRecType **freezeFrame)\r
1732 {\r
1733         boolean eventIdFound = FALSE;\r
1734         uint16 i;\r
1735 \r
1736         for (i = 0; (i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFound); i++) {\r
1737                 eventIdFound = ((priMemFreezeFrameBuffer[i].eventId == eventId) && (priMemFreezeFrameBuffer[i].recordNumber == recordNumber));\r
1738         }\r
1739 \r
1740         if (eventIdFound) {\r
1741                 *freezeFrame = &priMemFreezeFrameBuffer[i-1];\r
1742         }\r
1743 \r
1744         return eventIdFound;\r
1745 }\r
1746 \r
1747 /*\r
1748  * Procedure:   handlePreInitEvent\r
1749  * Description: Handle the updating of event status and storing of\r
1750  *                              event related data in preInit buffers.\r
1751  */\r
1752 static void handlePreInitEvent(Dem_EventIdType eventId, Dem_EventStatusType eventStatus)\r
1753 {\r
1754         const Dem_EventParameterType *eventParam;\r
1755         EventStatusRecType eventStatusLocal;\r
1756         FreezeFrameRecType freezeFrameLocal;\r
1757         ExtDataRecType extendedDataLocal;\r
1758 \r
1759         lookupEventIdParameter(eventId, &eventParam);\r
1760         if (eventParam != NULL) {\r
1761                 if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
1762                         if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
1763                                 if (eventStatus == DEM_EVENT_STATUS_FAILED) {\r
1764                                         updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
1765                                 }\r
1766                                 else {\r
1767                                         updateEventStatusRec(eventParam, eventStatus, FALSE, &eventStatusLocal);\r
1768                                 }\r
1769 \r
1770                                 if (eventStatusLocal.errorStatusChanged) {\r
1771                                         if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
1772                                                 getExtendedData(eventParam, &extendedDataLocal);\r
1773                                                 if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL) {\r
1774                                                         storeExtendedDataPreInit(eventParam, &extendedDataLocal);\r
1775                                                 }\r
1776                                                 getFreezeFrameData(eventParam, &freezeFrameLocal,eventStatus,&eventStatusLocal);\r
1777                                                 if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
1778                                                         storeFreezeFrameDataPreInit(eventParam, &freezeFrameLocal);\r
1779                                                 }\r
1780                                         }\r
1781                                 }\r
1782 \r
1783                                 \r
1784                         }\r
1785                         else {\r
1786                                 // Operation cycle not started\r
1787                                 // TODO: Report error?\r
1788                         }\r
1789                 }\r
1790                 else {\r
1791                         // Operation cycle not set\r
1792                         // TODO: Report error?\r
1793                 }\r
1794         }\r
1795         else {\r
1796                 // Event ID not configured\r
1797                 // TODO: Report error?\r
1798         }\r
1799 }\r
1800 \r
1801 \r
1802 /*\r
1803  * Procedure:   handleEvent\r
1804  * Description: Handle the updating of event status and storing of\r
1805  *                              event related data in event memory.\r
1806  */\r
1807 static Std_ReturnType handleEvent(Dem_EventIdType eventId, Dem_EventStatusType eventStatus)\r
1808 {\r
1809         Std_ReturnType returnCode = E_OK;\r
1810         const Dem_EventParameterType *eventParam;\r
1811         EventStatusRecType eventStatusLocal;\r
1812         FreezeFrameRecType freezeFrameLocal;\r
1813         ExtDataRecType extendedDataLocal;\r
1814         Dem_EventStatusType eventStatusTemp = eventStatus;\r
1815 \r
1816         lookupEventIdParameter(eventId, &eventParam);\r
1817         if (eventParam != NULL) {\r
1818                 if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
1819                         if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
1820                                 if ((!((disableDtcStorage.storageDisabled) && (checkDtcGroup(disableDtcStorage.dtcGroup, eventParam)) && (checkDtcKind(disableDtcStorage.dtcKind, eventParam)))))  {\r
1821                                         updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
1822                                         if (eventStatusLocal.errorStatusChanged) {\r
1823                                                 storeEventEvtMem(eventParam, &eventStatusLocal); /** @req DEM184 */\r
1824                                                 if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
1825                                                         getExtendedData(eventParam, &extendedDataLocal);\r
1826                                                         if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL)\r
1827                                                         {\r
1828                                                                 storeExtendedDataEvtMem(eventParam, &extendedDataLocal);\r
1829                                                         }\r
1830                                                 }\r
1831 \r
1832                                                 if ((eventStatusTemp == DEM_EVENT_STATUS_PREFAILED)\r
1833                                                                 || (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED)){\r
1834                                                         getFreezeFrameData(eventParam, &freezeFrameLocal,eventStatus,&eventStatusLocal);\r
1835                                                         if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
1836                                                                 storeFreezeFrameDataEvtMem(eventParam, &freezeFrameLocal); /** @req DEM190 */\r
1837                                                         }\r
1838                                                 }\r
1839                                                 else{\r
1840                                                         // do nothing\r
1841                                                 }\r
1842                                         }                                       \r
1843                                 }\r
1844                         }\r
1845                         else {\r
1846                                 // Operation cycle not started\r
1847                                 returnCode = E_NOT_OK;\r
1848                         }\r
1849                 }\r
1850                 else {\r
1851                         // Operation cycle not set\r
1852                         returnCode = E_NOT_OK;\r
1853                 }\r
1854         }\r
1855         else {\r
1856                 // Event ID not configured\r
1857                 returnCode = E_NOT_OK;\r
1858         }\r
1859 \r
1860         return returnCode;\r
1861 }\r
1862 \r
1863 \r
1864 /*\r
1865  * Procedure:   resetEventStatus\r
1866  * Description: Resets the events status of eventId.\r
1867  */\r
1868 static void resetEventStatus(Dem_EventIdType eventId)\r
1869 {\r
1870         EventStatusRecType *eventStatusRecPtr;\r
1871         imask_t state;\r
1872     Irq_Save(state);\r
1873 \r
1874         lookupEventStatusRec(eventId, &eventStatusRecPtr);\r
1875         if (eventStatusRecPtr != NULL) {\r
1876                 eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED; /** @req DEM187 */\r
1877         }\r
1878 \r
1879     Irq_Restore(state);\r
1880 }\r
1881 \r
1882 \r
1883 /*\r
1884  * Procedure:   getEventStatus\r
1885  * Description: Returns the extended event status bitmask of eventId in "eventStatusExtended".\r
1886  */\r
1887 static void getEventStatus(Dem_EventIdType eventId, Dem_EventStatusExtendedType *eventStatusExtended)\r
1888 {\r
1889         EventStatusRecType eventStatusLocal;\r
1890 \r
1891         // Get recorded status\r
1892         getEventStatusRec(eventId, &eventStatusLocal);\r
1893         if (eventStatusLocal.eventId == eventId) {\r
1894                 *eventStatusExtended = eventStatusLocal.eventStatusExtended; /** @req DEM051 */\r
1895         }\r
1896         else {\r
1897                 // Event Id not found, no report received.\r
1898                 *eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
1899         }\r
1900 }\r
1901 \r
1902 \r
1903 /*\r
1904  * Procedure:   getEventFailed\r
1905  * Description: Returns the TRUE or FALSE of "eventId" in "eventFailed" depending on current status.\r
1906  */\r
1907 static void getEventFailed(Dem_EventIdType eventId, boolean *eventFailed)\r
1908 {\r
1909         EventStatusRecType eventStatusLocal;\r
1910 \r
1911         // Get recorded status\r
1912         getEventStatusRec(eventId, &eventStatusLocal);\r
1913         if (eventStatusLocal.eventId == eventId) {\r
1914                 if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) { /** @req DEM052 */\r
1915                         *eventFailed = TRUE;\r
1916                 }\r
1917                 else {\r
1918                         *eventFailed = FALSE;\r
1919                 }\r
1920         }\r
1921         else {\r
1922                 // Event Id not found, assume ok.\r
1923                 *eventFailed = FALSE;\r
1924         }\r
1925 }\r
1926 \r
1927 \r
1928 /*\r
1929  * Procedure:   getEventTested\r
1930  * Description: Returns the TRUE or FALSE of "eventId" in "eventTested" depending on\r
1931  *                              current status the "test not completed this operation cycle" bit.\r
1932  */\r
1933 static void getEventTested(Dem_EventIdType eventId, boolean *eventTested)\r
1934 {\r
1935         EventStatusRecType eventStatusLocal;\r
1936 \r
1937         // Get recorded status\r
1938         getEventStatusRec(eventId, &eventStatusLocal);\r
1939         if (eventStatusLocal.eventId == eventId) {\r
1940                 if ( !(eventStatusLocal.eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE)) { /** @req DEM053 */\r
1941                         *eventTested = TRUE;\r
1942                 }\r
1943                 else {\r
1944                         *eventTested = FALSE;\r
1945                 }\r
1946         }\r
1947         else {\r
1948                 // Event Id not found, not tested.\r
1949                 *eventTested = FALSE;\r
1950         }\r
1951 }\r
1952 \r
1953 \r
1954 /*\r
1955  * Procedure:   getFaultDetectionCounter\r
1956  * Description: Returns pre debounce counter of "eventId" in "counter" and return value E_OK if\r
1957  *                              the counter was available else E_NOT_OK.\r
1958  */\r
1959 static Std_ReturnType getFaultDetectionCounter(Dem_EventIdType eventId, sint8 *counter)\r
1960 {\r
1961         Std_ReturnType returnCode = E_NOT_OK;\r
1962         const Dem_EventParameterType *eventParam;\r
1963 \r
1964         lookupEventIdParameter(eventId, &eventParam);\r
1965         if (eventParam != NULL) {\r
1966                 if (eventParam->EventClass->PreDebounceAlgorithmClass != NULL) {\r
1967                         switch (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceName)\r
1968                         {\r
1969                         case DEM_NO_PRE_DEBOUNCE:\r
1970                                 if (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal != NULL) {\r
1971                                         if (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal->CallbackGetFDCntFnc != NULL) {\r
1972                                                 returnCode = eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal->CallbackGetFDCntFnc(counter); /** @req DEM204.None */ /** @req DEM264 */ /** @req DEM265 */\r
1973                                         }\r
1974                                 }\r
1975                                 break;\r
1976 \r
1977                         case DEM_PRE_DEBOUNCE_COUNTER_BASED:\r
1978                                 {\r
1979                                         EventStatusRecType *eventStatusRec;\r
1980 \r
1981                                         lookupEventStatusRec(eventId, &eventStatusRec);\r
1982                                         if (eventStatusRec != NULL) {\r
1983                                                 *counter = eventStatusRec->faultDetectionCounter; /** @req DEM204.Counter */\r
1984                                         } else {\r
1985                                                 *counter = 0;\r
1986                                         }\r
1987                                         returnCode = E_OK;\r
1988                                 }\r
1989                                 break;\r
1990 \r
1991                         case DEM_PRE_DEBOUNCE_FREQUENCY_BASED:\r
1992                         case DEM_PRE_DEBOUNCE_TIME_BASED:\r
1993                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
1994                                 break;\r
1995 \r
1996                         default:\r
1997                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_PARAM_DATA);\r
1998                                 break;\r
1999                         }\r
2000                 }\r
2001         }\r
2002 \r
2003         return returnCode;\r
2004 }\r
2005 /*\r
2006  * Procedure:   deleteEventMemory\r
2007  * Description: If aging of an event occurs, the Dem module shall delete the event from \r
2008  *                              the event memory including its event related data\r
2009  */\r
2010 static void deleteEventMemory(const Dem_EventParameterType *eventParam)\r
2011 {\r
2012         uint16 i;\r
2013 \r
2014         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
2015                 switch (eventParam->EventClass->EventDestination[i])\r
2016                 {\r
2017                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
2018                         deleteEventPriMem(eventParam);\r
2019                         deleteFreezeFrameDataPriMem(eventParam);\r
2020                         deleteExtendedDataPriMem(eventParam);\r
2021                         storeFreezeFrameDataPerMem();\r
2022                         break;\r
2023 \r
2024                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
2025                         //TODO:need to add corresponding event and extended deleting functions\r
2026 \r
2027                         break;\r
2028 \r
2029                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
2030                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
2031                         // Not yet supported\r
2032                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
2033                         break;\r
2034 \r
2035                 default:\r
2036                         break;\r
2037                 }\r
2038 \r
2039         }\r
2040 \r
2041 }\r
2042 /*\r
2043  * Procedure:   lookupAgingRecPriMem\r
2044  * Description: Returns the pointer to event id parameters of "eventId" in "*priMemAgingBuffer",\r
2045  *                              if not found NULL is returned.\r
2046  */\r
2047 static boolean lookupAgingRecPriMem(Dem_EventIdType eventId, const HealingRecType **agingRec)\r
2048 {\r
2049         uint16 i;\r
2050         boolean agingRecFound = FALSE;\r
2051         \r
2052         for (i = 0; i < DEM_MAX_NUMBER_AGING_PRI_MEM && (!agingRecFound); i++) {\r
2053                 if(priMemAgingBuffer[i].eventId == eventId){\r
2054                         agingRecFound = TRUE;\r
2055                 }\r
2056 \r
2057         }\r
2058 \r
2059         if(agingRecFound){\r
2060                 *agingRec = &priMemAgingBuffer[i-1];\r
2061         }\r
2062         else{\r
2063                 *agingRec = NULL;\r
2064         }\r
2065 \r
2066         return agingRecFound;\r
2067 \r
2068 }\r
2069 \r
2070 \r
2071 /*\r
2072  * Procedure:   handleAging\r
2073  * Description: according to the operation state of "operationCycleId" to "cycleState" , handle the aging relatived data\r
2074  *                              Returns E_OK if operation was successful else E_NOT_OK.\r
2075  */\r
2076 static Std_ReturnType handleAging(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState)\r
2077 {\r
2078         uint16 i;\r
2079         Std_ReturnType returnCode = E_OK;\r
2080         HealingRecType *agingRecLocal = NULL;\r
2081         boolean agingRecFound = FALSE;\r
2082 \r
2083         if (operationCycleId < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
2084                 switch (cycleState)\r
2085                 {\r
2086                 case DEM_CYCLE_STATE_START:\r
2087                         break;\r
2088 \r
2089                 case DEM_CYCLE_STATE_END:/** @req Dem490 */\r
2090                         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2091                                 if(eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
2092                                         if(eventStatusBuffer[i].eventParamRef != NULL){\r
2093                                                 if(eventStatusBuffer[i].eventParamRef->EventClass != NULL){\r
2094                                                         if((eventStatusBuffer[i].eventParamRef->EventClass->HealingAllowed == TRUE)\\r
2095                                                                 && (eventStatusBuffer[i].eventParamRef->EventClass->HealingCycleRef == operationCycleId)){\r
2096                                                                 if((eventStatusBuffer[i].eventStatusExtended & DEM_CONFIRMED_DTC)\\r
2097                                                                         && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED))\\r
2098                                                                         && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE))){\r
2099                                                                         agingRecFound = lookupAgingRecPriMem(eventStatusBuffer[i].eventId, (const HealingRecType **)(&agingRecLocal));\r
2100                                                                         if(agingRecFound){\r
2101                                                                                 agingRecLocal->agingCounter++;/** @req Dem489 */\r
2102                                                                                 agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(HealingRecType) - sizeof(ChecksumType));\r
2103                                                                                 if(agingRecLocal->agingCounter > eventStatusBuffer[i].eventParamRef->EventClass->HealingCycleCounter){\r
2104                                                                                         //deleteEventMemory(eventStatusBuffer[i].eventParamRef); /** @req Dem497 */\r
2105 \r
2106                                                                                         deleteAgingRecPriMem(eventStatusBuffer[i].eventParamRef);\r
2107 \r
2108                                                                                         eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_CONFIRMED_DTC);\r
2109                                                                                         eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_PENDING_DTC);\r
2110                                                                                         eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_WARNING_INDICATOR_REQUESTED);\r
2111                                                                                 }\r
2112                                                                                 /* Set the flag,start up the storage of NVRam in main function. */\r
2113                                                                                 AgingIsModified = TRUE;\r
2114                                                                         }\r
2115                                                                         else{\r
2116                                                                                 /* If it does exist,establish a new record for the corresponding event */\r
2117                                                                                 agingRecFound = lookupAgingRecPriMem(DEM_EVENT_ID_NULL, (const HealingRecType **)(&agingRecLocal));\r
2118                                                                                 if(agingRecFound){\r
2119                                                                                         agingRecLocal->eventId = eventStatusBuffer[i].eventId;\r
2120                                                                                         agingRecLocal->agingCounter++;\r
2121                                                                                         agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(HealingRecType) - sizeof(ChecksumType));\r
2122                                                                                         AgingIsModified = TRUE;\r
2123                                                                                 }\r
2124                                                                                 else{\r
2125                                                                                         /* primary memory of aging records is full. */\r
2126                                                                                 }\r
2127                                                                         }\r
2128                                                                 }\r
2129                                                                 else{\r
2130                                                                         /* If the status bit testFailed (bit 0) is set during the operation cycle, the counter shall be reset. */\r
2131                                                                         if(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED){\r
2132                                                                                 agingRecFound = lookupAgingRecPriMem(eventStatusBuffer[i].eventId, (const HealingRecType **)(&agingRecLocal));\r
2133                                                                                 if(agingRecFound){\r
2134                                                                                         if(agingRecLocal->agingCounter){\r
2135                                                                                                 agingRecLocal->agingCounter = 0;\r
2136                                                                                                 agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(HealingRecType) - sizeof(ChecksumType));\r
2137                                                                                                 AgingIsModified = TRUE;\r
2138                                                                                         }\r
2139                                                                                 }\r
2140                                                                         }\r
2141                                                                 }\r
2142                                                         }\r
2143                                                 }\r
2144                                         }\r
2145                                 }\r
2146                         }\r
2147                         break;\r
2148                 default:\r
2149                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
2150                         returnCode = E_NOT_OK;\r
2151                         break;\r
2152                 }\r
2153         }\r
2154         else {\r
2155                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
2156                 returnCode = E_NOT_OK;\r
2157                 }\r
2158 \r
2159         return returnCode;\r
2160 \r
2161 }\r
2162 \r
2163 /*\r
2164  * Procedure:   setOperationCycleState\r
2165  * Description: Change the operation state of "operationCycleId" to "cycleState" and updates stored\r
2166  *                              event connected to this cycle id.\r
2167  *                              Returns E_OK if operation was successful else E_NOT_OK.\r
2168  */\r
2169 static Std_ReturnType setOperationCycleState(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState) /** @req DEM338 */\r
2170 {\r
2171         uint16 i;\r
2172         Std_ReturnType returnCode = E_OK;\r
2173 \r
2174         if (operationCycleId < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
2175                 switch (cycleState)\r
2176                 {\r
2177                 case DEM_CYCLE_STATE_START:\r
2178                         operationCycleStateList[operationCycleId] = cycleState;\r
2179                         // Lookup event ID\r
2180                         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2181                                 if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
2182                                         eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_TEST_FAILED_THIS_OPERATION_CYCLE;\r
2183                                         eventStatusBuffer[i].eventStatusExtended |= DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE;\r
2184                                 }\r
2185                         }\r
2186                         break;\r
2187 \r
2188                 case DEM_CYCLE_STATE_END:\r
2189                         operationCycleStateList[operationCycleId] = cycleState;\r
2190                         // Lookup event ID\r
2191                         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2192                                 if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
2193                                         if ((!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED_THIS_OPERATION_CYCLE)) && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE))) {\r
2194                                                 eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_PENDING_DTC;              // Clear pendingDTC bit /** @req DEM379.PendingClear\r
2195                                                 storeEventEvtMem(eventStatusBuffer[i].eventParamRef, &eventStatusBuffer[i]);\r
2196                                         }\r
2197                                 }\r
2198                         }\r
2199                         break;\r
2200                 default:\r
2201                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
2202                         returnCode = E_NOT_OK;\r
2203                         break;\r
2204                 }\r
2205         }\r
2206         else {\r
2207                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
2208                 returnCode = E_NOT_OK;\r
2209                 }\r
2210 \r
2211         return returnCode;\r
2212 }\r
2213 \r
2214 \r
2215 //==============================================================================//\r
2216 //                                                                                                                                                              //\r
2217 //                                        E X T E R N A L   F U N C T I O N S                                           //\r
2218 //                                                                                                                                                              //\r
2219 //==============================================================================//\r
2220 \r
2221 /*********************************************\r
2222  * Interface for upper layer modules (8.3.1) *\r
2223  *********************************************/\r
2224 \r
2225 /*\r
2226  * Procedure:   Dem_GetVersionInfo\r
2227  * Reentrant:   Yes\r
2228  */\r
2229 // Defined in Dem.h\r
2230 \r
2231 \r
2232 /***********************************************\r
2233  * Interface ECU State Manager <-> DEM (8.3.2) *\r
2234  ***********************************************/\r
2235 \r
2236 /*\r
2237  * Procedure:   Dem_PreInit\r
2238  * Reentrant:   No\r
2239  */\r
2240 void Dem_PreInit(void)\r
2241 {\r
2242         /** @req DEM180 */\r
2243         uint16 i, j;\r
2244 \r
2245         EventStatusRecType *eventStatusRecPtr;\r
2246         const Dem_EventParameterType *eventIdParamList;\r
2247 \r
2248         VALIDATE_NO_RV(DEM_Config.ConfigSet != NULL, DEM_PREINIT_ID, DEM_E_CONFIG_PTR_INVALID);\r
2249 \r
2250         configSet = DEM_Config.ConfigSet;\r
2251 \r
2252         // Initializion of operation cycle states.\r
2253         for (i = 0; i < DEM_OPERATION_CYCLE_ID_ENDMARK; i++) {\r
2254                 operationCycleStateList[i] = DEM_CYCLE_STATE_END;\r
2255         }\r
2256 \r
2257         // Initialize the event status buffer\r
2258         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2259                 eventStatusBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
2260                 eventStatusBuffer[i].eventParamRef = NULL;\r
2261                 eventStatusBuffer[i].faultDetectionCounter = 0;\r
2262                 eventStatusBuffer[i].occurrence = 0;\r
2263                 eventStatusBuffer[i].eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
2264                 eventStatusBuffer[i].errorStatusChanged = FALSE;\r
2265         }\r
2266 \r
2267         // Insert all supported events into event status buffer\r
2268         uint16 index = 0;\r
2269         eventIdParamList = configSet->EventParameter;\r
2270         while( !eventIdParamList[index].Arc_EOL ) {\r
2271                 // Find next free position in event status buffer\r
2272                 lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
2273                 if(NULL != eventStatusRecPtr) {\r
2274                         eventStatusRecPtr->eventId = eventIdParamList[index].EventID;\r
2275                         eventStatusRecPtr->eventParamRef = &eventIdParamList[index];\r
2276                 } else {\r
2277                         // event status buffer is full\r
2278                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_PREINIT_ID, DEM_E_EVENT_STATUS_BUFF_FULL);\r
2279                 }\r
2280                 index++;\r
2281         }\r
2282 \r
2283         //lint -save\r
2284         //lint -e568 -e685 //PC-Lint exception.\r
2285         //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when config variable is zero. Keep as it is for less complex code.\r
2286         // Initialize the pre init buffers\r
2287         for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
2288                 preInitFreezeFrameBuffer[i].checksum = 0;\r
2289                 preInitFreezeFrameBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
2290                 preInitFreezeFrameBuffer[i].occurrence = 0;\r
2291                 preInitFreezeFrameBuffer[i].dataSize = 0;\r
2292                 for (j = 0; j < DEM_MAX_SIZE_FF_DATA;j++){\r
2293                         preInitFreezeFrameBuffer[i].data[j] = 0;\r
2294                 }\r
2295         }\r
2296         //lint -restore\r
2297 \r
2298         for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
2299                 preInitExtDataBuffer[i].checksum = 0;\r
2300                 preInitExtDataBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
2301                 preInitExtDataBuffer[i].dataSize = 0;\r
2302                 for (j = 0; j < DEM_MAX_SIZE_EXT_DATA;j++){\r
2303                         preInitExtDataBuffer[i].data[j] = 0;\r
2304                 }\r
2305         }\r
2306 \r
2307         disableDtcStorage.storageDisabled = FALSE;\r
2308 \r
2309         (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START); /** @req DEM047 */\r
2310 \r
2311         demState = DEM_PREINITIALIZED;\r
2312 }\r
2313 \r
2314 \r
2315 /*\r
2316  * Procedure:   Dem_Init\r
2317  * Reentrant:   No\r
2318  */\r
2319 void Dem_Init(void)\r
2320 {\r
2321         uint16 i;\r
2322         ChecksumType cSum;\r
2323         boolean entryValid = FALSE;\r
2324         const Dem_EventParameterType *eventParam;\r
2325 \r
2326         if(DEM_PREINITIALIZED != demState){\r
2327                 /*\r
2328                  * Dem_PreInit was has not been called since last time Dem_Shutdown was called.\r
2329                  * This suggests that we are resuming from sleep. According to section 5.7 in\r
2330                  * EcuM specification, RAM content is assumed to be still valid from the previous cycle.\r
2331                  * Do not read from saved error log since buffers already contains this data.\r
2332                  */\r
2333                 (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START);\r
2334 \r
2335         } else {\r
2336 \r
2337                 for(i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
2338                         if( E_NOT_OK == copyNvmMirror(FreezeFrameBlockId[i], (uint8 *)&priMemFreezeFrameBuffer[i], (const uint8 *)&FreezeFrameMirrorBuffer[i], sizeof(FreezeFrameRecType)) ){\r
2339                                 //TODO:NVM is busy or block id is 0,report error or what?\r
2340                         }\r
2341                 }\r
2342                 //recover Aging from NVRam to RAM\r
2343                 if(E_OK == copyNvmMirror(HealingBlockId, (uint8*)priMemAgingBuffer, (const uint8*)HealingMirrorBuffer, sizeof(priMemAgingBuffer)) ){\r
2344 \r
2345                 }\r
2346 \r
2347                 // Validate aging records stored in primary memory\r
2348                 for (i = 0; i < DEM_MAX_NUMBER_AGING_PRI_MEM; i++){\r
2349                         entryValid = checkEntryValid(priMemAgingBuffer[i].eventId);\r
2350                         cSum = calcChecksum(&priMemAgingBuffer[i], sizeof(HealingRecType) - sizeof(ChecksumType));\r
2351                         if ((cSum != priMemAgingBuffer[i].checksum) || (priMemAgingBuffer[i].eventId == DEM_EVENT_ID_NULL) || (FALSE == entryValid)) {\r
2352                                 // Unlegal record, clear the record\r
2353                                 memset(&priMemAgingBuffer[i], 0, sizeof(HealingRecType));\r
2354                                 AgingIsModified = TRUE;\r
2355                         }\r
2356                 }\r
2357 \r
2358                 // Validate event records stored in primary memory\r
2359                 for (i = 0; i < DEM_MAX_NUMBER_EVENT_PRI_MEM; i++) {\r
2360                         entryValid = checkEntryValid(priMemEventBuffer[i].eventId);\r
2361                         cSum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
2362                         if ((cSum != priMemEventBuffer[i].checksum) || (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL) || (FALSE == entryValid)) {\r
2363                                 // Unlegal record, clear the record\r
2364                                 memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
2365                         }\r
2366                         else {\r
2367                                 // Valid, update current status\r
2368                                 mergeEventStatusRec(&priMemEventBuffer[i]);\r
2369 \r
2370                                 // Update occurrence counter on pre init stored freeze frames\r
2371                                 updateFreezeFrameOccurrencePreInit(&priMemEventBuffer[i]);\r
2372                         }\r
2373                 }\r
2374 \r
2375                 //initialize the current timestamp and update the timestamp in pre init\r
2376                 initCurrentFreezeFrameTimeStamp(&FF_TimeStamp);\r
2377 \r
2378                 // Validate extended data records stored in primary memory\r
2379                 for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM; i++) {\r
2380                         entryValid = checkEntryValid(priMemExtDataBuffer[i].eventId);\r
2381                         cSum = calcChecksum(&priMemExtDataBuffer[i], sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
2382                         if ((cSum != priMemExtDataBuffer[i].checksum) || (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL) || (FALSE == entryValid)) {\r
2383                                 // Unlegal record, clear the record\r
2384                                 memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
2385                         }\r
2386                 }\r
2387 \r
2388                 //initialize the current timestamp and update the timestamp in pre init\r
2389                 initCurrentFreezeFrameTimeStamp(&FF_TimeStamp);\r
2390 \r
2391                 //lint -save\r
2392                 //lint -e568 //PC-Lint exception.\r
2393                 //lint -e685 //PC-Lint exception.\r
2394                 //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
2395                 // Validate freeze frame records stored in primary memory\r
2396                 for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++) {\r
2397                         entryValid = checkEntryValid(priMemFreezeFrameBuffer[i].eventId);\r
2398                         cSum = calcChecksum(&priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
2399                         if ((cSum != priMemFreezeFrameBuffer[i].checksum) || (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL) || (FALSE == entryValid)) {\r
2400                                 // Unlegal record, clear the record\r
2401                                 memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
2402                         }\r
2403                 }\r
2404                 //lint -restore\r
2405 \r
2406                 /* Transfer updated event data to event memory */\r
2407                 for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2408                         if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
2409                                 lookupEventIdParameter(eventStatusBuffer[i].eventId, &eventParam);\r
2410                                 storeEventEvtMem(eventParam, &eventStatusBuffer[i]);\r
2411                         }\r
2412                 }\r
2413 \r
2414                 /* Transfer extended data to event memory if necessary */\r
2415                 for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
2416                         if (preInitExtDataBuffer[i].eventId !=  DEM_EVENT_ID_NULL) {\r
2417                                 lookupEventIdParameter(preInitExtDataBuffer[i].eventId, &eventParam);\r
2418                                 storeExtendedDataEvtMem(eventParam, &preInitExtDataBuffer[i]);\r
2419                         }\r
2420                 }\r
2421 \r
2422                 //lint -save\r
2423                 //lint -e568 //PC-Lint exception.\r
2424                 //lint -e685 //PC-Lint exception.\r
2425                 //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
2426                 /* Transfer freeze frames to event memory */\r
2427                 for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
2428                         if (preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
2429                                 lookupEventIdParameter(preInitFreezeFrameBuffer[i].eventId, &eventParam);\r
2430                                 storeFreezeFrameDataEvtMem(eventParam, &preInitFreezeFrameBuffer[i]);\r
2431                         }\r
2432                 }\r
2433                 //lint -restore\r
2434         }\r
2435 \r
2436         // Init the dtc filter\r
2437         dtcFilter.dtcStatusMask = DEM_DTC_STATUS_MASK_ALL;                                      // All allowed\r
2438         dtcFilter.dtcKind = DEM_DTC_KIND_ALL_DTCS;                                                      // All kinds of DTCs\r
2439         dtcFilter.dtcOrigin = DEM_DTC_ORIGIN_PRIMARY_MEMORY;                            // Primary memory\r
2440         dtcFilter.filterWithSeverity = DEM_FILTER_WITH_SEVERITY_NO;                     // No Severity filtering\r
2441         dtcFilter.dtcSeverityMask = DEM_SEVERITY_NO_SEVERITY;                           // Not used when filterWithSeverity is FALSE\r
2442         dtcFilter.filterForFaultDetectionCounter = DEM_FILTER_FOR_FDC_NO;       // No fault detection counter filtering\r
2443 \r
2444         dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
2445 \r
2446         disableDtcStorage.storageDisabled = FALSE;\r
2447 \r
2448         demState = DEM_INITIALIZED;\r
2449 }\r
2450 \r
2451 \r
2452 /*\r
2453  * Procedure:   Dem_shutdown\r
2454  * Reentrant:   No\r
2455  */\r
2456 void Dem_Shutdown(void)\r
2457 {\r
2458         (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_END); /** @req DEM047 */\r
2459 \r
2460         /* handleAging() should be called behind setOperationCycleState() */\r
2461         (void)handleAging(DEM_ACTIVE, DEM_CYCLE_STATE_END);\r
2462 \r
2463         demState = DEM_UNINITIALIZED; /** @req DEM368 */\r
2464 }\r
2465 \r
2466 \r
2467 /*\r
2468  * Interface for basic software scheduler\r
2469  */\r
2470 void Dem_MainFunction(void)/** @req DEM125 */\r
2471 {       \r
2472         if (FFIsModified) {\r
2473                 storeFreezeFrameDataPerMem(FreezeFrameBlockId);\r
2474         }\r
2475 \r
2476         if (AgingIsModified) {\r
2477                 storeAgingRecPerMem(HealingBlockId);\r
2478         }\r
2479 }\r
2480 \r
2481 \r
2482 /***************************************************\r
2483  * Interface SW-Components via RTE <-> DEM (8.3.3) *\r
2484  ***************************************************/\r
2485 \r
2486 /*\r
2487  * Procedure:   Dem_SetEventStatus\r
2488  * Reentrant:   Yes\r
2489  */\r
2490 Std_ReturnType Dem_SetEventStatus(Dem_EventIdType eventId, Dem_EventStatusType eventStatus) /** @req DEM330 */\r
2491 {\r
2492         Std_ReturnType returnCode = E_OK;\r
2493 \r
2494         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2495         {\r
2496                 returnCode = handleEvent(eventId, eventStatus);\r
2497         }\r
2498         else\r
2499         {\r
2500                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETEVENTSTATUS_ID, DEM_E_UNINIT);\r
2501                 returnCode = E_NOT_OK;\r
2502         }\r
2503 \r
2504         return returnCode;\r
2505 }\r
2506 \r
2507 \r
2508 /*\r
2509  * Procedure:   Dem_ResetEventStatus\r
2510  * Reentrant:   Yes\r
2511  */\r
2512 Std_ReturnType Dem_ResetEventStatus(Dem_EventIdType eventId) /** @req DEM331 */\r
2513 {\r
2514         Std_ReturnType returnCode = E_OK;\r
2515 \r
2516         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2517         {\r
2518                 resetEventStatus(eventId); /** @req DEM186 */\r
2519         }\r
2520         else\r
2521         {\r
2522                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_RESETEVENTSTATUS_ID, DEM_E_UNINIT);\r
2523                 returnCode = E_NOT_OK;\r
2524         }\r
2525 \r
2526         return returnCode;\r
2527 }\r
2528 \r
2529 \r
2530 /*\r
2531  * Procedure:   Dem_GetEventStatus\r
2532  * Reentrant:   Yes\r
2533  */\r
2534 Std_ReturnType Dem_GetEventStatus(Dem_EventIdType eventId, Dem_EventStatusExtendedType *eventStatusExtended) /** @req DEM332 */\r
2535 {\r
2536         Std_ReturnType returnCode = E_OK;\r
2537 \r
2538         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2539         {\r
2540                 getEventStatus(eventId, eventStatusExtended);\r
2541         }\r
2542         else\r
2543         {\r
2544                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETEVENTSTATUS_ID, DEM_E_UNINIT);\r
2545                 returnCode = E_NOT_OK;\r
2546         }\r
2547 \r
2548         return returnCode;\r
2549 }\r
2550 \r
2551 \r
2552 /*\r
2553  * Procedure:   Dem_GetEventFailed\r
2554  * Reentrant:   Yes\r
2555  */\r
2556 Std_ReturnType Dem_GetEventFailed(Dem_EventIdType eventId, boolean *eventFailed) /** @req DEM333 */\r
2557 {\r
2558         Std_ReturnType returnCode = E_OK;\r
2559 \r
2560         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2561         {\r
2562                 getEventFailed(eventId, eventFailed);\r
2563         }\r
2564         else\r
2565         {\r
2566                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETEVENTFAILED_ID, DEM_E_UNINIT);\r
2567                 returnCode = E_NOT_OK;\r
2568         }\r
2569 \r
2570         return returnCode;\r
2571 }\r
2572 \r
2573 \r
2574 /*\r
2575  * Procedure:   Dem_GetEventTested\r
2576  * Reentrant:   Yes\r
2577  */\r
2578 Std_ReturnType Dem_GetEventTested(Dem_EventIdType eventId, boolean *eventTested)\r
2579 {\r
2580         Std_ReturnType returnCode = E_OK;\r
2581 \r
2582         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2583         {\r
2584                 getEventTested(eventId, eventTested);\r
2585         }\r
2586         else\r
2587         {\r
2588                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETEVENTTESTED_ID, DEM_E_UNINIT);\r
2589                 returnCode = E_NOT_OK;\r
2590         }\r
2591 \r
2592         return returnCode;\r
2593 }\r
2594 \r
2595 \r
2596 /*\r
2597  * Procedure:   Dem_GetFaultDetectionCounter\r
2598  * Reentrant:   No\r
2599  */\r
2600 Std_ReturnType Dem_GetFaultDetectionCounter(Dem_EventIdType eventId, sint8 *counter)\r
2601 {\r
2602         Std_ReturnType returnCode = E_OK;\r
2603 \r
2604         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2605         {\r
2606                 returnCode = getFaultDetectionCounter(eventId, counter);\r
2607         }\r
2608         else\r
2609         {\r
2610                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_UNINIT);\r
2611                 returnCode = E_NOT_OK;\r
2612         }\r
2613 \r
2614         return returnCode;\r
2615 }\r
2616 \r
2617 \r
2618 /*\r
2619  * Procedure:   Dem_SetOperationCycleState\r
2620  * Reentrant:   No\r
2621  */\r
2622 Std_ReturnType Dem_SetOperationCycleState(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState)\r
2623 {\r
2624         Std_ReturnType returnCode = E_OK;\r
2625 \r
2626         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2627         {\r
2628                 returnCode = setOperationCycleState(operationCycleId, cycleState);\r
2629                 (void)handleAging(operationCycleId, cycleState);\r
2630 \r
2631         }\r
2632         else\r
2633         {\r
2634                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_UNINIT);\r
2635                 returnCode = E_NOT_OK;\r
2636         }\r
2637 \r
2638         return returnCode;\r
2639 }\r
2640 \r
2641 \r
2642 /*\r
2643  * Procedure:   Dem_GetDTCOfEvent\r
2644  * Reentrant:   Yes\r
2645  */\r
2646 Std_ReturnType Dem_GetDTCOfEvent(Dem_EventIdType eventId, Dem_DTCKindType dtcKind, uint32* dtcOfEvent)\r
2647 {\r
2648         Std_ReturnType returnCode = E_NO_DTC_AVAILABLE;\r
2649         const Dem_EventParameterType *eventParam;\r
2650 \r
2651         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
2652         {\r
2653                 lookupEventIdParameter(eventId, &eventParam);\r
2654 \r
2655                 if (eventParam != NULL) {\r
2656                         if (checkDtcKind(dtcKind, eventParam)) {\r
2657                                 if (eventParam->DTCClassRef != NULL) {\r
2658                                         *dtcOfEvent = eventParam->DTCClassRef->DTC; /** @req DEM269 */\r
2659                                         returnCode = E_OK;\r
2660                                 }\r
2661                         }\r
2662                 }\r
2663                 else {\r
2664                         // Event Id not found\r
2665                         returnCode = E_NOT_OK;\r
2666                 }\r
2667         }\r
2668         else\r
2669         {\r
2670                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETDTCOFEVENT_ID, DEM_UNINITIALIZED);\r
2671                 returnCode = E_NOT_OK;\r
2672         }\r
2673 \r
2674         return returnCode;\r
2675 }\r
2676 \r
2677 \r
2678 /********************************************\r
2679  * Interface BSW-Components <-> DEM (8.3.4) *\r
2680  ********************************************/\r
2681 \r
2682 /*\r
2683  * Procedure:   Dem_ReportErrorStatus\r
2684  * Reentrant:   Yes\r
2685  */\r
2686 void Dem_ReportErrorStatus( Dem_EventIdType eventId, Dem_EventStatusType eventStatus ) /** @req DEM107 *//** @req DEM206 */\r
2687 {\r
2688 \r
2689         switch (demState) {\r
2690                 case DEM_PREINITIALIZED:\r
2691                         // Update status and check if is to be stored\r
2692                         if ((eventStatus == DEM_EVENT_STATUS_PASSED) || (eventStatus == DEM_EVENT_STATUS_FAILED)) {\r
2693                                 handlePreInitEvent(eventId, eventStatus); /** @req DEM168 */\r
2694                         }\r
2695                         break;\r
2696 \r
2697                 case DEM_INITIALIZED:\r
2698                         (void)handleEvent(eventId, eventStatus);        /** @req DEM167 */\r
2699                         break;\r
2700 \r
2701                 case DEM_UNINITIALIZED:\r
2702                 default:\r
2703                         // Uninitialized can not do anything\r
2704                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_REPORTERRORSTATUS_ID, DEM_E_UNINIT);\r
2705 \r
2706                         break;\r
2707 \r
2708         } // switch (demState)\r
2709 }\r
2710 \r
2711 /*********************************\r
2712  * Interface DCM <-> DEM (8.3.5) *\r
2713  *********************************/\r
2714 /*\r
2715  * Procedure:   Dem_GetDTCStatusAvailabilityMask\r
2716  * Reentrant:   No\r
2717  */\r
2718 Std_ReturnType Dem_GetDTCStatusAvailabilityMask(uint8 *dtcStatusMask) /** @req DEM014 */\r
2719 {\r
2720         *dtcStatusMask =        DEM_DTC_STATUS_AVAILABILITY_MASK;               // User configuration mask\r
2721         *dtcStatusMask &=       DEM_TEST_FAILED                                                 // Mask with supported bits /** @req DEM060 */\r
2722                                                 | DEM_TEST_FAILED_THIS_OPERATION_CYCLE\r
2723                                                 | DEM_PENDING_DTC\r
2724                                                 | DEM_CONFIRMED_DTC\r
2725                                                 | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR\r
2726                                                 | DEM_TEST_FAILED_SINCE_LAST_CLEAR\r
2727                                                 | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE\r
2728 //                                              | DEM_WARNING_INDICATOR_REQUESTED       TODO: Add support for this bit\r
2729                                                 ;\r
2730 \r
2731         return E_OK;\r
2732 }\r
2733 \r
2734 \r
2735 /*\r
2736  * Procedure:   Dem_SetDTCFilter\r
2737  * Reentrant:   No\r
2738  */\r
2739 Dem_ReturnSetDTCFilterType Dem_SetDTCFilter(uint8 dtcStatusMask,\r
2740                 Dem_DTCKindType dtcKind,\r
2741                 Dem_DTCOriginType dtcOrigin,\r
2742                 Dem_FilterWithSeverityType filterWithSeverity,\r
2743                 Dem_DTCSeverityType dtcSeverityMask,\r
2744                 Dem_FilterForFDCType filterForFaultDetectionCounter)\r
2745 {\r
2746         Dem_ReturnSetDTCFilterType returnCode = DEM_FILTER_ACCEPTED;\r
2747 \r
2748         if (demState == DEM_INITIALIZED) {\r
2749                 // Check dtcKind parameter\r
2750                 VALIDATE_RV((dtcKind == DEM_DTC_KIND_ALL_DTCS) || (dtcKind == DEM_DTC_KIND_EMISSION_REL_DTCS), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
2751 \r
2752                 // Check dtcOrigin parameter\r
2753                 VALIDATE_RV((dtcOrigin == DEM_DTC_ORIGIN_SECONDARY_MEMORY) || (dtcOrigin == DEM_DTC_ORIGIN_PRIMARY_MEMORY)\r
2754                                         || (dtcOrigin == DEM_DTC_ORIGIN_PERMANENT_MEMORY) || (dtcOrigin == DEM_DTC_ORIGIN_MIRROR_MEMORY), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
2755 \r
2756                 // Check filterWithSeverity and dtcSeverityMask parameter\r
2757                 VALIDATE_RV(((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
2758                                         || ((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES)\r
2759                                                 && (!(dtcSeverityMask & (Dem_DTCSeverityType)~(DEM_SEVERITY_MAINTENANCE_ONLY | DEM_SEVERITY_CHECK_AT_NEXT_FALT | DEM_SEVERITY_CHECK_IMMEDIATELY))))), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
2760 \r
2761                 // Check filterForFaultDetectionCounter parameter\r
2762                 VALIDATE_RV((filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_YES) || (filterForFaultDetectionCounter ==  DEM_FILTER_FOR_FDC_NO), DEM_SETDTCFILTER_ID, DEM_E_PARAM_DATA, DEM_WRONG_FILTER);\r
2763 \r
2764                 // Yes all parameters correct, set the new filters.  /** @req DEM057 */\r
2765                 dtcFilter.dtcStatusMask = dtcStatusMask;\r
2766                 dtcFilter.dtcKind = dtcKind;\r
2767                 dtcFilter.dtcOrigin = dtcOrigin;\r
2768                 dtcFilter.filterWithSeverity = filterWithSeverity;\r
2769                 dtcFilter.dtcSeverityMask = dtcSeverityMask;\r
2770                 dtcFilter.filterForFaultDetectionCounter = filterForFaultDetectionCounter;\r
2771                 dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
2772         } else {\r
2773                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETDTCFILTER_ID, DEM_E_UNINIT);\r
2774                 returnCode = DEM_WRONG_FILTER;\r
2775         }\r
2776 \r
2777         return returnCode;\r
2778 }\r
2779 \r
2780 \r
2781 /*\r
2782  * Procedure:   Dem_GetStatusOfDTC\r
2783  * Reentrant:   No\r
2784  */\r
2785 Dem_ReturnGetStatusOfDTCType Dem_GetStatusOfDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, Dem_EventStatusExtendedType* status) {\r
2786         Dem_ReturnGetStatusOfDTCType returnCode = DEM_STATUS_FAILED;\r
2787         EventStatusRecType *eventRec;\r
2788 \r
2789         if (demState == DEM_INITIALIZED) {\r
2790                 if (lookupDtcEvent(dtc, &eventRec)) {\r
2791                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
2792                                 if (checkDtcOrigin(dtcOrigin,eventRec->eventParamRef)) {\r
2793                                         *status = eventRec->eventStatusExtended; /** @req DEM059 */\r
2794                                         returnCode = DEM_STATUS_OK;\r
2795                                 }\r
2796                                 else {\r
2797                                         returnCode = DEM_STATUS_WRONG_DTCORIGIN; /** @req DEM171 */\r
2798                                 }\r
2799                         }\r
2800                         else {\r
2801                                 returnCode = DEM_STATUS_WRONG_DTCKIND;\r
2802                         }\r
2803                 }\r
2804                 else {\r
2805                         returnCode = DEM_STATUS_WRONG_DTC; /** @req DEM172 */\r
2806                 }\r
2807         } else {\r
2808                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETSTATUSOFDTC_ID, DEM_E_UNINIT);\r
2809                 returnCode = DEM_STATUS_FAILED;\r
2810         }\r
2811 \r
2812         return returnCode;\r
2813 }\r
2814 \r
2815 \r
2816 /*\r
2817  * Procedure:   Dem_GetNumberOfFilteredDtc\r
2818  * Reentrant:   No\r
2819  */\r
2820 Dem_ReturnGetNumberOfFilteredDTCType Dem_GetNumberOfFilteredDtc(uint16 *numberOfFilteredDTC) {\r
2821         uint16 i;\r
2822         uint16 numberOfFaults = 0;\r
2823         Dem_ReturnGetNumberOfFilteredDTCType returnCode = DEM_NUMBER_OK;\r
2824 \r
2825         if (demState == DEM_INITIALIZED) {\r
2826                 //Dem_DisableEventStatusUpdate();\r
2827 \r
2828                 for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2829                         if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
2830                                 if (matchEventWithDtcFilter(&eventStatusBuffer[i])) {\r
2831                                         if (eventStatusBuffer[i].eventParamRef->DTCClassRef != NULL) {\r
2832                                                 numberOfFaults++;\r
2833                                         }\r
2834                                 }\r
2835                         }\r
2836                 }\r
2837 \r
2838                 //Dem_EnableEventStatusUpdate();\r
2839 \r
2840                 *numberOfFilteredDTC = numberOfFaults; /** @req DEM061 */\r
2841         } else {\r
2842                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETNUMBEROFFILTEREDDTC_ID, DEM_E_UNINIT);\r
2843                 returnCode = DEM_NUMBER_FAILED;\r
2844         }\r
2845 \r
2846         return returnCode;\r
2847 }\r
2848 \r
2849 \r
2850 /*\r
2851  * Procedure:   Dem_GetNextFilteredDTC\r
2852  * Reentrant:   No\r
2853  */\r
2854 Dem_ReturnGetNextFilteredDTCType Dem_GetNextFilteredDTC(uint32 *dtc, Dem_EventStatusExtendedType *dtcStatus)\r
2855 {\r
2856         Dem_ReturnGetNextFilteredDTCType returnCode = DEM_FILTERED_OK;\r
2857         boolean dtcFound = FALSE;\r
2858 \r
2859         if (demState == DEM_INITIALIZED) {\r
2860                 // TODO: This job should be done in an more advanced way according to Dem217\r
2861                 while ((!dtcFound) && (dtcFilter.faultIndex != 0)) {\r
2862                         dtcFilter.faultIndex--;\r
2863                         if (eventStatusBuffer[dtcFilter.faultIndex].eventId != DEM_EVENT_ID_NULL) {\r
2864                                 if (matchEventWithDtcFilter(&eventStatusBuffer[dtcFilter.faultIndex])) {\r
2865                                         if (eventStatusBuffer[dtcFilter.faultIndex].eventParamRef->DTCClassRef != NULL) {\r
2866                                                 *dtc = eventStatusBuffer[dtcFilter.faultIndex].eventParamRef->DTCClassRef->DTC; /** @req DEM216 */\r
2867                                                 *dtcStatus = eventStatusBuffer[dtcFilter.faultIndex].eventStatusExtended;\r
2868                                                 dtcFound = TRUE;\r
2869                                         }\r
2870                                 }\r
2871                         }\r
2872                 }\r
2873 \r
2874                 if (!dtcFound) {\r
2875                         dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
2876                         returnCode = DEM_FILTERED_NO_MATCHING_DTC;\r
2877                 }\r
2878         } else {\r
2879                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETNEXTFILTEREDDTC_ID, DEM_E_UNINIT);\r
2880                 returnCode = DEM_FILTERED_NO_MATCHING_DTC;\r
2881         }\r
2882 \r
2883         return returnCode;\r
2884 }\r
2885 \r
2886 \r
2887 /*\r
2888  * Procedure:   Dem_GetTranslationType\r
2889  * Reentrant:   No\r
2890  */\r
2891 Dem_ReturnTypeOfDtcSupportedType Dem_GetTranslationType(void)\r
2892 {\r
2893         return DEM_TYPE_OF_DTC_SUPPORTED; /** @req DEM231 */\r
2894 }\r
2895 \r
2896 \r
2897 /*\r
2898  * Procedure:   Dem_ClearDTC\r
2899  * Reentrant:   No\r
2900  */\r
2901 Dem_ReturnClearDTCType Dem_ClearDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin) /** @req DEM009 *//** @req DEM241 */\r
2902 {\r
2903         Dem_ReturnClearDTCType returnCode = DEM_CLEAR_OK;\r
2904         Dem_EventIdType eventId;\r
2905         const Dem_EventParameterType *eventParam;\r
2906         uint16 i, j;\r
2907 \r
2908         if (demState == DEM_INITIALIZED) {\r
2909                 for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
2910                         eventId = eventStatusBuffer[i].eventId;\r
2911                         if (eventId != DEM_EVENT_ID_NULL) {\r
2912                                 eventParam = eventStatusBuffer[i].eventParamRef;\r
2913                                 if (eventParam != NULL) {\r
2914                                         //lint --e(506) PC-Lint exception Misra 13.7, 14.1 Allow configuration variables in boolean expression\r
2915                                         //lint --e(774) PC-Lint exception       Related to MISRA 13.7\r
2916                                         if ((DEM_CLEAR_ALL_EVENTS == STD_ON) || (eventParam->DTCClassRef != NULL)) {\r
2917                                                 if (checkDtcKind(dtcKind, eventParam)) {\r
2918                                                         if (checkDtcGroup(dtc, eventParam)) {\r
2919                                                                 boolean dtcOriginFound = FALSE;\r
2920                                                                 for (j = 0; (j < DEM_MAX_NR_OF_EVENT_DESTINATION) && (!dtcOriginFound) ; j++){\r
2921                                                                         dtcOriginFound =(eventParam->EventClass->EventDestination[j] == dtcOrigin);\r
2922                                                                 }\r
2923                                                                 if (dtcOriginFound) {\r
2924                                                                         switch (dtcOrigin)\r
2925                                                                         {\r
2926                                                                         case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
2927                                                                                 /** @req DEM077 */\r
2928                                                                                 deleteEventPriMem(eventParam);\r
2929                                                                                 deleteFreezeFrameDataPriMem(eventParam);\r
2930                                                                                 deleteExtendedDataPriMem(eventParam);\r
2931                                                                                 resetEventStatusRec(eventParam);\r
2932                                                                                 storeFreezeFrameDataPerMem();\r
2933                                                                                 break;\r
2934                                                                                 \r
2935                                                                         case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
2936                                                                                 \r
2937                                                                                 break;\r
2938                                                                                 \r
2939                                                                         case DEM_DTC_ORIGIN_SECONDARY_MEMORY:                                                                   \r
2940                                                                         case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
2941                                                                                 // Not yet supported\r
2942                                                                                 returnCode = DEM_CLEAR_WRONG_DTCORIGIN;\r
2943                                                                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_CLEARDTC_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
2944                                                                                 break;\r
2945                                                                         default:\r
2946                                                                                 returnCode = DEM_CLEAR_WRONG_DTCORIGIN;\r
2947                                                                                 break;\r
2948                                                                         }\r
2949                                                                 }\r
2950                                                         }\r
2951                                                 }\r
2952                                         }\r
2953                                 }\r
2954                                 else {\r
2955                                         // Fatal error, no event parameters found for the stored event!\r
2956                                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_CLEARDTC_ID, DEM_E_UNEXPECTED_EXECUTION);\r
2957                                 }\r
2958                         }\r
2959                 }\r
2960         } else {\r
2961                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_CLEARDTC_ID, DEM_E_UNINIT);\r
2962                 returnCode = DEM_CLEAR_FAILED;\r
2963         }\r
2964 \r
2965         return returnCode;\r
2966 }\r
2967 \r
2968 \r
2969 /*\r
2970  * Procedure:   Dem_DisableDTCStorage\r
2971  * Reentrant:   No\r
2972  */\r
2973 Dem_ReturnControlDTCStorageType Dem_DisableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind) /** @req DEM035 */\r
2974 {\r
2975         Dem_ReturnControlDTCStorageType returnCode = DEM_CONTROL_DTC_STORAGE_OK;\r
2976 \r
2977         if (demState == DEM_INITIALIZED) {\r
2978                 // Check dtcGroup parameter\r
2979                 if (dtcGroup == DEM_DTC_GROUP_ALL_DTCS) {\r
2980                         // Check dtcKind parameter\r
2981                         if ((dtcKind == DEM_DTC_KIND_ALL_DTCS) || (dtcKind ==  DEM_DTC_KIND_EMISSION_REL_DTCS)) {\r
2982                                 /** @req DEM079 */\r
2983                                 disableDtcStorage.dtcGroup = dtcGroup;\r
2984                                 disableDtcStorage.dtcKind = dtcKind;\r
2985                                 disableDtcStorage.storageDisabled = TRUE;\r
2986                         } else {\r
2987                                 returnCode = DEM_CONTROL_DTC_STORAGE_N_OK;\r
2988                         }\r
2989                 } else {\r
2990                         returnCode = DEM_CONTROL_DTC_WRONG_DTCGROUP;\r
2991                 }\r
2992         } else {\r
2993                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_DISABLEDTCSTORAGE_ID, DEM_E_UNINIT);\r
2994                 returnCode = DEM_CONTROL_DTC_STORAGE_N_OK;\r
2995         }\r
2996 \r
2997         return returnCode;\r
2998 }\r
2999 \r
3000 \r
3001 /*\r
3002  * Procedure:   Dem_EnableDTCStorage\r
3003  * Reentrant:   No\r
3004  */\r
3005 Dem_ReturnControlDTCStorageType Dem_EnableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind)\r
3006 {\r
3007         Dem_ReturnControlDTCStorageType returnCode = DEM_CONTROL_DTC_STORAGE_OK;\r
3008 \r
3009         if (demState == DEM_INITIALIZED) {\r
3010                 // TODO: Behavior is not defined if group or kind do not match active settings, therefore the filter is just switched off.\r
3011                 (void)dtcGroup; (void)dtcKind;  // Just to make get rid of PC-Lint warnings\r
3012                 disableDtcStorage.storageDisabled = FALSE; /** @req DEM080 */\r
3013         } else {\r
3014                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_ENABLEDTCSTORAGE_ID, DEM_E_UNINIT);\r
3015                 returnCode = DEM_CONTROL_DTC_STORAGE_N_OK;\r
3016         }\r
3017 \r
3018         return returnCode;\r
3019 }\r
3020 \r
3021 /*\r
3022  * Procedure:   Dem_GetExtendedDataRecordByDTC\r
3023  * Reentrant:   No\r
3024  */\r
3025 Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint16 *bufSize)\r
3026 {\r
3027         Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_RECORD_WRONG_DTC;\r
3028         EventStatusRecType *eventRec;\r
3029         Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
3030         ExtDataRecType *extData;\r
3031         uint16 posInExtData = 0;\r
3032 \r
3033         if (demState == DEM_INITIALIZED) {\r
3034                 if (lookupDtcEvent(dtc, &eventRec)) {\r
3035                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
3036                                 if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
3037                                         if (lookupExtendedDataRecNumParam(extendedDataNumber, eventRec->eventParamRef, &extendedDataRecordClass, &posInExtData)) {\r
3038                                                 if (*bufSize >= extendedDataRecordClass->DataSize) {\r
3039                                                         switch (dtcOrigin)\r
3040                                                         {\r
3041                                                         case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
3042                                                                 if (lookupExtendedDataPriMem(eventRec->eventId, &extData)) {\r
3043                                                                         // Yes all conditions met, copy the extended data record to destination buffer.\r
3044                                                                         memcpy(destBuffer, &extData->data[posInExtData], extendedDataRecordClass->DataSize); /** @req DEM075 */\r
3045                                                                         *bufSize = extendedDataRecordClass->DataSize;\r
3046                                                                         returnCode = DEM_RECORD_OK;\r
3047                                                                 }\r
3048                                                                 else {\r
3049                                                                         // The record number is legal but no record was found for the DTC\r
3050                                                                         *bufSize = 0;\r
3051                                                                         returnCode = DEM_RECORD_OK;\r
3052                                                                 }\r
3053                                                                 break;\r
3054 \r
3055                                                         case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
3056                                                         case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
3057                                                         case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
3058                                                                 // Not yet supported\r
3059                                                                 returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
3060                                                                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETEXTENDEDDATARECORDBYDTC_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
3061                                                                 break;\r
3062                                                         default:\r
3063                                                                 returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
3064                                                                 break;\r
3065                                                         }\r
3066                                                 }\r
3067                                                 else {\r
3068                                                         returnCode = DEM_RECORD_BUFFERSIZE;\r
3069                                                 }\r
3070                                         }\r
3071                                         else {\r
3072                                                 returnCode = DEM_RECORD_NUMBER;\r
3073                                         }\r
3074                                 }\r
3075                                 else {\r
3076                                         returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
3077                                 }\r
3078                         }\r
3079                         else {\r
3080                                 returnCode = DEM_RECORD_DTCKIND;\r
3081                         }\r
3082                 }\r
3083         } else {\r
3084                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETEXTENDEDDATARECORDBYDTC_ID, DEM_E_UNINIT);\r
3085                 returnCode = DEM_RECORD_WRONG_DTC;\r
3086         }\r
3087 \r
3088         return returnCode;\r
3089 }\r
3090 \r
3091 \r
3092 /*\r
3093  * Procedure:   Dem_GetSizeOfExtendedDataRecordByDTC\r
3094  * Reentrant:   No\r
3095  */\r
3096 Dem_ReturnGetSizeOfExtendedDataRecordByDTCType Dem_GetSizeOfExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint16 *sizeOfExtendedDataRecord)\r
3097 {\r
3098         Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTC;\r
3099         EventStatusRecType *eventRec;\r
3100         Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
3101         uint16 posInExtData;\r
3102 \r
3103         if (demState == DEM_INITIALIZED) {\r
3104                 if (lookupDtcEvent(dtc, &eventRec)) {\r
3105                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
3106                                 if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
3107                                         if (lookupExtendedDataRecNumParam(extendedDataNumber, eventRec->eventParamRef, &extendedDataRecordClass, &posInExtData)) {\r
3108                                                 *sizeOfExtendedDataRecord = extendedDataRecordClass->DataSize; /** @req DEM076 */\r
3109                                                 returnCode = DEM_GET_SIZEOFEDRBYDTC_OK;\r
3110                                         }\r
3111                                         else {\r
3112                                                 returnCode = DEM_GET_SIZEOFEDRBYDTC_W_RNUM;\r
3113                                         }\r
3114                                 }\r
3115                                 else {\r
3116                                         returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTCOR;\r
3117                                 }\r
3118                         }\r
3119                         else {\r
3120                                 returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTCKI;\r
3121                         }\r
3122                 }\r
3123         } else {\r
3124                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETSIZEOFEXTENDEDDATARECORDBYDTC_ID, DEM_E_UNINIT);\r
3125                 returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTC;\r
3126         }\r
3127 \r
3128         return returnCode;\r
3129 }\r
3130 \r
3131 /*\r
3132  * Procedure:   Dem_GetFreezeFrameDataByDTC\r
3133  * Reentrant:   No\r
3134  */\r
3135 /** @req DEM236 */ \r
3136 Dem_ReturnGetFreezeFrameDataByDTCType Dem_GetFreezeFrameDataByDTC(uint32  dtc,Dem_DTCKindType  dtcKind,Dem_DTCOriginType  dtcOrigin,uint8  recordNumber,uint8*  destBuffer,uint8*  bufSize)\r
3137 {\r
3138         Dem_ReturnGetFreezeFrameDataByDTCType returnCode = DEM_GET_FFDATABYDTC_WRONG_DTC;\r
3139         EventStatusRecType *eventRec;\r
3140         Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
3141         FreezeFrameRecType *freezeframe;\r
3142         uint16 FFDataSize = 0;\r
3143 \r
3144         if (demState == DEM_INITIALIZED) {\r
3145                 if (lookupDtcEvent(dtc, &eventRec)) {\r
3146                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
3147                                 if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
3148                                         if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
3149                                                 if(lookupFreezeFrameDataSize(recordNumber, &FFDataRecordClass, &FFDataSize)){\r
3150                                                         if (*bufSize >= FFDataSize) {\r
3151                                                                 switch (dtcOrigin)\r
3152                                                                 {\r
3153                                                                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
3154                                                                         if (lookupFreezeFrameDataPriMem(eventRec->eventId,recordNumber, &freezeframe)) {\r
3155                                                                                 memcpy(destBuffer, freezeframe->data, FFDataSize); /** @req DEM071 */\r
3156                                                                                 *bufSize = FFDataSize;\r
3157                                                                                 returnCode = DEM_GET_FFDATABYDTC_OK;\r
3158                                                                         }\r
3159                                                                         else {\r
3160                                                                                 *bufSize = 0;\r
3161                                                                                 returnCode = DEM_GET_FFDATABYDTC_OK;\r
3162                                                                         }\r
3163                                                                         break;\r
3164 \r
3165                                                                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
3166                                                                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
3167                                                                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
3168                                                                         // Not yet supported\r
3169                                                                         returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
3170                                                                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATARECORDBYDTC_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
3171                                                                         break;\r
3172                                                                 default:\r
3173                                                                         returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
3174                                                                         break;\r
3175                                                                 }\r
3176                                                         }\r
3177                                                         else{\r
3178                                                                 returnCode = DEM_GET_FFDATABYDTC_BUFFERSIZE;\r
3179                                                         }\r
3180                                                 }\r
3181                                                 else {\r
3182                                                         returnCode = DEM_GET_FFDATABYDTC_BUFFERSIZE;\r
3183                                                 }\r
3184                                         }\r
3185                                         else {\r
3186                                                 returnCode = DEM_GET_FFDATABYDTC_RECORDNUMBER;\r
3187                                         }\r
3188                                 }\r
3189                                 else {\r
3190                                         returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
3191                                 }\r
3192                         }\r
3193                         else {\r
3194                                 returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCKIND;\r
3195                         }\r
3196                 }\r
3197                 else{\r
3198                         returnCode = DEM_GET_FFDATABYDTC_WRONG_DTC;\r
3199 \r
3200                 }\r
3201         } else {\r
3202                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATARECORDBYDTC_ID, DEM_E_UNINIT);\r
3203                 returnCode = DEM_GET_ID_PENDING;\r
3204         }\r
3205 \r
3206         return returnCode;\r
3207 \r
3208 \r
3209 }\r
3210 \r
3211 /*\r
3212  * Procedure:   Dem_GetFreezeFrameDataIdentifierByDTC\r
3213  * Reentrant:   No\r
3214  */\r
3215 Dem_GetFreezeFameDataIdentifierByDTCType Dem_GetFreezeFrameDataIdentifierByDTC(uint32  dtc,\r
3216                                                                                                                                                                                 Dem_DTCKindType  dtcKind,\r
3217                                                                                                                                                                                 Dem_DTCOriginType  dtcOrigin,\r
3218                                                                                                                                                                                 uint8  recordNumber,\r
3219                                                                                                                                                                                 uint8*  arraySize,\r
3220                                                                                                                                                                                 const  uint16** dataId )/** @req DEM237 */\r
3221 {\r
3222         Dem_GetFreezeFameDataIdentifierByDTCType returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
3223         Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
3224         EventStatusRecType *eventRec;\r
3225         uint8 didNum = 0;\r
3226         uint16 i = 0;\r
3227         if (demState == DEM_INITIALIZED) {\r
3228                 if (lookupDtcEvent(dtc, &eventRec)) {\r
3229                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
3230                                 if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
3231                                         if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
3232                                                 if(FFDataRecordClass->FFIdClassRef != NULL){\r
3233                                                         for(i=0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FFDataRecordClass->FFIdClassRef[i].Arc_EOL)); i++){\r
3234                                                                 if(didNum < *arraySize){\r
3235                                                                         dataId[didNum] = &FFDataRecordClass->FFIdClassRef[i].DidIdentifier;/** @req DEM073 */\r
3236                                                                         didNum++;\r
3237                                                                         returnCode = DEM_GET_ID_OK;\r
3238                                                                 }else{\r
3239                                                                         returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
3240                                                                 }\r
3241                                                         }\r
3242                                                         *arraySize = didNum;\r
3243                                                 }\r
3244                                                 \r
3245                                         }\r
3246                                         else{\r
3247                                                 returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
3248                                         }\r
3249                                 }\r
3250                                 else{\r
3251                                         returnCode = DEM_GET_ID_WRONG_DTCORIGIN;\r
3252                                 }\r
3253                         }\r
3254                         else{\r
3255                                 returnCode = DEM_GET_ID_WRONG_DTCKIND;\r
3256                         }\r
3257                 }\r
3258                 else{\r
3259                         returnCode = DEM_GET_ID_WRONG_DTC;\r
3260                 }\r
3261                 \r
3262         } \r
3263         else{\r
3264                 DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATAIDENTIFIERBYDTC_ID, DEM_E_UNINIT);\r
3265         }\r
3266 \r
3267         return returnCode;\r
3268 \r
3269 }\r
3270 \r
3271 /*\r
3272  * Procedure:   Dem_GetSizeOfFreezeFrame\r
3273  * Reentrant:   No\r
3274  */\r
3275  /** @req DEM238 */\r
3276 Dem_ReturnGetSizeOfFreezeFrameType Dem_GetSizeOfFreezeFrame(uint32  dtc,Dem_DTCKindType  dtcKind,Dem_DTCOriginType  dtcOrigin,uint8  recordNumber,uint16*  sizeOfFreezeFrame)  \r
3277 {\r
3278         Dem_ReturnGetSizeOfFreezeFrameType returnCode = DEM_GET_SIZEOFFF_PENDING;\r
3279         Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
3280         Std_ReturnType callbackReturnCode;\r
3281         EventStatusRecType *eventRec;\r
3282         uint16 dataSize = 0;\r
3283         uint16 i = 0;\r
3284         \r
3285         if (demState == DEM_INITIALIZED) {\r
3286                 if (lookupDtcEvent(dtc, &eventRec)) {\r
3287                         if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
3288                                 if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
3289                                         if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
3290                                                 if(FFDataRecordClass->FFIdClassRef != NULL){\r
3291                                                         for(i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FFDataRecordClass->FFIdClassRef[i].Arc_EOL)); i++){\r
3292                                                                 /* read out the did size */\r
3293                                                                 if(FFDataRecordClass->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
3294                                                                         callbackReturnCode = FFDataRecordClass->FFIdClassRef[i].DidReadDataLengthFnc(&dataSize);\r
3295                                                                         if(callbackReturnCode != E_OK){\r
3296                                                                                 return (returnCode = DEM_GET_SIZEOFFF_PENDING);\r
3297                                                                         }\r
3298                                                                 }\r
3299                                                                 else{\r
3300                                                                         dataSize = FFDataRecordClass->FFIdClassRef[i].PidOrDidSize;\r
3301                                                                 }\r
3302                                                                 *sizeOfFreezeFrame += dataSize+DEM_DID_IDENTIFIER_SIZE_OF_BYTES;/** @req DEM074 */\r
3303                                                                 returnCode = DEM_GET_SIZEOFFF_OK;               \r
3304                                                         }                               \r
3305                                                 }\r
3306                                         }\r
3307                                         else{\r
3308                                                 returnCode = DEM_GET_SIZEOFFF_WRONG_RNUM;\r
3309                                         }\r
3310                                 }\r
3311                                 else{\r
3312                                         returnCode = DEM_GET_SIZEOFFF_WRONG_DTCOR;\r
3313                                 }\r
3314                         }\r
3315                         else{\r
3316                                 returnCode = DEM_GET_SIZEOFFF_WRONG_DTCKIND;\r
3317                         }\r
3318                 }\r
3319                 else{\r
3320                         returnCode = DEM_GET_SIZEOFFF_WRONG_DTC;\r
3321                 }\r
3322                 \r
3323         } \r
3324         else{\r
3325                         DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATAIDENTIFIERBYDTC_ID, DEM_E_UNINIT);\r
3326                         returnCode = DEM_GET_SIZEOFFF_PENDING;\r
3327                 }\r
3328 \r
3329         return returnCode;\r
3330 \r
3331 \r
3332 }\r
3333 \r
3334 \r
3335 #ifdef DEM_UNIT_TEST\r
3336 void getFFDataPreInit(FreezeFrameRecType **buf)\r
3337 {\r
3338         *buf = &preInitFreezeFrameBuffer[0];\r
3339         return;\r
3340 }\r
3341 void getPriMemFFBufPtr(FreezeFrameRecType **buf)\r
3342 {\r
3343         *buf = &priMemFreezeFrameBuffer[0];\r
3344         return;\r
3345 }\r
3346 \r
3347 uint32 getCurTimeStamp()\r
3348 {\r
3349         return FF_TimeStamp;\r
3350 }\r
3351 \r
3352 void getPriMemEventRecBufPtr(EventStatusRecType **buf)\r
3353 {\r
3354         *buf = &eventStatusBuffer[0];\r
3355         return;\r
3356 }\r
3357 \r
3358 void getPriMemAgingBufPtr(HealingRecType **buf)\r
3359 {\r
3360         *buf = &priMemAgingBuffer[0];\r
3361         return;\r
3362 }\r
3363 #endif\r
3364 \r
3365 \r
3366 \r
3367 \r
3368 \r
3369 /***********************************\r
3370  * OBD-specific Interfaces (8.3.6) *\r
3371  ***********************************/\r
3372 \r
3373 \r
3374 \r