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