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