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