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 \r
  17 \r
  18 \r
  19 \r
  20 /*\r
  21  *  General requirements\r
  22  */\r
  23 /** @req DEM126 */\r
  24 /** @req DEM151.partially */\r
  25 /** @req DEM152 */\r
  26 /** @req DEM013.14229-1 */\r
  27 /** @req DEM277 */\r
  28 /** @req DEM363 */\r
  29 /** @req DEM113 */ /** @req DEM174 */\r
  30 /** @req DEM286 */\r
  31 /** @req DEM267 */\r
  32 \r
  33 \r
  34 #include <string.h>\r
  35 #include "Dem.h"\r
  36 #include "Det.h"\r
  37 //#include "Fim.h"\r
  38 //#include "Nvm.h"\r
  39 //#include "SchM_Dem.h"\r
  40 #include "MemMap.h"\r
  41 #include "McuExtensions.h"\r
  42 \r
  43 /*\r
  44  * Local defines\r
  45  */\r
  46 #define DEBOUNCE_FDC_TEST_FAILED  127\r
  47 #define DEBOUNCE_FDC_TEST_PASSED -128\r
  48 \r
  49 /*\r
  50  * Local types\r
  51  */\r
  52 \r
  53 typedef uint16 ChecksumType;\r
  54 \r
  55 // DtcFilterType\r
  56 typedef struct {\r
  57         Dem_EventStatusExtendedType dtcStatusMask;\r
  58         Dem_DTCKindType                         dtcKind;\r
  59         Dem_DTCOriginType                       dtcOrigin;\r
  60         Dem_FilterWithSeverityType      filterWithSeverity;\r
  61         Dem_DTCSeverityType                     dtcSeverityMask;\r
  62         Dem_FilterForFDCType            filterForFaultDetectionCounter;\r
  63         uint16                                          faultIndex;\r
  64 } DtcFilterType;\r
  65 \r
  66 // DisableDtcStorageType\r
  67 typedef struct {\r
  68         boolean                                         storageDisabled;\r
  69         Dem_DTCGroupType                        dtcGroup;\r
  70         Dem_DTCKindType                         dtcKind;\r
  71 } DisableDtcStorageType;\r
  72 \r
  73 // For keeping track of the events status\r
  74 typedef struct {\r
  75         Dem_EventIdType                         eventId;\r
  76         const Dem_EventParameterType *eventParamRef;\r
  77         sint8                                           faultDetectionCounter;\r
  78         uint16                                          occurrence;                             /** @req DEM011 */\r
  79         Dem_EventStatusExtendedType     eventStatusExtended;    /** @req DEM006 */\r
  80         boolean                                         errorStatusChanged;\r
  81 } EventStatusRecType;\r
  82 \r
  83 \r
  84 // Types for storing different event data on event memory\r
  85 typedef struct {\r
  86         Dem_EventIdType         eventId;\r
  87         uint16                          occurrence;\r
  88         ChecksumType            checksum;\r
  89 } EventRecType;\r
  90 \r
  91 typedef struct {\r
  92         Dem_EventIdType         eventId;\r
  93         uint16                          occurrence;\r
  94         uint16                          dataSize;\r
  95         sint8                           data[DEM_MAX_SIZE_FF_DATA];\r
  96         ChecksumType            checksum;\r
  97 } FreezeFrameRecType;\r
  98 \r
  99 typedef struct {\r
 100         Dem_EventIdType         eventId;\r
 101         uint16                          dataSize;\r
 102         uint8                           data[DEM_MAX_SIZE_EXT_DATA];\r
 103         ChecksumType            checksum;\r
 104 } ExtDataRecType;\r
 105 \r
 106 \r
 107 // State variable\r
 108 typedef enum\r
 109 {\r
 110   DEM_UNINITIALIZED = 0,\r
 111   DEM_PREINITIALIZED,\r
 112   DEM_INITIALIZED\r
 113 } Dem_StateType; /** @req DEM169 */\r
 114 \r
 115 \r
 116 static Dem_StateType demState = DEM_UNINITIALIZED;\r
 117 \r
 118 // Help pointer to configuration set\r
 119 static const Dem_ConfigSetType *configSet;\r
 120 \r
 121 /*\r
 122  * Allocation of DTC filter parameters\r
 123  */\r
 124 static DtcFilterType dtcFilter;\r
 125 \r
 126 /*\r
 127  * Allocation of Disable/Enable DTC storage parameters\r
 128  */\r
 129 static DisableDtcStorageType disableDtcStorage;\r
 130 \r
 131 /*\r
 132  * Allocation of operation cycle state list\r
 133  */\r
 134 static Dem_OperationCycleStateType operationCycleStateList[DEM_OPERATION_CYCLE_ID_ENDMARK];\r
 135 \r
 136 /*\r
 137  * Allocation of local event status buffer\r
 138  */\r
 139 static EventStatusRecType       eventStatusBuffer[DEM_MAX_NUMBER_EVENT];\r
 140 \r
 141 /*\r
 142  * Allocation of pre-init event memory (used between pre-init and init)\r
 143  */\r
 144 /** @req DEM207 */\r
 145 static FreezeFrameRecType       preInitFreezeFrameBuffer[DEM_MAX_NUMBER_FF_DATA_PRE_INIT];\r
 146 static ExtDataRecType           preInitExtDataBuffer[DEM_MAX_NUMBER_EXT_DATA_PRE_INIT];\r
 147 \r
 148 /*\r
 149  * Allocation of primary event memory ramlog (after init) in uninitialized memory\r
 150  */\r
 151 /** @req DEM162 */\r
 152 static EventRecType             priMemEventBuffer[DEM_MAX_NUMBER_EVENT_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 153 static FreezeFrameRecType       priMemFreezeFrameBuffer[DEM_MAX_NUMBER_FF_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 154 static ExtDataRecType           priMemExtDataBuffer[DEM_MAX_NUMBER_EXT_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
 155 \r
 156 \r
 157 /*\r
 158  * Procedure:   zeroPriMemBuffers\r
 159  * Description: Fill the primary buffers with zeroes\r
 160  */\r
 161 void demZeroPriMemBuffers(void)\r
 162 {\r
 163         memset(priMemEventBuffer, 0, sizeof(priMemEventBuffer));\r
 164         memset(priMemFreezeFrameBuffer, 0, sizeof(priMemFreezeFrameBuffer));\r
 165         memset(priMemExtDataBuffer, 0, sizeof(priMemExtDataBuffer));\r
 166 }\r
 167 \r
 168 \r
 169 /*\r
 170  * Procedure:   calcChecksum\r
 171  * Description: Calculate checksum over *data to *(data+nrOfBytes-1) area\r
 172  */\r
 173 static ChecksumType calcChecksum(void *data, uint16 nrOfBytes)\r
 174 {\r
 175         uint16 i;\r
 176         uint8 *ptr = (uint8*)data;\r
 177         ChecksumType sum = 0;\r
 178 \r
 179         for (i = 0; i < nrOfBytes; i++)\r
 180                 sum += *ptr++;\r
 181         sum ^= 0xaaaa;\r
 182         return sum;\r
 183 }\r
 184 \r
 185 \r
 186 /*\r
 187  * Procedure:   checkDtcKind\r
 188  * Description: Return TRUE if "dtcKind" match the events DTCKind or "dtcKind"\r
 189  *                              is "DEM_DTC_KIND_ALL_DTCS" otherwise FALSE.\r
 190  */\r
 191 static boolean checkDtcKind(Dem_DTCKindType dtcKind, const Dem_EventParameterType *eventParam)\r
 192 {\r
 193         boolean result = FALSE;\r
 194 \r
 195         if (dtcKind == DEM_DTC_KIND_ALL_DTCS) {\r
 196                 result = TRUE;\r
 197         }\r
 198         else {\r
 199                 if (eventParam->DTCClassRef != NULL) {\r
 200                         if (eventParam->DTCClassRef->DTCKind == dtcKind) {\r
 201                                 result = TRUE;\r
 202                         }\r
 203                 }\r
 204         }\r
 205         return result;\r
 206 }\r
 207 \r
 208 \r
 209 /*\r
 210  * Procedure:   checkDtcGroup\r
 211  * Description: Return TRUE if "dtc" match the events DTC or "dtc" is\r
 212  *                              "DEM_DTC_GROUP_ALL_DTCS" otherwise FALSE.\r
 213  */\r
 214 static boolean checkDtcGroup(uint32 dtc, const Dem_EventParameterType *eventParam)\r
 215 {\r
 216         boolean result = FALSE;\r
 217 \r
 218         if (dtc == DEM_DTC_GROUP_ALL_DTCS) {\r
 219                 result = TRUE;\r
 220         }\r
 221         else {\r
 222                 if (eventParam->DTCClassRef != NULL) {\r
 223                         if (eventParam->DTCClassRef->DTC == dtc) {\r
 224                                 result = TRUE;\r
 225                         }\r
 226                 }\r
 227         }\r
 228         return result;\r
 229 }\r
 230 \r
 231 \r
 232 /*\r
 233  * Procedure:   checkDtcOrigin\r
 234  * Description: Return TRUE if "dtcOrigin" match any of the events DTCOrigin otherwise FALSE.\r
 235  */\r
 236 static boolean checkDtcOrigin(Dem_DTCOriginType dtcOrigin, const Dem_EventParameterType *eventParam)\r
 237 {\r
 238         boolean result = FALSE;\r
 239         uint16 i;\r
 240 \r
 241         for (i = 0; (eventParam->EventClass->EventDestination[i] != dtcOrigin) && (i < DEM_MAX_NR_OF_EVENT_DESTINATION); i++);\r
 242 \r
 243         if (i < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
 244                 result = TRUE;\r
 245         }\r
 246 \r
 247         return result;\r
 248 }\r
 249 \r
 250 \r
 251 /*\r
 252  * Procedure:   checkDtcSeverityMask\r
 253  * Description: Return TRUE if "dtcSeverityMask" match any of the events DTC severity otherwise FALSE.\r
 254  */\r
 255 static boolean checkDtcSeverityMask(Dem_DTCSeverityType dtcSeverityMask, const Dem_EventParameterType *eventParam)\r
 256 {\r
 257         boolean result = TRUE;\r
 258 \r
 259         // TODO: This function is optional, may be implemented here.\r
 260 \r
 261         return result;\r
 262 }\r
 263 \r
 264 \r
 265 /*\r
 266  * Procedure:   checkDtcFaultDetectionCounterMask\r
 267  * Description: TBD.\r
 268  */\r
 269 static boolean checkDtcFaultDetectionCounter(const Dem_EventParameterType *eventParam)\r
 270 {\r
 271         boolean result = TRUE;\r
 272 \r
 273         // TODO: Not implemented yet.\r
 274 \r
 275         return result;\r
 276 }\r
 277 \r
 278 \r
 279 /*\r
 280  * Procedure:   lookupEventStatusRec\r
 281  * Description: Returns the pointer to event id parameters of "eventId" in "*eventStatusBuffer",\r
 282  *                              if not found NULL is returned.\r
 283  */\r
 284 static void lookupEventStatusRec(Dem_EventIdType eventId, EventStatusRecType **const eventStatusRec)\r
 285 {\r
 286         EventStatusRecType *eventStatusRecPtr = eventStatusBuffer;\r
 287 \r
 288         while ((eventStatusRecPtr->eventId != eventId) && (eventStatusRecPtr < &eventStatusBuffer[DEM_MAX_NUMBER_EVENT])) {\r
 289                 eventStatusRecPtr++;\r
 290         }\r
 291 \r
 292         if (eventStatusRecPtr < &eventStatusBuffer[DEM_MAX_NUMBER_EVENT]) {\r
 293                 *eventStatusRec = eventStatusRecPtr;\r
 294         } else {\r
 295                 *eventStatusRec = NULL;\r
 296         }\r
 297 }\r
 298 \r
 299 \r
 300 /*\r
 301  * Procedure:   lookupEventIdParameter\r
 302  * Description: Returns the pointer to event id parameters of "eventId" in "*eventIdParam",\r
 303  *                              if not found NULL is returned.\r
 304  */\r
 305 static void lookupEventIdParameter(Dem_EventIdType eventId, const Dem_EventParameterType **const eventIdParam)\r
 306 {\r
 307         const Dem_EventParameterType *EventIdParamPtr = configSet->EventParameter;\r
 308 \r
 309         // Lookup the correct event id parameters\r
 310         while ((EventIdParamPtr->EventID != eventId) && !EventIdParamPtr->Arc_EOL) {\r
 311                 EventIdParamPtr++;\r
 312         }\r
 313 \r
 314         if (!EventIdParamPtr->Arc_EOL) {\r
 315                 *eventIdParam = EventIdParamPtr;\r
 316         } else {\r
 317                 *eventIdParam = NULL;\r
 318         }\r
 319 }\r
 320 \r
 321 \r
 322 /*\r
 323  * Procedure:   preDebounceNone\r
 324  * Description: Returns the result of the debouncing.\r
 325  */\r
 326 static Dem_EventStatusType preDebounceNone(Dem_EventStatusType reportedStatus, EventStatusRecType* statusRecord) {\r
 327         Dem_EventStatusType returnCode;\r
 328 \r
 329         switch (reportedStatus) {\r
 330         case DEM_EVENT_STATUS_FAILED: /** @req DEM091.NoneFailed */\r
 331         case DEM_EVENT_STATUS_PASSED: /** @req DEM091.NonePassed */\r
 332                 // Already debounced, do nothing.\r
 333                 break;\r
 334 \r
 335         default:\r
 336                 // TODO: What to do with PREFAIL and PREPASSED on no debouncing?\r
 337 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 338                         Det_ReportError(MODULE_ID_DEM, 0, DEM_PREDEBOUNCE_NONE_ID, DEM_E_PARAM_DATA); /** @req DEM117 */\r
 339 #endif\r
 340                 break;\r
 341         }\r
 342 \r
 343         returnCode = reportedStatus;\r
 344         return returnCode;\r
 345 }\r
 346 \r
 347 \r
 348 /*\r
 349  * Procedure:   preDebounceCounterBased\r
 350  * Description: Returns the result of the debouncing.\r
 351  */\r
 352 static Dem_EventStatusType preDebounceCounterBased(Dem_EventStatusType reportedStatus, EventStatusRecType* statusRecord) {\r
 353         Dem_EventStatusType returnCode;\r
 354         const Dem_PreDebounceCounterBasedType* pdVars = statusRecord->eventParamRef->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceCounterBased;\r
 355 \r
 356         switch (reportedStatus) {\r
 357         case DEM_EVENT_STATUS_PREFAILED:\r
 358                 if (statusRecord->faultDetectionCounter < DEBOUNCE_FDC_TEST_FAILED) {\r
 359                         if (pdVars->JumpUp && (statusRecord->faultDetectionCounter < 0)) {\r
 360                                 statusRecord->faultDetectionCounter = 0;\r
 361                         } else {\r
 362                                 if (((sint16)statusRecord->faultDetectionCounter + pdVars->CountInStepSize) < DEBOUNCE_FDC_TEST_FAILED) {\r
 363                                         statusRecord->faultDetectionCounter += pdVars->CountInStepSize;\r
 364                                 } else {\r
 365                                         statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_FAILED;\r
 366                                 }\r
 367                         }\r
 368                 }\r
 369                 break;\r
 370 \r
 371         case DEM_EVENT_STATUS_PREPASSED:\r
 372                 if (statusRecord->faultDetectionCounter > DEBOUNCE_FDC_TEST_PASSED) {\r
 373                         if (pdVars->JumpDown && (statusRecord->faultDetectionCounter > 0)) {\r
 374                                 statusRecord->faultDetectionCounter = 0;\r
 375                         } else {\r
 376                                 if (((sint16)statusRecord->faultDetectionCounter - pdVars->CountOutStepSize) > DEBOUNCE_FDC_TEST_PASSED) {\r
 377                                         statusRecord->faultDetectionCounter -= pdVars->CountOutStepSize;\r
 378                                 } else {\r
 379                                         statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_PASSED;\r
 380                                 }\r
 381                         }\r
 382                 }\r
 383                 break;\r
 384 \r
 385         case DEM_EVENT_STATUS_FAILED:\r
 386                 statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_FAILED; /** @req DEM091.CounterFailed */\r
 387                 break;\r
 388 \r
 389         case DEM_EVENT_STATUS_PASSED:\r
 390                 statusRecord->faultDetectionCounter = DEBOUNCE_FDC_TEST_PASSED; /** @req DEM091.CounterPassed */\r
 391                 break;\r
 392 \r
 393         default:\r
 394 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 395                 Det_ReportError(MODULE_ID_DEM, 0, DEM_PREDEBOUNCE_COUNTER_BASED_ID, DEM_E_PARAM_DATA); /** @req DEM117 */\r
 396 #endif\r
 397                 break;\r
 398 \r
 399         }\r
 400 \r
 401         switch (statusRecord->faultDetectionCounter) {\r
 402         case DEBOUNCE_FDC_TEST_FAILED:\r
 403                 returnCode = DEM_EVENT_STATUS_FAILED;\r
 404                 break;\r
 405 \r
 406         case DEBOUNCE_FDC_TEST_PASSED:\r
 407                 returnCode = DEM_EVENT_STATUS_PASSED;\r
 408                 break;\r
 409 \r
 410         default:\r
 411                 returnCode = reportedStatus;\r
 412                 break;\r
 413         }\r
 414 \r
 415         return returnCode;\r
 416 }\r
 417 \r
 418 \r
 419 /*\r
 420  * Procedure:   updateEventStatusRec\r
 421  * Description: Update the status of "eventId", if not exist and "createIfNotExist" is\r
 422  *                              true a new record is created\r
 423  */\r
 424 static void updateEventStatusRec(const Dem_EventParameterType *eventParam, Dem_EventStatusType eventStatus, boolean createIfNotExist, EventStatusRecType *eventStatusRec)\r
 425 {\r
 426         EventStatusRecType *eventStatusRecPtr;\r
 427         imask_t state = McuE_EnterCriticalSection();\r
 428 \r
 429         // Lookup event ID\r
 430         lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
 431 \r
 432         if ((eventStatusRecPtr == NULL) && (createIfNotExist)) {\r
 433                 // Search for free position\r
 434                 lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
 435 \r
 436                 if (eventStatusRecPtr != NULL) {\r
 437                         // Create new event record\r
 438                         eventStatusRecPtr->eventId = eventParam->EventID;\r
 439                         eventStatusRecPtr->eventParamRef = eventParam;\r
 440                         eventStatusRecPtr->faultDetectionCounter = 0;\r
 441                         eventStatusRecPtr->occurrence = 0;\r
 442                         eventStatusRecPtr->eventStatusExtended = DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE;\r
 443                         eventStatusRecPtr->errorStatusChanged = FALSE;\r
 444                 }\r
 445                 else {\r
 446                         // Error: Event status buffer full\r
 447 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 448                         Det_ReportError(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_EVENT_STATUS_BUFF_FULL); /** @req DEM117 */\r
 449 #endif\r
 450                 }\r
 451         }\r
 452 \r
 453 \r
 454         if (eventStatusRecPtr != NULL) {\r
 455                 // Handle debouncing\r
 456                 if (eventParam->EventClass->PreDebounceAlgorithmClass != NULL) {\r
 457                         switch (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceName) { /** @req DEM004 */ /** @req DEM342 */\r
 458                         case DEM_NO_PRE_DEBOUNCE:\r
 459                                 eventStatus = preDebounceNone(eventStatus, eventStatusRecPtr);\r
 460                                 break;\r
 461 \r
 462                         case DEM_PRE_DEBOUNCE_COUNTER_BASED:\r
 463                                 eventStatus = preDebounceCounterBased(eventStatus, eventStatusRecPtr);\r
 464                                 break;\r
 465 \r
 466                         default:\r
 467                                 // Don't know how to handle this.\r
 468         #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 469                                 Det_ReportError(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
 470         #endif\r
 471                                 break;\r
 472                         }\r
 473                 }\r
 474 \r
 475                 eventStatusRecPtr->errorStatusChanged = FALSE;\r
 476 \r
 477                 // Check test failed\r
 478                 if (eventStatus == DEM_EVENT_STATUS_FAILED) {\r
 479                         if (!(eventStatusRecPtr->eventStatusExtended & DEM_TEST_FAILED)) {\r
 480                                 eventStatusRecPtr->occurrence++;\r
 481                                 eventStatusRecPtr->errorStatusChanged = TRUE;\r
 482                         }\r
 483                         /** @req DEM036 */ /** @req DEM379.PendingSet */\r
 484                         eventStatusRecPtr->eventStatusExtended |= (DEM_TEST_FAILED | DEM_TEST_FAILED_THIS_OPERATION_CYCLE | DEM_TEST_FAILED_SINCE_LAST_CLEAR | DEM_PENDING_DTC);\r
 485                         eventStatusRecPtr->eventStatusExtended &= ~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
 486                 }\r
 487 \r
 488                 // Check test passed\r
 489                 if (eventStatus == DEM_EVENT_STATUS_PASSED) {\r
 490                         if (eventStatusRecPtr->eventStatusExtended & DEM_TEST_FAILED) {\r
 491                                 eventStatusRecPtr->errorStatusChanged = TRUE;\r
 492                         }\r
 493                         /** @req DEM036 */\r
 494                         eventStatusRecPtr->eventStatusExtended &= ~DEM_TEST_FAILED;\r
 495                         eventStatusRecPtr->eventStatusExtended &= ~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
 496                 }\r
 497 \r
 498                 // Copy the record\r
 499                 memcpy(eventStatusRec, eventStatusRecPtr, sizeof(EventStatusRecType));\r
 500         }\r
 501         else {\r
 502                 // Copy an empty record to return data\r
 503                 eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
 504                 eventStatusRecPtr->faultDetectionCounter = 0;\r
 505                 eventStatusRec->occurrence = 0;\r
 506                 eventStatusRec->eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
 507                 eventStatusRec->errorStatusChanged = FALSE;\r
 508         }\r
 509 \r
 510         McuE_ExitCriticalSection(state);\r
 511 }\r
 512 \r
 513 \r
 514 /*\r
 515  * Procedure:   mergeEventStatusRec\r
 516  * Description: Update the occurrence counter of status, if not exist a new record is created\r
 517  */\r
 518 static void mergeEventStatusRec(EventRecType *eventRec)\r
 519 {\r
 520         EventStatusRecType *eventStatusRecPtr;\r
 521         imask_t state = McuE_EnterCriticalSection();\r
 522 \r
 523         // Lookup event ID\r
 524         lookupEventStatusRec(eventRec->eventId, &eventStatusRecPtr);\r
 525 \r
 526         if (eventStatusRecPtr != NULL) {\r
 527                 // Update occurrence counter, rest of pre init state is kept.\r
 528                 eventStatusRecPtr->occurrence += eventRec->occurrence;\r
 529 \r
 530         }\r
 531         else {\r
 532                 // Search for free position\r
 533                 lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
 534 \r
 535                 if (eventStatusRecPtr != NULL) {\r
 536                         // Create new event, from stored event\r
 537                         eventStatusRecPtr->eventId = eventRec->eventId;\r
 538                         lookupEventIdParameter(eventRec->eventId, &eventStatusRecPtr->eventParamRef);\r
 539                         eventStatusRecPtr->faultDetectionCounter = 0;\r
 540                         eventStatusRecPtr->occurrence = eventRec->occurrence;\r
 541                         eventStatusRecPtr->eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
 542                         eventStatusRecPtr->errorStatusChanged = FALSE;\r
 543                 }\r
 544                 else {\r
 545                         // Error: Event status buffer full\r
 546 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 547                         Det_ReportError(MODULE_ID_DEM, 0, DEM_MERGE_EVENT_STATUS_ID, DEM_E_EVENT_STATUS_BUFF_FULL); /** @req DEM117 */\r
 548 #endif\r
 549                 }\r
 550         }\r
 551 \r
 552         McuE_ExitCriticalSection(state);\r
 553 }\r
 554 \r
 555 \r
 556 /*\r
 557  * Procedure:   deleteEventStatusRec\r
 558  * Description: Delete the status record of "eventParam->eventId" from "eventStatusBuffer".\r
 559  */\r
 560 static void deleteEventStatusRec(const Dem_EventParameterType *eventParam)\r
 561 {\r
 562         EventStatusRecType *eventStatusRecPtr;\r
 563         imask_t state = McuE_EnterCriticalSection();\r
 564 \r
 565         // Lookup event ID\r
 566         lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
 567 \r
 568         if (eventStatusRecPtr != NULL) {\r
 569                 // Delete event record\r
 570                 memset(eventStatusRecPtr, 0, sizeof(EventStatusRecType));\r
 571         }\r
 572 \r
 573         McuE_ExitCriticalSection(state);\r
 574 }\r
 575 \r
 576 \r
 577 /*\r
 578  * Procedure:   getEventStatusRec\r
 579  * Description: Returns the status record of "eventId" in "eventStatusRec"\r
 580  */\r
 581 static void getEventStatusRec(Dem_EventIdType eventId, EventStatusRecType *eventStatusRec)\r
 582 {\r
 583         EventStatusRecType *eventStatusRecPtr;\r
 584 \r
 585         // Lookup event ID\r
 586         lookupEventStatusRec(eventId, &eventStatusRecPtr);\r
 587 \r
 588         if (eventStatusRecPtr != NULL) {\r
 589                 // Copy the record\r
 590                 memcpy(eventStatusRec, eventStatusRecPtr, sizeof(EventStatusRecType));\r
 591         }\r
 592         else {\r
 593                 eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
 594         }\r
 595 }\r
 596 \r
 597 \r
 598 /*\r
 599  * Procedure:   lookupDtcEvent\r
 600  * Description: Returns TRUE if the DTC was found and "eventStatusRec" points\r
 601  *                              to the event record found.\r
 602  */\r
 603 static boolean lookupDtcEvent(uint32 dtc, EventStatusRecType **eventStatusRec)\r
 604 {\r
 605         boolean dtcFound = FALSE;\r
 606         uint16 i;\r
 607 \r
 608         *eventStatusRec = NULL;\r
 609 \r
 610         for (i = 0; (i < DEM_MAX_NUMBER_EVENT) && !dtcFound; i++) {\r
 611                 if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
 612                         if (eventStatusBuffer[i].eventParamRef->DTCClassRef != NULL) {\r
 613 \r
 614                                 // Check DTC\r
 615                                 if (eventStatusBuffer[i].eventParamRef->DTCClassRef->DTC == dtc) {\r
 616                                         *eventStatusRec = &eventStatusBuffer[i];\r
 617                                         dtcFound = TRUE;\r
 618                                 }\r
 619                         }\r
 620                 }\r
 621         }\r
 622 \r
 623         return dtcFound;\r
 624 }\r
 625 \r
 626 \r
 627 /*\r
 628  * Procedure:   matchEventWithDtcFilter\r
 629  * Description: Returns TRUE if the event pointed by "event" fulfill\r
 630  *                              the "dtcFilter" global filter settings.\r
 631  */\r
 632 static boolean matchEventWithDtcFilter(const EventStatusRecType *eventRec)\r
 633 {\r
 634         boolean dtcMatch = FALSE;\r
 635 \r
 636         // Check status\r
 637         if ((dtcFilter.dtcStatusMask == DEM_DTC_STATUS_MASK_ALL) || (eventRec->eventStatusExtended & dtcFilter.dtcStatusMask)) {\r
 638                 if (eventRec->eventParamRef != NULL) {\r
 639 \r
 640                         // Check dtcKind\r
 641                         if (checkDtcKind(dtcFilter.dtcKind, eventRec->eventParamRef)) {\r
 642 \r
 643                                 // Check dtcOrigin\r
 644                                 if (checkDtcOrigin(dtcFilter.dtcOrigin, eventRec->eventParamRef)) {\r
 645 \r
 646                                         // Check severity\r
 647                                         if ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
 648                                                 || ((dtcFilter.filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES) && checkDtcSeverityMask(dtcFilter.dtcSeverityMask, eventRec->eventParamRef))) {\r
 649 \r
 650                                                 // Check fault detection counter\r
 651                                                 if ((dtcFilter.filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_NO)\r
 652                                                         || ((dtcFilter.filterWithSeverity == DEM_FILTER_FOR_FDC_YES) && checkDtcFaultDetectionCounter(eventRec->eventParamRef))) {\r
 653                                                         dtcMatch = TRUE;\r
 654                                                 }\r
 655                                         }\r
 656                                 }\r
 657                         }\r
 658                 }\r
 659         }\r
 660 \r
 661         return dtcMatch;\r
 662 }\r
 663 \r
 664 \r
 665 static void getFreezeFrameData(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
 666 {\r
 667         // TODO: Fill out\r
 668         freezeFrame->eventId = DEM_EVENT_ID_NULL;       // Not supported yet\r
 669 }\r
 670 \r
 671 \r
 672 static void storeFreezeFrameDataPreInit(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
 673 {\r
 674         // TODO: Fill out\r
 675 }\r
 676 \r
 677 \r
 678 static void updateFreezeFrameOccurrencePreInit(EventRecType *EventBuffer)\r
 679 {\r
 680         // TODO: Fill out\r
 681 }\r
 682 \r
 683 \r
 684 /*\r
 685  * Procedure:   getExtendedData\r
 686  * Description: Collects the extended data according to "eventParam" and return it in "extData",\r
 687  *                              if not found eventId is set to DEM_EVENT_ID_NULL.\r
 688  */\r
 689 static void getExtendedData(const Dem_EventParameterType *eventParam, ExtDataRecType *extData)\r
 690 {\r
 691         Std_ReturnType callbackReturnCode;\r
 692         uint16 i;\r
 693         uint16 storeIndex = 0;\r
 694         uint16 recordSize;\r
 695 \r
 696         // Clear ext data record\r
 697         memset(extData, 0, sizeof(ExtDataRecType));\r
 698 \r
 699         // Check if any pointer to extended data class\r
 700         if (eventParam->ExtendedDataClassRef != NULL) {\r
 701                 // Request extended data and copy it to the buffer\r
 702                 for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i] != NULL); i++) {\r
 703                         recordSize = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->DataSize;\r
 704                         if ((storeIndex + recordSize) <= DEM_MAX_SIZE_EXT_DATA) {\r
 705                                 callbackReturnCode = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef[i]->CallbackGetExtDataRecord(&extData->data[storeIndex]); /** @req DEM282 */\r
 706                                 if (callbackReturnCode != E_OK) {\r
 707                                         // Callback data currently not available, clear space.\r
 708                                         memset(&extData->data[storeIndex], 0xFF, recordSize);\r
 709                                 }\r
 710                                 storeIndex += recordSize;\r
 711                         }\r
 712                         else {\r
 713                                 // Error: Size of extended data record is bigger than reserved space.\r
 714 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 715                                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GET_EXTENDED_DATA_ID, DEM_E_EXT_DATA_TOO_BIG); /** @req DEM117 */\r
 716 #endif\r
 717                                 break;  // Break the loop\r
 718                         }\r
 719                 }\r
 720         }\r
 721 \r
 722         // Check if any data has been stored\r
 723         if (storeIndex != 0) {\r
 724                 extData->eventId = eventParam->EventID;\r
 725                 extData->dataSize = storeIndex;\r
 726                 extData->checksum = calcChecksum(extData, sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
 727         }\r
 728         else {\r
 729                 extData->eventId = DEM_EVENT_ID_NULL;\r
 730                 extData->dataSize = storeIndex;\r
 731                 extData->checksum = 0;\r
 732         }\r
 733 }\r
 734 \r
 735 \r
 736 /*\r
 737  * Procedure:   storeExtendedDataPreInit\r
 738  * Description: Store the extended data pointed by "extendedData" to the "preInitExtDataBuffer",\r
 739  *                              if non existent a new entry is created.\r
 740  */\r
 741 static void storeExtendedDataPreInit(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData)\r
 742 {\r
 743         uint16 i;\r
 744         imask_t state = McuE_EnterCriticalSection();\r
 745 \r
 746         // Check if already stored\r
 747         for (i = 0; (preInitExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT); i++);\r
 748 \r
 749         if (i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) {\r
 750                 // Yes, overwrite existing\r
 751                 memcpy(&preInitExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
 752         }\r
 753         else {\r
 754                 // No, lookup first free position\r
 755                 for (i = 0; (preInitExtDataBuffer[i].eventId !=0) && (i<DEM_MAX_NUMBER_EXT_DATA_PRE_INIT); i++);\r
 756 \r
 757                 if (i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT) {\r
 758                         memcpy(&preInitExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
 759                 }\r
 760                 else {\r
 761                         // Error: Pre init extended data buffer full\r
 762 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 763                         Det_ReportError(MODULE_ID_DEM, 0, DEM_STORE_EXT_DATA_PRE_INIT_ID, DEM_E_PRE_INIT_EXT_DATA_BUFF_FULL); /** @req DEM117 */\r
 764 #endif\r
 765                 }\r
 766         }\r
 767 \r
 768         McuE_ExitCriticalSection(state);\r
 769 }\r
 770 \r
 771 \r
 772 /*\r
 773  * Procedure:   storeEventPriMem\r
 774  * Description: Store the event data of "eventStatus->eventId" in "priMemEventBuffer",\r
 775  *                              if non existent a new entry is created.\r
 776  */\r
 777 static void storeEventPriMem(const Dem_EventParameterType *eventParam, EventStatusRecType *eventStatus)\r
 778 {\r
 779         uint16 i;\r
 780         imask_t state = McuE_EnterCriticalSection();\r
 781 \r
 782 \r
 783         // Lookup event ID\r
 784         for (i = 0; (priMemEventBuffer[i].eventId != eventStatus->eventId) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
 785 \r
 786         if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
 787                 // Update event found\r
 788                 priMemEventBuffer[i].occurrence = eventStatus->occurrence;\r
 789                 priMemEventBuffer[i].checksum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
 790         }\r
 791         else {\r
 792                 // Search for free position\r
 793                 for (i=0; (priMemEventBuffer[i].eventId != DEM_EVENT_ID_NULL) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
 794 \r
 795                 if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
 796                         priMemEventBuffer[i].eventId = eventStatus->eventId;\r
 797                         priMemEventBuffer[i].occurrence = eventStatus->occurrence;\r
 798                         priMemEventBuffer[i].checksum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
 799                 }\r
 800                 else {\r
 801                         // Error: Pri mem event buffer full\r
 802 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 803                         Det_ReportError(MODULE_ID_DEM, 0, DEM_STORE_EVENT_PRI_MEM_ID, DEM_E_PRI_MEM_EVENT_BUFF_FULL); /** @req DEM117 */\r
 804 #endif\r
 805                 }\r
 806         }\r
 807 \r
 808         McuE_ExitCriticalSection(state);\r
 809 }\r
 810 \r
 811 \r
 812 /*\r
 813  * Procedure:   deleteEventPriMem\r
 814  * Description: Delete the event data of "eventParam->eventId" from "priMemEventBuffer".\r
 815  */\r
 816 static void deleteEventPriMem(const Dem_EventParameterType *eventParam)\r
 817 {\r
 818         uint16 i;\r
 819         imask_t state = McuE_EnterCriticalSection();\r
 820 \r
 821 \r
 822         // Lookup event ID\r
 823         for (i = 0; (priMemEventBuffer[i].eventId != eventParam->EventID) && (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI); i++);\r
 824 \r
 825         if (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) {\r
 826                 // Delete event found\r
 827                 memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
 828         }\r
 829 \r
 830         McuE_ExitCriticalSection(state);\r
 831 }\r
 832 \r
 833 \r
 834 /*\r
 835  * Procedure:   storeEventEvtMem\r
 836  * Description: Store the event data of "eventStatus->eventId" in event memory according to\r
 837  *                              "eventParam" destination option.\r
 838  */\r
 839 static void storeEventEvtMem(const Dem_EventParameterType *eventParam, EventStatusRecType *eventStatus)\r
 840 {\r
 841         uint16 i;\r
 842 \r
 843         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION)\r
 844                                  && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
 845                 switch (eventParam->EventClass->EventDestination[i])\r
 846                 {\r
 847                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
 848                         storeEventPriMem(eventParam, eventStatus);      /** @req DEM010 */\r
 849                         break;\r
 850 \r
 851                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
 852                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
 853                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
 854                         // Not yet supported\r
 855 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 856                         Det_ReportError(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
 857 #endif\r
 858                         break;\r
 859                 default:\r
 860                         break;\r
 861                 }\r
 862         }\r
 863 }\r
 864 \r
 865 \r
 866 /*\r
 867  * Procedure:   storeExtendedDataPriMem\r
 868  * Description: Store the extended data pointed by "extendedData" to the "priMemExtDataBuffer",\r
 869  *                              if non existent a new entry is created.\r
 870  */\r
 871 static void storeExtendedDataPriMem(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData) /** @req DEM041 */\r
 872 {\r
 873         uint16 i;\r
 874         imask_t state = McuE_EnterCriticalSection();\r
 875 \r
 876         // Check if already stored\r
 877         for (i = 0; (priMemExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
 878 \r
 879         if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
 880                 // Yes, overwrite existing\r
 881                 memcpy(&priMemExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
 882         }\r
 883         else {\r
 884                 // No, lookup first free position\r
 885                 for (i = 0; (priMemExtDataBuffer[i].eventId != DEM_EVENT_ID_NULL) && (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
 886                 if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
 887                         memcpy(&priMemExtDataBuffer[i], extendedData, sizeof(ExtDataRecType));\r
 888                 }\r
 889                 else {\r
 890                         // Error: Pri mem extended data buffer full\r
 891 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 892                         Det_ReportError(MODULE_ID_DEM, 0, DEM_STORE_EXT_DATA_PRI_MEM_ID, DEM_E_PRI_MEM_EXT_DATA_BUFF_FULL); /** @req DEM117 */\r
 893 #endif\r
 894                 }\r
 895         }\r
 896 \r
 897         McuE_ExitCriticalSection(state);\r
 898 }\r
 899 \r
 900 \r
 901 /*\r
 902  * Procedure:   deleteExtendedDataPriMem\r
 903  * Description: Delete the extended data of "eventParam->eventId" from "priMemExtDataBuffer".\r
 904  */\r
 905 static void deleteExtendedDataPriMem(const Dem_EventParameterType *eventParam)\r
 906 {\r
 907         uint16 i;\r
 908         imask_t state = McuE_EnterCriticalSection();\r
 909 \r
 910         // Check if already stored\r
 911         for (i = 0; (priMemExtDataBuffer[i].eventId != eventParam->EventID) && (i<DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
 912 \r
 913         if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
 914                 // Yes, clear record\r
 915                 memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
 916         }\r
 917 \r
 918         McuE_ExitCriticalSection(state);\r
 919 }\r
 920 \r
 921 \r
 922 /*\r
 923  * Procedure:   storeExtendedDataEvtMem\r
 924  * Description: Store the extended data in event memory according to\r
 925  *                              "eventParam" destination option\r
 926  */\r
 927 static void storeExtendedDataEvtMem(const Dem_EventParameterType *eventParam, ExtDataRecType *extendedData)\r
 928 {\r
 929         uint16 i;\r
 930 \r
 931         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
 932                 switch (eventParam->EventClass->EventDestination[i])\r
 933                 {\r
 934                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
 935                         storeExtendedDataPriMem(eventParam, extendedData);\r
 936                         break;\r
 937 \r
 938                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
 939                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
 940                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
 941                         // Not yet supported\r
 942 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
 943                         Det_ReportError(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
 944 #endif\r
 945                         break;\r
 946 \r
 947                 default:\r
 948                         break;\r
 949                 }\r
 950         }\r
 951 }\r
 952 \r
 953 \r
 954 /*\r
 955  * Procedure:   lookupExtendedDataRecNumParam\r
 956  * Description: Returns TRUE if the requested extended data number was found among the configured records for the event.\r
 957  *                              "extDataRecClassPtr" returns a pointer to the record class, "posInExtData" returns the position in stored extended data.\r
 958  */\r
 959 static boolean lookupExtendedDataRecNumParam(uint8 extendedDataNumber, const Dem_EventParameterType *eventParam, Dem_ExtendedDataRecordClassType const **extDataRecClassPtr, uint8 *posInExtData)\r
 960 {\r
 961         boolean recNumFound = FALSE;\r
 962 \r
 963         if (eventParam->ExtendedDataClassRef != NULL) {\r
 964                 Dem_ExtendedDataRecordClassType const* const* extDataRecClassRefList = eventParam->ExtendedDataClassRef->ExtendedDataRecordClassRef;\r
 965                 uint16  byteCnt = 0;\r
 966                 uint16 i;\r
 967 \r
 968                 // Request extended data and copy it to the buffer\r
 969                 for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_EXTENDED_DATA) && (extDataRecClassRefList[i] != NULL) && !recNumFound; i++) {\r
 970                         if (extDataRecClassRefList[i]->RecordNumber == extendedDataNumber) {\r
 971                                 *extDataRecClassPtr =  extDataRecClassRefList[i];\r
 972                                 *posInExtData = byteCnt;\r
 973                                 recNumFound = TRUE;\r
 974                         }\r
 975                         byteCnt += extDataRecClassRefList[i]->DataSize;\r
 976                 }\r
 977         }\r
 978 \r
 979         return recNumFound;\r
 980 }\r
 981 \r
 982 \r
 983 /*\r
 984  * Procedure:   lookupExtendedDataPriMem\r
 985  * Description: Returns TRUE if the requested event id is found, "extData" points to the found data.\r
 986  */\r
 987 static boolean lookupExtendedDataPriMem(Dem_EventIdType eventId, ExtDataRecType **extData)\r
 988 {\r
 989         boolean eventIdFound = FALSE;\r
 990         uint16 i;\r
 991 \r
 992         // Lookup corresponding extended data\r
 993         for (i = 0; (priMemExtDataBuffer[i].eventId != eventId) && (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM); i++);\r
 994 \r
 995         if (i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM) {\r
 996                 // Yes, return pointer\r
 997                 *extData = &priMemExtDataBuffer[i];\r
 998                 eventIdFound = TRUE;\r
 999         }\r
1000 \r
1001         return eventIdFound;\r
1002 }\r
1003 \r
1004 \r
1005 static void storeFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
1006 {\r
1007         // TODO: Fill out\r
1008 }\r
1009 \r
1010 \r
1011 static void deleteFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam)\r
1012 {\r
1013         // TODO: Fill out\r
1014 }\r
1015 \r
1016 \r
1017 /*\r
1018  * Procedure:   storeFreezeFrameDataEvtMem\r
1019  * Description: Store the freeze frame data in event memory according to\r
1020  *                              "eventParam" destination option\r
1021  */\r
1022 static void storeFreezeFrameDataEvtMem(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
1023 {\r
1024         uint16 i;\r
1025 \r
1026         for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
1027                 switch (eventParam->EventClass->EventDestination[i])\r
1028                 {\r
1029                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
1030                         storeFreezeFrameDataPriMem(eventParam, freezeFrame);\r
1031                         break;\r
1032 \r
1033                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
1034                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
1035                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
1036                         // Not yet supported\r
1037 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1038                         Det_ReportError(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
1039 #endif\r
1040                         break;\r
1041                 default:\r
1042                         break;\r
1043                 }\r
1044         }\r
1045 }\r
1046 \r
1047 \r
1048 /*\r
1049  * Procedure:   handlePreInitEvent\r
1050  * Description: Handle the updating of event status and storing of\r
1051  *                              event related data in preInit buffers.\r
1052  */\r
1053 static void handlePreInitEvent(Dem_EventIdType eventId, Dem_EventStatusType eventStatus)\r
1054 {\r
1055         const Dem_EventParameterType *eventParam;\r
1056         EventStatusRecType eventStatusLocal;\r
1057         FreezeFrameRecType freezeFrameLocal;\r
1058         ExtDataRecType extendedDataLocal;\r
1059 \r
1060         // Find configuration for this event\r
1061         lookupEventIdParameter(eventId, &eventParam);\r
1062         if (eventParam != NULL) {\r
1063                 if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
1064                         if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
1065                                 if (eventStatus == DEM_EVENT_STATUS_FAILED) {\r
1066                                         updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
1067                                 }\r
1068                                 else {\r
1069                                         updateEventStatusRec(eventParam, eventStatus, FALSE, &eventStatusLocal);\r
1070                                 }\r
1071 \r
1072                                 if (eventStatusLocal.errorStatusChanged) {\r
1073 \r
1074                                         if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
1075                                                 // Collect freeze frame data\r
1076                                                 getFreezeFrameData(eventParam, &freezeFrameLocal);\r
1077                                                 if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
1078                                                         storeFreezeFrameDataPreInit(eventParam, &freezeFrameLocal);\r
1079                                                 }\r
1080 \r
1081                                                 // Collect extended data\r
1082                                                 getExtendedData(eventParam, &extendedDataLocal);\r
1083                                                 if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL) {\r
1084                                                         storeExtendedDataPreInit(eventParam, &extendedDataLocal);\r
1085                                                 }\r
1086                                         }\r
1087                                 }\r
1088                         }\r
1089                         else {\r
1090                                 // Operation cycle not started\r
1091                                 // TODO: Report error?\r
1092                         }\r
1093                 }\r
1094                 else {\r
1095                         // Operation cycle not set\r
1096                         // TODO: Report error?\r
1097                 }\r
1098         }\r
1099         else {\r
1100                 // Event ID not configured\r
1101                 // TODO: Report error?\r
1102         }\r
1103 }\r
1104 \r
1105 \r
1106 /*\r
1107  * Procedure:   handleEvent\r
1108  * Description: Handle the updating of event status and storing of\r
1109  *                              event related data in event memory.\r
1110  */\r
1111 static Std_ReturnType handleEvent(Dem_EventIdType eventId, Dem_EventStatusType eventStatus)\r
1112 {\r
1113         Std_ReturnType returnCode = E_OK;\r
1114         const Dem_EventParameterType *eventParam;\r
1115         EventStatusRecType eventStatusLocal;\r
1116         FreezeFrameRecType freezeFrameLocal;\r
1117         ExtDataRecType extendedDataLocal;\r
1118 \r
1119         // Find configuration for this event\r
1120         lookupEventIdParameter(eventId, &eventParam);\r
1121         if (eventParam != NULL) {\r
1122                 if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
1123                         if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
1124                                 if (!(disableDtcStorage.storageDisabled && checkDtcGroup(disableDtcStorage.dtcGroup, eventParam) && checkDtcKind(disableDtcStorage.dtcKind, eventParam)))  {\r
1125                                         updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
1126                                         if (eventStatusLocal.errorStatusChanged) {\r
1127                                                 if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
1128                                                         storeEventEvtMem(eventParam, &eventStatusLocal); /** @req DEM184 */\r
1129                                                         // Collect freeze frame data\r
1130                                                         getFreezeFrameData(eventParam, &freezeFrameLocal);\r
1131                                                         if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
1132                                                                 storeFreezeFrameDataEvtMem(eventParam, &freezeFrameLocal); /** @req DEM190 */\r
1133                                                         }\r
1134 \r
1135                                                         // Collect extended data\r
1136                                                         getExtendedData(eventParam, &extendedDataLocal);\r
1137                                                         if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL)\r
1138                                                         {\r
1139                                                                 storeExtendedDataEvtMem(eventParam, &extendedDataLocal);\r
1140                                                         }\r
1141                                                 }\r
1142                                         }\r
1143                                 }\r
1144                         }\r
1145                         else {\r
1146                                 // Operation cycle not started\r
1147                                 returnCode = E_NOT_OK;\r
1148                         }\r
1149                 }\r
1150                 else {\r
1151                         // Operation cycle not set\r
1152                         returnCode = E_NOT_OK;\r
1153                 }\r
1154         }\r
1155         else {\r
1156                 // Event ID not configured\r
1157                 returnCode = E_NOT_OK;\r
1158         }\r
1159 \r
1160         return returnCode;\r
1161 }\r
1162 \r
1163 \r
1164 /*\r
1165  * Procedure:   resetEventStatus\r
1166  * Description: Resets the events status of eventId.\r
1167  */\r
1168 static void resetEventStatus(Dem_EventIdType eventId)\r
1169 {\r
1170         imask_t state = McuE_EnterCriticalSection();\r
1171         EventStatusRecType *eventStatusRecPtr;\r
1172 \r
1173         lookupEventStatusRec(eventId, &eventStatusRecPtr);\r
1174         if (eventStatusRecPtr != NULL) {\r
1175                 eventStatusRecPtr->eventStatusExtended &= ~DEM_TEST_FAILED; /** @req DEM187 */\r
1176         }\r
1177 \r
1178         McuE_ExitCriticalSection(state);\r
1179 }\r
1180 \r
1181 \r
1182 /*\r
1183  * Procedure:   getEventStatus\r
1184  * Description: Returns the extended event status bitmask of eventId in "eventStatusExtended".\r
1185  */\r
1186 static void getEventStatus(Dem_EventIdType eventId, Dem_EventStatusExtendedType *eventStatusExtended)\r
1187 {\r
1188         EventStatusRecType eventStatusLocal;\r
1189 \r
1190         // Get recorded status\r
1191         getEventStatusRec(eventId, &eventStatusLocal);\r
1192         if (eventStatusLocal.eventId == eventId) {\r
1193                 *eventStatusExtended = eventStatusLocal.eventStatusExtended; /** @req DEM051 */\r
1194         }\r
1195         else {\r
1196                 // Event Id not found, no report received.\r
1197                 *eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
1198         }\r
1199 }\r
1200 \r
1201 \r
1202 /*\r
1203  * Procedure:   getEventFailed\r
1204  * Description: Returns the TRUE or FALSE of "eventId" in "eventFailed" depending on current status.\r
1205  */\r
1206 static void getEventFailed(Dem_EventIdType eventId, boolean *eventFailed)\r
1207 {\r
1208         EventStatusRecType eventStatusLocal;\r
1209 \r
1210         // Get recorded status\r
1211         getEventStatusRec(eventId, &eventStatusLocal);\r
1212         if (eventStatusLocal.eventId == eventId) {\r
1213                 if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) { /** @req DEM052 */\r
1214                         *eventFailed = TRUE;\r
1215                 }\r
1216                 else {\r
1217                         *eventFailed = FALSE;\r
1218                 }\r
1219         }\r
1220         else {\r
1221                 // Event Id not found, assume ok.\r
1222                 *eventFailed = FALSE;\r
1223         }\r
1224 }\r
1225 \r
1226 \r
1227 /*\r
1228  * Procedure:   getEventTested\r
1229  * Description: Returns the TRUE or FALSE of "eventId" in "eventTested" depending on\r
1230  *                              current status the "test not completed this operation cycle" bit.\r
1231  */\r
1232 static void getEventTested(Dem_EventIdType eventId, boolean *eventTested)\r
1233 {\r
1234         EventStatusRecType eventStatusLocal;\r
1235 \r
1236         // Get recorded status\r
1237         getEventStatusRec(eventId, &eventStatusLocal);\r
1238         if (eventStatusLocal.eventId == eventId) {\r
1239                 if ( !(eventStatusLocal.eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE)) { /** @req DEM053 */\r
1240                         *eventTested = TRUE;\r
1241                 }\r
1242                 else {\r
1243                         *eventTested = FALSE;\r
1244                 }\r
1245         }\r
1246         else {\r
1247                 // Event Id not found, not tested.\r
1248                 *eventTested = FALSE;\r
1249         }\r
1250 }\r
1251 \r
1252 \r
1253 /*\r
1254  * Procedure:   getFaultDetectionCounter\r
1255  * Description: Returns pre debounce counter of "eventId" in "counter" and return value E_OK if\r
1256  *                              the counter was available else E_NOT_OK.\r
1257  */\r
1258 static Std_ReturnType getFaultDetectionCounter(Dem_EventIdType eventId, sint8 *counter)\r
1259 {\r
1260         Std_ReturnType returnCode = E_NOT_OK;\r
1261         const Dem_EventParameterType *eventParam;\r
1262 \r
1263         lookupEventIdParameter(eventId, &eventParam);\r
1264         if (eventParam != NULL) {\r
1265                 if (eventParam->EventClass->PreDebounceAlgorithmClass != NULL) {\r
1266                         switch (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceName)\r
1267                         {\r
1268                         case DEM_NO_PRE_DEBOUNCE:\r
1269                                 if (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal != NULL) {\r
1270                                         if (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal->CallbackGetFDCntFnc != NULL) {\r
1271                                                 returnCode = eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceAlgorithm.PreDebounceMonitorInternal->CallbackGetFDCntFnc(counter); /** @req DEM204.None */ /** @req DEM264 */ /** @req DEM265 */\r
1272                                         }\r
1273                                 }\r
1274                                 break;\r
1275 \r
1276                         case DEM_PRE_DEBOUNCE_COUNTER_BASED:\r
1277                                 {\r
1278                                         EventStatusRecType *eventStatusRec;\r
1279 \r
1280                                         lookupEventStatusRec(eventId, &eventStatusRec);\r
1281                                         if (eventStatusRec != NULL) {\r
1282                                                 *counter = eventStatusRec->faultDetectionCounter; /** @req DEM204.Counter */\r
1283                                         } else {\r
1284                                                 *counter = 0;\r
1285                                         }\r
1286                                         returnCode = E_OK;\r
1287                                 }\r
1288                                 break;\r
1289 \r
1290                         case DEM_PRE_DEBOUNCE_FREQUENCY_BASED:\r
1291                         case DEM_PRE_DEBOUNCE_TIME_BASED:\r
1292 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1293                                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
1294 #endif\r
1295                                 break;\r
1296 \r
1297                         default:\r
1298 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1299                                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_PARAM_DATA); /** @req DEM117 */\r
1300 #endif\r
1301                                 break;\r
1302                         }\r
1303                 }\r
1304         }\r
1305 \r
1306         return returnCode;\r
1307 }\r
1308 \r
1309 \r
1310 /*\r
1311  * Procedure:   setOperationCycleState\r
1312  * Description: Change the operation state of "operationCycleId" to "cycleState" and updates stored\r
1313  *                              event connected to this cycle id.\r
1314  *                              Returns E_OK if operation was successful else E_NOT_OK.\r
1315  */\r
1316 static Std_ReturnType setOperationCycleState(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState) /** @req DEM338 */\r
1317 {\r
1318         uint16 i;\r
1319         Std_ReturnType returnCode = E_OK;\r
1320 \r
1321         if (operationCycleId < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
1322                 switch (cycleState)\r
1323                 {\r
1324                 case DEM_CYCLE_STATE_START:\r
1325                         operationCycleStateList[operationCycleId] = cycleState;\r
1326                         // Lookup event ID\r
1327                         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1328                                 if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
1329                                         eventStatusBuffer[i].eventStatusExtended &= ~DEM_TEST_FAILED_THIS_OPERATION_CYCLE;\r
1330                                         eventStatusBuffer[i].eventStatusExtended |= DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE;\r
1331                                 }\r
1332                         }\r
1333                         break;\r
1334 \r
1335                 case DEM_CYCLE_STATE_END:\r
1336                         operationCycleStateList[operationCycleId] = cycleState;\r
1337                         // Lookup event ID\r
1338                         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1339                                 if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
1340                                         if (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED_THIS_OPERATION_CYCLE) && !(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE)) {\r
1341                                                 eventStatusBuffer[i].eventStatusExtended &= ~DEM_PENDING_DTC;           // Clear pendingDTC bit /** @req DEM379.PendingClear\r
1342                                         }\r
1343                                 }\r
1344                         }\r
1345                         break;\r
1346                 default:\r
1347 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1348                         Det_ReportError(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA); /** @req DEM117 */\r
1349 #endif\r
1350                         returnCode = E_NOT_OK;\r
1351                         break;\r
1352                 }\r
1353         }\r
1354         else {\r
1355 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1356                 Det_ReportError(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA); /** @req DEM117 */\r
1357 #endif\r
1358                 returnCode = E_NOT_OK;\r
1359                 }\r
1360 \r
1361         return returnCode;\r
1362 }\r
1363 \r
1364 \r
1365 //==============================================================================//\r
1366 //                                                                                                                                                              //\r
1367 //                                        E X T E R N A L   F U N C T I O N S                                           //\r
1368 //                                                                                                                                                              //\r
1369 //==============================================================================//\r
1370 \r
1371 /*********************************************\r
1372  * Interface for upper layer modules (8.3.1) *\r
1373  *********************************************/\r
1374 \r
1375 /*\r
1376  * Procedure:   Dem_GetVersionInfo\r
1377  * Reentrant:   Yes\r
1378  */\r
1379 // Defined in Dem.h\r
1380 \r
1381 \r
1382 /***********************************************\r
1383  * Interface ECU State Manager <-> DEM (8.3.2) *\r
1384  ***********************************************/\r
1385 \r
1386 /*\r
1387  * Procedure:   Dem_PreInit\r
1388  * Reentrant:   No\r
1389  */\r
1390 void Dem_PreInit(void)\r
1391 {\r
1392         /** @req DEM180 */\r
1393         int i, j;\r
1394 \r
1395         if (DEM_Config.ConfigSet == NULL) {\r
1396 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1397                 Det_ReportError(MODULE_ID_DEM, 0, DEM_PREINIT_ID, DEM_E_CONFIG_PTR_INVALID); /** @req DEM117 */\r
1398 #endif\r
1399                 return;\r
1400         } else {\r
1401                 configSet = DEM_Config.ConfigSet;\r
1402         }\r
1403 \r
1404         // Initializion of operation cycle states.\r
1405         for (i = 0; i < DEM_OPERATION_CYCLE_ID_ENDMARK; i++) {\r
1406                 operationCycleStateList[i] = DEM_CYCLE_STATE_END;\r
1407         }\r
1408 \r
1409         // Initialize the event status buffer\r
1410         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1411                 eventStatusBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
1412                 eventStatusBuffer[i].eventParamRef = NULL;\r
1413                 eventStatusBuffer[i].faultDetectionCounter = 0;\r
1414                 eventStatusBuffer[i].occurrence = 0;\r
1415                 eventStatusBuffer[i].eventStatusExtended = DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR;\r
1416                 eventStatusBuffer[i].errorStatusChanged = FALSE;\r
1417         }\r
1418 \r
1419         // Initialize the pre init buffers\r
1420         for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
1421                 preInitFreezeFrameBuffer[i].checksum = 0;\r
1422                 preInitFreezeFrameBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
1423                 preInitFreezeFrameBuffer[i].occurrence = 0;\r
1424                 preInitFreezeFrameBuffer[i].dataSize = 0;\r
1425                 for (j = 0; j < DEM_MAX_SIZE_FF_DATA;j++)\r
1426                         preInitFreezeFrameBuffer[i].data[j] = 0;\r
1427         }\r
1428 \r
1429         for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
1430                 preInitExtDataBuffer[i].checksum = 0;\r
1431                 preInitExtDataBuffer[i].eventId = DEM_EVENT_ID_NULL;\r
1432                 preInitExtDataBuffer[i].dataSize = 0;\r
1433                 for (j = 0; j < DEM_MAX_SIZE_EXT_DATA;j++)\r
1434                         preInitExtDataBuffer[i].data[j] = 0;\r
1435         }\r
1436 \r
1437         disableDtcStorage.storageDisabled = FALSE;\r
1438 \r
1439         setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START); /** @req DEM047 */\r
1440 \r
1441         demState = DEM_PREINITIALIZED;\r
1442 }\r
1443 \r
1444 \r
1445 /*\r
1446  * Procedure:   Dem_Init\r
1447  * Reentrant:   No\r
1448  */\r
1449 void Dem_Init(void)\r
1450 {\r
1451         uint16 i;\r
1452         ChecksumType cSum;\r
1453         const Dem_EventParameterType *eventParam;\r
1454 \r
1455         /*\r
1456          *  Validate and read out saved error log from non volatile memory\r
1457          */\r
1458 \r
1459         // Validate event records stored in primary memory\r
1460         for (i = 0; i < DEM_MAX_NUMBER_EVENT_PRI_MEM; i++) {\r
1461                 cSum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
1462                 if ((cSum != priMemEventBuffer[i].checksum) || priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL) {\r
1463                         // Unlegal record, clear the record\r
1464                         memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
1465                 }\r
1466                 else {\r
1467                         // Valid, update current status\r
1468                         mergeEventStatusRec(&priMemEventBuffer[i]);\r
1469 \r
1470                         // Update occurrence counter on pre init stored freeze frames\r
1471                         updateFreezeFrameOccurrencePreInit(&priMemEventBuffer[i]);\r
1472                 }\r
1473         }\r
1474 \r
1475         // Validate extended data records stored in primary memory\r
1476         for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM; i++) {\r
1477                 cSum = calcChecksum(&priMemExtDataBuffer[i], sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
1478                 if ((cSum != priMemExtDataBuffer[i].checksum) || priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL) {\r
1479                         // Unlegal record, clear the record\r
1480                         memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
1481                 }\r
1482         }\r
1483 \r
1484         // Validate freeze frame records stored in primary memory\r
1485         for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++) {\r
1486                 cSum = calcChecksum(&priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
1487                 if ((cSum != priMemFreezeFrameBuffer[i].checksum) || (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
1488                         // Unlegal record, clear the record\r
1489                         memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
1490                 }\r
1491         }\r
1492 \r
1493         /*\r
1494          *  Handle errors stored in temporary buffer (if any)\r
1495          */\r
1496 \r
1497         // Transfer updated event data to event memory\r
1498         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1499                 if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
1500                         // Update the event memory\r
1501                         lookupEventIdParameter(eventStatusBuffer[i].eventId, &eventParam);\r
1502                         storeEventEvtMem(eventParam, &eventStatusBuffer[i]);\r
1503                 }\r
1504         }\r
1505 \r
1506         // Transfer extended data to event memory if necessary\r
1507         for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
1508                 if (preInitExtDataBuffer[i].eventId !=  DEM_EVENT_ID_NULL) {\r
1509                         lookupEventIdParameter(preInitExtDataBuffer[i].eventId, &eventParam);\r
1510                         storeExtendedDataEvtMem(eventParam, &preInitExtDataBuffer[i]);\r
1511                 }\r
1512         }\r
1513 \r
1514         // Transfer freeze frames to event memory\r
1515         for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
1516                 if (preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
1517                         lookupEventIdParameter(preInitFreezeFrameBuffer[i].eventId, &eventParam);\r
1518                         storeFreezeFrameDataEvtMem(eventParam, &preInitFreezeFrameBuffer[i]);\r
1519                 }\r
1520         }\r
1521 \r
1522         // Init the dtc filter\r
1523         dtcFilter.dtcStatusMask = DEM_DTC_STATUS_MASK_ALL;                                      // All allowed\r
1524         dtcFilter.dtcKind = DEM_DTC_KIND_ALL_DTCS;                                                      // All kinds of DTCs\r
1525         dtcFilter.dtcOrigin = DEM_DTC_ORIGIN_PRIMARY_MEMORY;                            // Primary memory\r
1526         dtcFilter.filterWithSeverity = DEM_FILTER_WITH_SEVERITY_NO;                     // No Severity filtering\r
1527         dtcFilter.dtcSeverityMask = DEM_SEVERITY_NO_SEVERITY;                           // Not used when filterWithSeverity is FALSE\r
1528         dtcFilter.filterForFaultDetectionCounter = DEM_FILTER_FOR_FDC_NO;       // No fault detection counter filtering\r
1529 \r
1530         dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
1531 \r
1532         disableDtcStorage.storageDisabled = FALSE;\r
1533 \r
1534         demState = DEM_INITIALIZED;\r
1535 }\r
1536 \r
1537 \r
1538 /*\r
1539  * Procedure:   Dem_shutdown\r
1540  * Reentrant:   No\r
1541  */\r
1542 void Dem_Shutdown(void)\r
1543 {\r
1544         setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_END); /** @req DEM047 */\r
1545 \r
1546         demState = DEM_UNINITIALIZED; /** @req DEM368 */\r
1547 }\r
1548 \r
1549 \r
1550 /*\r
1551  * Interface for basic software scheduler\r
1552  */\r
1553 void Dem_MainFunction(void)\r
1554 {\r
1555         /** @req DEM125 */\r
1556 \r
1557 }\r
1558 \r
1559 \r
1560 /***************************************************\r
1561  * Interface SW-Components via RTE <-> DEM (8.3.3) *\r
1562  ***************************************************/\r
1563 \r
1564 /*\r
1565  * Procedure:   Dem_SetEventStatus\r
1566  * Reentrant:   Yes\r
1567  */\r
1568 Std_ReturnType Dem_SetEventStatus(Dem_EventIdType eventId, Dem_EventStatusType eventStatus) /** @req DEM330 */\r
1569 {\r
1570         Std_ReturnType returnCode = E_OK;\r
1571 \r
1572         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1573         {\r
1574                 returnCode = handleEvent(eventId, eventStatus);\r
1575         }\r
1576         else\r
1577         {\r
1578 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1579                 Det_ReportError(MODULE_ID_DEM, 0, DEM_SETEVENTSTATUS_ID, DEM_E_UNINIT); /** @req DEM124.SetEventStatus */ /** @req DEM117 */\r
1580 #endif\r
1581                 returnCode = E_NOT_OK; /** @req DEM370.SetEventStatus */\r
1582         }\r
1583 \r
1584         return returnCode;\r
1585 }\r
1586 \r
1587 \r
1588 /*\r
1589  * Procedure:   Dem_ResetEventStatus\r
1590  * Reentrant:   Yes\r
1591  */\r
1592 Std_ReturnType Dem_ResetEventStatus(Dem_EventIdType eventId) /** @req DEM331 */\r
1593 {\r
1594         Std_ReturnType returnCode = E_OK;\r
1595 \r
1596         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1597         {\r
1598                 resetEventStatus(eventId); /** @req DEM186 */\r
1599         }\r
1600         else\r
1601         {\r
1602 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1603                 Det_ReportError(MODULE_ID_DEM, 0, DEM_RESETEVENTSTATUS_ID, DEM_E_UNINIT); /** @req DEM124.ResetEventStatus */ /** @req DEM117 */\r
1604 #endif\r
1605                 returnCode = E_NOT_OK; /** @req DEM370.ResetEventStatus */\r
1606         }\r
1607 \r
1608         return returnCode;\r
1609 }\r
1610 \r
1611 \r
1612 /*\r
1613  * Procedure:   Dem_GetEventStatus\r
1614  * Reentrant:   Yes\r
1615  */\r
1616 Std_ReturnType Dem_GetEventStatus(Dem_EventIdType eventId, Dem_EventStatusExtendedType *eventStatusExtended) /** @req DEM332 */\r
1617 {\r
1618         Std_ReturnType returnCode = E_OK;\r
1619 \r
1620         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1621         {\r
1622                 getEventStatus(eventId, eventStatusExtended);\r
1623         }\r
1624         else\r
1625         {\r
1626 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1627                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETEVENTSTATUS_ID, DEM_E_UNINIT); /** @req DEM124.GetEventStatus */ /** @req DEM117 */\r
1628 #endif\r
1629                 returnCode = E_NOT_OK; /** @req DEM370.GetEventStatus */\r
1630         }\r
1631 \r
1632         return returnCode;\r
1633 }\r
1634 \r
1635 \r
1636 /*\r
1637  * Procedure:   Dem_GetEventFailed\r
1638  * Reentrant:   Yes\r
1639  */\r
1640 Std_ReturnType Dem_GetEventFailed(Dem_EventIdType eventId, boolean *eventFailed) /** @req DEM333 */\r
1641 {\r
1642         Std_ReturnType returnCode = E_OK;\r
1643 \r
1644         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1645         {\r
1646                 getEventFailed(eventId, eventFailed);\r
1647         }\r
1648         else\r
1649         {\r
1650 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1651                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETEVENTFAILED_ID, DEM_E_UNINIT); /** @req DEM124.GetEventFailed */ /** @req DEM117 */\r
1652 #endif\r
1653                 returnCode = E_NOT_OK; /** @req DEM370.GetEventFailed */\r
1654         }\r
1655 \r
1656         return returnCode;\r
1657 }\r
1658 \r
1659 \r
1660 /*\r
1661  * Procedure:   Dem_GetEventTested\r
1662  * Reentrant:   Yes\r
1663  */\r
1664 Std_ReturnType Dem_GetEventTested(Dem_EventIdType eventId, boolean *eventTested)\r
1665 {\r
1666         Std_ReturnType returnCode = E_OK;\r
1667 \r
1668         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1669         {\r
1670                 getEventTested(eventId, eventTested);\r
1671         }\r
1672         else\r
1673         {\r
1674 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1675                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETEVENTTESTED_ID, DEM_E_UNINIT); /** @req DEM124.GetEventTested */ /** @req DEM117 */\r
1676 #endif\r
1677                 returnCode = E_NOT_OK; /** @req DEM370.GetEventTested */\r
1678         }\r
1679 \r
1680         return returnCode;\r
1681 }\r
1682 \r
1683 \r
1684 /*\r
1685  * Procedure:   Dem_GetFaultDetectionCounter\r
1686  * Reentrant:   No\r
1687  */\r
1688 Std_ReturnType Dem_GetFaultDetectionCounter(Dem_EventIdType eventId, sint8 *counter)\r
1689 {\r
1690         Std_ReturnType returnCode = E_OK;\r
1691 \r
1692         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1693         {\r
1694                 returnCode = getFaultDetectionCounter(eventId, counter);\r
1695         }\r
1696         else\r
1697         {\r
1698 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1699                 Det_ReportError(MODULE_ID_DEM, 0, DEM_GETFAULTDETECTIONCOUNTER_ID, DEM_E_UNINIT); /** @req DEM124.GetFaultDetectionCounter */ /** @req DEM117 */\r
1700 #endif\r
1701                 returnCode = E_NOT_OK; /** @req DEM370.GetFaultDetectionCounter */\r
1702         }\r
1703 \r
1704         return returnCode;\r
1705 }\r
1706 \r
1707 \r
1708 /*\r
1709  * Procedure:   Dem_SetOperationCycleState\r
1710  * Reentrant:   No\r
1711  */\r
1712 Std_ReturnType Dem_SetOperationCycleState(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState)\r
1713 {\r
1714         Std_ReturnType returnCode = E_OK;\r
1715 \r
1716         if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
1717         {\r
1718                 returnCode = setOperationCycleState(operationCycleId, cycleState);\r
1719 \r
1720         }\r
1721         else\r
1722         {\r
1723 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1724                 Det_ReportError(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_UNINIT); /** @req DEM124.SetOperationCycleState */ /** @req DEM117 */\r
1725 #endif\r
1726                 returnCode = E_NOT_OK; /** @req DEM370.SetOperationCycleState */\r
1727         }\r
1728 \r
1729         return returnCode;\r
1730 }\r
1731 \r
1732 \r
1733 /*\r
1734  * Procedure:   Dem_GetDTCOfEvent\r
1735  * Reentrant:   Yes\r
1736  */\r
1737 Std_ReturnType Dem_GetDTCOfEvent(Dem_EventIdType eventId, Dem_DTCKindType dtcKind, uint32* dtcOfEvent)\r
1738 {\r
1739         Std_ReturnType returnCode = E_NO_DTC_AVAILABLE;\r
1740         const Dem_EventParameterType *eventParam;\r
1741 \r
1742         lookupEventIdParameter(eventId, &eventParam);\r
1743 \r
1744         if (eventParam != NULL) {\r
1745                 if (checkDtcKind(dtcKind, eventParam)) {\r
1746                         if (eventParam->DTCClassRef != NULL) {\r
1747                                 *dtcOfEvent = eventParam->DTCClassRef->DTC; /** @req DEM269 */\r
1748                                 returnCode = E_OK;\r
1749                         }\r
1750                 }\r
1751         }\r
1752         else {\r
1753                 // Event Id not found\r
1754                 returnCode = E_NOT_OK;\r
1755         }\r
1756 \r
1757         return returnCode;\r
1758 }\r
1759 \r
1760 \r
1761 /********************************************\r
1762  * Interface BSW-Components <-> DEM (8.3.4) *\r
1763  ********************************************/\r
1764 \r
1765 /*\r
1766  * Procedure:   Dem_ReportErrorStatus\r
1767  * Reentrant:   Yes\r
1768  */\r
1769 void Dem_ReportErrorStatus( Dem_EventIdType eventId, Dem_EventStatusType eventStatus ) /** @req DEM107 */\r
1770 {\r
1771 \r
1772         switch (demState) {\r
1773                 case DEM_PREINITIALIZED:\r
1774                         // Update status and check if is to be stored\r
1775                         if ((eventStatus == DEM_EVENT_STATUS_PASSED) || (eventStatus == DEM_EVENT_STATUS_FAILED)) {\r
1776                                 handlePreInitEvent(eventId, eventStatus); /** @req DEM168 */\r
1777                         }\r
1778                         break;\r
1779 \r
1780                 case DEM_INITIALIZED:\r
1781                         (void)handleEvent(eventId, eventStatus);        /** @req DEM167 */\r
1782                         break;\r
1783 \r
1784                 case DEM_UNINITIALIZED:\r
1785                 default:\r
1786                         // Uninitialized can not do anything\r
1787 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
1788                         Det_ReportError(MODULE_ID_DEM, 0, DEM_REPORTERRORSTATUS_ID, DEM_E_UNINIT); /** @req DEM124.ReportErrorStatus */ /** @req DEM364 */ /** @req DEM117 */\r
1789 #endif\r
1790                         break;\r
1791 \r
1792         } // switch (demState)\r
1793 }\r
1794 \r
1795 /*********************************\r
1796  * Interface DCM <-> DEM (8.3.5) *\r
1797  *********************************/\r
1798 /*\r
1799  * Procedure:   Dem_GetDTCStatusAvailabilityMask\r
1800  * Reentrant:   No\r
1801  */\r
1802 Std_ReturnType Dem_GetDTCStatusAvailabilityMask(uint8 *dtcStatusMask) /** @req DEM014 */\r
1803 {\r
1804         *dtcStatusMask =        DEM_DTC_STATUS_AVAILABILITY_MASK;               // User configuration mask\r
1805         *dtcStatusMask &=       DEM_TEST_FAILED                                                 // Mask with supported bits /** @req DEM060 */\r
1806                                                 | DEM_TEST_FAILED_THIS_OPERATION_CYCLE\r
1807                                                 | DEM_PENDING_DTC\r
1808 //                                              | DEM_CONFIRMED_DTC                                     TODO: Add support for this bit\r
1809                                                 | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR\r
1810                                                 | DEM_TEST_FAILED_SINCE_LAST_CLEAR\r
1811                                                 | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE\r
1812 //                                              | DEM_WARNING_INDICATOR_REQUESTED       TODO: Add support for this bit\r
1813                                                 ;\r
1814 \r
1815         return E_OK;\r
1816 }\r
1817 \r
1818 \r
1819 /*\r
1820  * Procedure:   Dem_SetDTCFilter\r
1821  * Reentrant:   No\r
1822  */\r
1823 Dem_ReturnSetDTCFilterType Dem_SetDTCFilter(uint8 dtcStatusMask,\r
1824                 Dem_DTCKindType dtcKind,\r
1825                 Dem_DTCOriginType dtcOrigin,\r
1826                 Dem_FilterWithSeverityType filterWithSeverity,\r
1827                 Dem_DTCSeverityType dtcSeverityMask,\r
1828                 Dem_FilterForFDCType filterForFaultDetectionCounter) {\r
1829 \r
1830         Dem_ReturnSetDTCFilterType returnCode = DEM_WRONG_FILTER;\r
1831 \r
1832         // Check dtcKind parameter\r
1833         if ((dtcKind == DEM_DTC_KIND_ALL_DTCS) || (dtcKind ==  DEM_DTC_KIND_EMISSION_REL_DTCS)) {\r
1834 \r
1835                 // Check dtcOrigin parameter\r
1836                 if ((dtcOrigin == DEM_DTC_ORIGIN_SECONDARY_MEMORY) || (dtcOrigin == DEM_DTC_ORIGIN_PRIMARY_MEMORY)\r
1837                         || (dtcOrigin == DEM_DTC_ORIGIN_PERMANENT_MEMORY) || (dtcOrigin == DEM_DTC_ORIGIN_MIRROR_MEMORY)) {\r
1838 \r
1839                         // Check filterWithSeverity and dtcSeverityMask parameter\r
1840                         if ((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_NO)\r
1841                                 || ((filterWithSeverity == DEM_FILTER_WITH_SEVERITY_YES) && !(dtcSeverityMask & ~(DEM_SEVERITY_MAINTENANCE_ONLY | DEM_SEVERITY_CHECK_AT_NEXT_FALT | DEM_SEVERITY_CHECK_IMMEDIATELY)))){\r
1842 \r
1843                                 // Check filterForFaultDetectionCounter parameter\r
1844                                 if ((filterForFaultDetectionCounter == DEM_FILTER_FOR_FDC_YES) || (filterForFaultDetectionCounter ==  DEM_FILTER_FOR_FDC_NO)) {\r
1845                                         // Yes all parameters correct, set the new filters.  /** @req DEM057 */\r
1846                                         dtcFilter.dtcStatusMask = dtcStatusMask;\r
1847                                         dtcFilter.dtcKind = dtcKind;\r
1848                                         dtcFilter.dtcOrigin = dtcOrigin;\r
1849                                         dtcFilter.filterWithSeverity = filterWithSeverity;\r
1850                                         dtcFilter.dtcSeverityMask = dtcSeverityMask;\r
1851                                         dtcFilter.filterForFaultDetectionCounter = filterForFaultDetectionCounter;\r
1852                                         dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
1853                                         returnCode = DEM_FILTER_ACCEPTED;\r
1854                                 }\r
1855                         }\r
1856                 }\r
1857         }\r
1858 \r
1859         return returnCode;\r
1860 }\r
1861 \r
1862 \r
1863 /*\r
1864  * Procedure:   Dem_GetStatusOfDTC\r
1865  * Reentrant:   No\r
1866  */\r
1867 Dem_ReturnGetStatusOfDTCType Dem_GetStatusOfDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, Dem_EventStatusExtendedType* status) {\r
1868         Dem_ReturnGetStatusOfDTCType returnCode = DEM_STATUS_FAILED;\r
1869         EventStatusRecType *eventRec;\r
1870 \r
1871         if (lookupDtcEvent(dtc, &eventRec)) {\r
1872                 if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
1873                         if (checkDtcOrigin(dtcOrigin,eventRec->eventParamRef)) {\r
1874                                 *status = eventRec->eventStatusExtended; /** @req DEM059 */\r
1875                                 returnCode = DEM_STATUS_OK;\r
1876                         }\r
1877                         else {\r
1878                                 returnCode = DEM_STATUS_WRONG_DTCORIGIN; /** @req DEM171 */\r
1879                         }\r
1880                 }\r
1881                 else {\r
1882                         returnCode = DEM_STATUS_WRONG_DTCKIND;\r
1883                 }\r
1884         }\r
1885         else {\r
1886                 returnCode = DEM_STATUS_WRONG_DTC; /** @req DEM172 */\r
1887         }\r
1888 \r
1889         return returnCode;\r
1890 }\r
1891 \r
1892 \r
1893 /*\r
1894  * Procedure:   Dem_GetNumberOfFilteredDtc\r
1895  * Reentrant:   No\r
1896  */\r
1897 Dem_ReturnGetNumberOfFilteredDTCType Dem_GetNumberOfFilteredDtc(uint16 *numberOfFilteredDTC) {\r
1898         uint16 i;\r
1899         uint16 numberOfFaults = 0;\r
1900 \r
1901         //Dem_DisableEventStatusUpdate();\r
1902 \r
1903         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1904                 if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
1905                         if (matchEventWithDtcFilter(&eventStatusBuffer[i])) {\r
1906                                 if (eventStatusBuffer[i].eventParamRef->DTCClassRef != NULL) {\r
1907                                         numberOfFaults++;\r
1908                                 }\r
1909                         }\r
1910                 }\r
1911         }\r
1912 \r
1913         //Dem_EnableEventStatusUpdate();\r
1914 \r
1915         *numberOfFilteredDTC = numberOfFaults; /** @req DEM061 */\r
1916 \r
1917         return DEM_NUMBER_OK;\r
1918 }\r
1919 \r
1920 \r
1921 /*\r
1922  * Procedure:   Dem_GetNextFilteredDTC\r
1923  * Reentrant:   No\r
1924  */\r
1925 Dem_ReturnGetNextFilteredDTCType Dem_GetNextFilteredDTC(uint32 *dtc, Dem_EventStatusExtendedType *dtcStatus)\r
1926 {\r
1927         Dem_ReturnGetNextFilteredDTCType returnCode = DEM_FILTERED_OK;\r
1928         boolean dtcFound = FALSE;\r
1929 \r
1930         // TODO: This job should be done in an more advanced way according to Dem217\r
1931         while (!dtcFound && (dtcFilter.faultIndex != 0)) {\r
1932                 dtcFilter.faultIndex--;\r
1933                 if (eventStatusBuffer[dtcFilter.faultIndex].eventId != DEM_EVENT_ID_NULL) {\r
1934                         if (matchEventWithDtcFilter(&eventStatusBuffer[dtcFilter.faultIndex])) {\r
1935                                 if (eventStatusBuffer[dtcFilter.faultIndex].eventParamRef->DTCClassRef != NULL) {\r
1936                                         *dtc = eventStatusBuffer[dtcFilter.faultIndex].eventParamRef->DTCClassRef->DTC; /** @req DEM216 */\r
1937                                         *dtcStatus = eventStatusBuffer[dtcFilter.faultIndex].eventStatusExtended;\r
1938                                         dtcFound = TRUE;\r
1939                                 }\r
1940                         }\r
1941                 }\r
1942         }\r
1943 \r
1944         if (!dtcFound) {\r
1945                 dtcFilter.faultIndex = DEM_MAX_NUMBER_EVENT;\r
1946                 returnCode = DEM_FILTERED_NO_MATCHING_DTC;\r
1947         }\r
1948 \r
1949         return returnCode;\r
1950 }\r
1951 \r
1952 \r
1953 /*\r
1954  * Procedure:   Dem_GetTranslationType\r
1955  * Reentrant:   No\r
1956  */\r
1957 Dem_ReturnTypeOfDtcSupportedType Dem_GetTranslationType(void)\r
1958 {\r
1959         return DEM_TYPE_OF_DTC_SUPPORTED; /** @req DEM231 */\r
1960 }\r
1961 \r
1962 \r
1963 /*\r
1964  * Procedure:   Dem_ClearDTC\r
1965  * Reentrant:   No\r
1966  */\r
1967 Dem_ReturnClearDTCType Dem_ClearDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin) /** @req DEM009 */\r
1968 {\r
1969         Dem_ReturnClearDTCType returnCode = DEM_CLEAR_OK;\r
1970         Dem_EventIdType eventId;\r
1971         const Dem_EventParameterType *eventParam;\r
1972         uint16 i, j;\r
1973 \r
1974         // Loop through the event buffer\r
1975         for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
1976                 eventId = eventStatusBuffer[i].eventId;\r
1977                 if (eventId != DEM_EVENT_ID_NULL) {\r
1978                         eventParam = eventStatusBuffer[i].eventParamRef;\r
1979                         if (eventParam != NULL) {\r
1980                                 if (DEM_CLEAR_ALL_EVENTS | (eventParam->DTCClassRef != NULL)) {\r
1981                                         if (checkDtcKind(dtcKind, eventParam)) {\r
1982                                                 if (checkDtcGroup(dtc, eventParam)) {\r
1983                                                         for (j = 0; (j < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[j] != dtcOrigin); j++);\r
1984                                                         if (j < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
1985                                                                 // Yes! All conditions met.\r
1986                                                                 switch (dtcOrigin)\r
1987                                                                 {\r
1988                                                                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
1989                                                                         /** @req DEM077 */\r
1990                                                                         deleteEventPriMem(eventParam);\r
1991                                                                         deleteFreezeFrameDataPriMem(eventParam);\r
1992                                                                         deleteExtendedDataPriMem(eventParam);\r
1993                                                                         deleteEventStatusRec(eventParam);               // TODO: Shall this be done or just resetting the status?\r
1994                                                                         break;\r
1995 \r
1996                                                                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
1997                                                                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
1998                                                                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
1999                                                                         // Not yet supported\r
2000                                                                         returnCode = DEM_CLEAR_WRONG_DTCORIGIN;\r
2001 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
2002                                                                         Det_ReportError(MODULE_ID_DEM, 0, DEM_CLEARDTC_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
2003 #endif\r
2004                                                                         break;\r
2005                                                                 default:\r
2006                                                                         returnCode = DEM_CLEAR_WRONG_DTCORIGIN;\r
2007                                                                         break;\r
2008                                                                 }\r
2009                                                         }\r
2010                                                 }\r
2011                                         }\r
2012                                 }\r
2013                         }\r
2014                         else {\r
2015                                 // Fatal error, no event parameters found for the stored event!\r
2016 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
2017                         Det_ReportError(MODULE_ID_DEM, 0, DEM_CLEARDTC_ID, DEM_E_UNEXPECTED_EXECUTION); /** @req DEM117 */\r
2018 #endif\r
2019                         }\r
2020                 }\r
2021         }\r
2022 \r
2023         return returnCode;\r
2024 }\r
2025 \r
2026 \r
2027 /*\r
2028  * Procedure:   Dem_DisableDTCStorage\r
2029  * Reentrant:   No\r
2030  */\r
2031 Dem_ReturnControlDTCStorageType Dem_DisableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind) /** @req DEM035 */\r
2032 {\r
2033         Dem_ReturnControlDTCStorageType returnCode = DEM_CONTROL_DTC_STORAGE_N_OK;\r
2034 \r
2035         // Check dtcGroup parameter\r
2036         if (dtcGroup == DEM_DTC_GROUP_ALL_DTCS) {\r
2037                 // Check dtcKind parameter\r
2038                 if ((dtcKind == DEM_DTC_KIND_ALL_DTCS) || (dtcKind ==  DEM_DTC_KIND_EMISSION_REL_DTCS)) {\r
2039                         /** @req DEM079 */\r
2040                         disableDtcStorage.dtcGroup = dtcGroup;\r
2041                         disableDtcStorage.dtcKind = dtcKind;\r
2042                         disableDtcStorage.storageDisabled = TRUE;\r
2043 \r
2044                         returnCode = DEM_CONTROL_DTC_STORAGE_OK;\r
2045                 }\r
2046         }\r
2047         else {\r
2048                 returnCode = DEM_CONTROL_DTC_WRONG_DTCGROUP;\r
2049         }\r
2050 \r
2051         return returnCode;\r
2052 }\r
2053 \r
2054 \r
2055 /*\r
2056  * Procedure:   Dem_EnableDTCStorage\r
2057  * Reentrant:   No\r
2058  */\r
2059 Dem_ReturnControlDTCStorageType Dem_EnableDTCStorage(Dem_DTCGroupType dtcGroup, Dem_DTCKindType dtcKind)\r
2060 {\r
2061         // TODO: Behavior is not defined if group or kind do not match active settings, therefore the filter is just switched off.\r
2062         disableDtcStorage.storageDisabled = FALSE; /** @req DEM080 */\r
2063 \r
2064         return DEM_CONTROL_DTC_STORAGE_OK;\r
2065 }\r
2066 \r
2067 /*\r
2068  * Procedure:   Dem_GetExtendedDataRecordByDTC\r
2069  * Reentrant:   No\r
2070  */\r
2071 Dem_ReturnGetExtendedDataRecordByDTCType Dem_GetExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint8 *destBuffer, uint8 *bufSize)\r
2072 {\r
2073         Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_RECORD_WRONG_DTC;\r
2074         EventStatusRecType *eventRec;\r
2075         Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
2076         ExtDataRecType *extData;\r
2077         uint8 posInExtData = 0;\r
2078 \r
2079         if (lookupDtcEvent(dtc, &eventRec)) {\r
2080                 if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
2081                         if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
2082                                 if (lookupExtendedDataRecNumParam(extendedDataNumber, eventRec->eventParamRef, &extendedDataRecordClass, &posInExtData)) {\r
2083                                         if (*bufSize >= extendedDataRecordClass->DataSize) {\r
2084                                                 switch (dtcOrigin)\r
2085                                                 {\r
2086                                                 case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
2087                                                         if (lookupExtendedDataPriMem(eventRec->eventId, &extData)) {\r
2088                                                                 // Yes all conditions met, copy the extended data record to destination buffer.\r
2089                                                                 memcpy(destBuffer, &extData->data[posInExtData], extendedDataRecordClass->DataSize); /** @req DEM075 */\r
2090                                                                 *bufSize = extendedDataRecordClass->DataSize;\r
2091                                                                 returnCode = DEM_RECORD_OK;\r
2092                                                         }\r
2093                                                         else {\r
2094                                                                 // The record number is legal but no record was found for the DTC\r
2095                                                                 *bufSize = 0;\r
2096                                                                 returnCode = DEM_RECORD_OK;\r
2097                                                         }\r
2098                                                         break;\r
2099 \r
2100                                                 case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
2101                                                 case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
2102                                                 case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
2103                                                         // Not yet supported\r
2104                                                         returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
2105 #if (DEM_DEV_ERROR_DETECT == STD_ON)\r
2106                                                         Det_ReportError(MODULE_ID_DEM, 0, DEM_GETEXTENDEDDATARECORDBYDTC_ID, DEM_E_NOT_IMPLEMENTED_YET); /** @req DEM117 */\r
2107 #endif\r
2108                                                         break;\r
2109                                                 default:\r
2110                                                         returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
2111                                                         break;\r
2112                                                 }\r
2113                                         }\r
2114                                         else {\r
2115                                                 returnCode = DEM_RECORD_BUFFERSIZE;\r
2116                                         }\r
2117                                 }\r
2118                                 else {\r
2119                                         returnCode = DEM_RECORD_NUMBER;\r
2120                                 }\r
2121                         }\r
2122                         else {\r
2123                                 returnCode = DEM_RECORD_WRONG_DTCORIGIN;\r
2124                         }\r
2125                 }\r
2126                 else {\r
2127                         returnCode = DEM_RECORD_DTCKIND;\r
2128                 }\r
2129         }\r
2130 \r
2131         return returnCode;\r
2132 }\r
2133 \r
2134 \r
2135 /*\r
2136  * Procedure:   Dem_GetSizeOfExtendedDataRecordByDTC\r
2137  * Reentrant:   No\r
2138  */\r
2139 Dem_ReturnGetSizeOfExtendedDataRecordByDTCType Dem_GetSizeOfExtendedDataRecordByDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin, uint8 extendedDataNumber, uint16 *sizeOfExtendedDataRecord)\r
2140 {\r
2141         Dem_ReturnGetExtendedDataRecordByDTCType returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTC;\r
2142         EventStatusRecType *eventRec;\r
2143         Dem_ExtendedDataRecordClassType const *extendedDataRecordClass = NULL;\r
2144         uint8 posInExtData;\r
2145 \r
2146         if (lookupDtcEvent(dtc, &eventRec)) {\r
2147                 if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
2148                         if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
2149                                 if (lookupExtendedDataRecNumParam(extendedDataNumber, eventRec->eventParamRef, &extendedDataRecordClass, &posInExtData)) {\r
2150                                         *sizeOfExtendedDataRecord = extendedDataRecordClass->DataSize; /** @req DEM076 */\r
2151                                         returnCode = DEM_GET_SIZEOFEDRBYDTC_OK;\r
2152                                 }\r
2153                                 else {\r
2154                                         returnCode = DEM_GET_SIZEOFEDRBYDTC_W_RNUM;\r
2155                                 }\r
2156                         }\r
2157                         else {\r
2158                                 returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTCOR;\r
2159                         }\r
2160                 }\r
2161                 else {\r
2162                         returnCode = DEM_GET_SIZEOFEDRBYDTC_W_DTCKI;\r
2163                 }\r
2164         }\r
2165 \r
2166         return returnCode;\r
2167 }\r
2168 \r
2169 /***********************************\r
2170  * OBD-specific Interfaces (8.3.6) *\r
2171  ***********************************/\r
2172 \r
2173 \r
2174 \r