diagnostic/Dem/Dem.c

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