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