/*  BEGIN_FILE_HDR
********************************************************************************
*   NOTICE
*   This software is the property of HiRain Technologies. Any information
*   contained in this doc should not be reproduced, or used, or disclosed
*   without the written authorization from HiRain Technologies.
********************************************************************************
*   File Name       : Dcm_OBD.c
********************************************************************************
*   Project/Product : AUTOSAR R21-11
*   Title           : Dcm_OBD.c
*   Author          : Hirain
********************************************************************************
*   Description: Main source file of the AUTOSAR Diagnositc communcation manager,
*                according to AUTOSAR_SWS_DiagnosticCommunicationManager.pdf
*                (Release R21-11) and SAE J1979.
*
********************************************************************************
*   Limitations: None
*
********************************************************************************
*
********************************************************************************
*   Revision History:
*   Reference to Dcm.c File
********************************************************************************
* END_FILE_HDR*/

/*PRQA S 553 EOF*/
/*
When DCM_OBD_SUPPORT is STD_ON, the code is not empty.
*/

/*PRQA S 857 EOF*/

/*PRQA S 3614,3214,862 EOF*/
/*
According to the requirements of AUTOSAR Specification,when locating address
segments in the files of each module,#include "Dcm_MemMap.h" is required.Defined
XXX_START_SEC_ will undefine in Dcm_MemMap.h
*/

/*******************************************************************************
* Includes
*******************************************************************************/
#include "Dcm.h"
#include "Dcm_OBD.h"
#include "Dcm_Lcfg.h"
#if(DCM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD)
#include "Dcm_PBcfg.h"
#endif
#if(STD_ON == DCM_DEM_SUPPORT)
#include "Dem.h"
#include "Dem_Dcm.h"
#endif

/*******************************************************************************
*   Macro
*******************************************************************************/
#if(STD_ON == DCM_OBD_SUPPORT)
/*Used by OBD services start*/
#define DCM_OBD_AVAILABILITY_PARAMETER         (uint8)0x20
/*Used by OBD services end*/
#endif

/*For OBD services*/
#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON))
#define DCM_CFG_PID_ID(i)                      (Dcm_DspPidTable[i].DcmDspPidIdentifier)
#define DCM_CFG_PID_SERVICE(i)                 (Dcm_DspPidTable[i].DcmDspPidService)
#define DCM_CFG_PID_SIZE(i)                    (Dcm_DspPidTable[i].DcmDspPidSize)
#if(DCM_CONFIG_VARIANTS != STD_CONFIG_VARIANTS_POSTBUILD)
#define DCM_CFG_PID_USED(i)                    (Dcm_DspPidTable[i].DcmDspPidUsed)
#endif
#define DCM_CFG_PID_DATA_NUM(i)                (Dcm_DspPidTable[i].NumOfPidData)
#define DCM_CFG_PID_DATA(i)                    (Dcm_DspPidTable[i].DcmDspPidData)
#define DCM_CFG_PID_DATA_OFFSET(i,j)           (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidByteOffset)
#define DCM_CFG_PID_DATA_SIZE(i,j)             (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidDataByteSize)
#define DCM_CFG_PID_DATA_SUPPORTINFO(i,j)      (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidDataSupportInfo)

#if(DCM_OBD_01_ENABLED == STD_ON)
#define DCM_CFG_PID_DATA_SERVICE01(i,j)        (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidService01)
#define DCM_CFG_PID_DATA_SERVICE01_ENDIAN(i,j) (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidService01->DcmDspPidDataEndianness)
#define DCM_CFG_PID_DATA_SERVICE01_FNC(i,j)    (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidService01->DcmDspPidDataReadFnc)
#define DCM_CFG_PID_DATA_SERVICE01_TYPE(i,j)   (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidService01->DcmDspPidDataType)
#define DCM_CFG_PID_DATA_SERVICE01_PORT(i,j)   (Dcm_DspPidTable[i].DcmDspPidData[j].DcmDspPidService01->DcmDspPidDataUsePort)
#endif

#define DCM_CFG_PID_SUPPORTINFO_NUM(i)         (Dcm_DspPidTable[i].NumOfPidSupportInfo)
#define DCM_CFG_PID_SUPPORTINFO(i)             (Dcm_DspPidTable[i].DcmDspPidSupportInfo)
#endif/*#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON))*/


#if(DCM_OBD_08_ENABLED == STD_ON)
#define DCM_CFG_TID_CONTROL_IN_SIZE(i)         (Dcm_DspRequestControlTable[i].DcmDspRequestControlInBufferSize)
#define DCM_CFG_TID_CONTROL_OUT_SIZE(i)        (Dcm_DspRequestControlTable[i].DcmDspRequestControlOutBufferSize)
#define DCM_CFG_TID_CONTROL_TEST_ID(i)         (Dcm_DspRequestControlTable[i].DcmDspRequestControlTestId)
#define DCM_CFG_TID_CONTROL_FNC(i)             (Dcm_DspRequestControlTable[i].DcmDspRequestControlFunction)
#endif/*#if(DCM_OBD_08_ENABLED == STD_ON)*/


#if(DCM_OBD_09_ENABLED == STD_ON)
#define DCM_CFG_INFOTYPE_ID(i)                 (Dcm_DspVehInfoTable[i].DcmDspVehInfoInfoType)
#define DCM_CFG_INFOTYPE_NOD_PRO(i)            (Dcm_DspVehInfoTable[i].DcmDspVehInfoNODIProvResp)
#define DCM_CFG_INFOTYPE_DATA_NUM(i)           (Dcm_DspVehInfoTable[i].NumOfVehInfoData)
#define DCM_CFG_INFOTYPE_DATA(i)               (Dcm_DspVehInfoTable[i].DcmDspVehInfoData)
#define DCM_CFG_INFOTYPE_DATA_ORDER(i,j)       (Dcm_DspVehInfoTable[i].DcmDspVehInfoData[j].DcmDspVehInfoDataOrder)
#define DCM_CFG_INFOTYPE_DATA_FNC(i,j)         (Dcm_DspVehInfoTable[i].DcmDspVehInfoData[j].DcmDspVehInfoDataReadFnc)
#define DCM_CFG_INFOTYPE_DATA_SIZE(i,j)        (Dcm_DspVehInfoTable[i].DcmDspVehInfoData[j].DcmDspVehInfoDataSize)
#define DCM_CFG_INFOTYPE_DATA_PORT(i,j)        (Dcm_DspVehInfoTable[i].DcmDspVehInfoData[j].DcmDspVehInfoDataUsePort)
#endif/*#if(DCM_OBD_09_ENABLED == STD_ON)*/


/******************************************************************************
*   static Vars
******************************************************************************/
#define DCM_START_SEC_VAR_NOINIT_8
#include "Dcm_MemMap.h"
#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON) || (DCM_OBD_08_ENABLED == STD_ON) || (DCM_OBD_09_ENABLED == STD_ON))
STATIC VAR(uint8, DCM_VAR) Dcm_OBDServiceReqData[7];
#endif

/*The following four array parameters are assigned during initialization*/
#if(DCM_OBD_01_ENABLED == STD_ON)
STATIC VAR(uint8, DCM_VAR) Dcm_OBDService01_AvailPID[8][4];
#endif
#if(DCM_OBD_02_ENABLED == STD_ON)
STATIC VAR(uint8, DCM_VAR) Dcm_OBDService02_AvailPID[8][4];
#endif
#if(DCM_OBD_08_ENABLED == STD_ON)
STATIC VAR(uint8, DCM_VAR) Dcm_OBDService08_AvailTID[8][4];/*Be assigned in Dcm_Init() function*/
#endif
#if(DCM_OBD_09_ENABLED == STD_ON)
STATIC VAR(uint8, DCM_VAR) Dcm_OBDService09_AvailInfoType[8][4];/*Be assigned in Dcm_Init() function*/

STATIC VAR(uint8, DCM_VAR) Dcm_OBDInfoTypeIndex;
STATIC VAR(uint8, DCM_VAR) Dcm_OBDInfoTypeDataIndex;
#endif

#if((DCM_OBD_03_ENABLED == STD_ON) || (DCM_OBD_07_ENABLED == STD_ON) || (DCM_OBD_0A_ENABLED == STD_ON))
STATIC VAR(uint8, DCM_VAR) Dcm_OBDDtcCounter;
#endif
#define DCM_START_SEC_VAR_NOINIT_8
#include "Dcm_MemMap.h"


/*******************************************************************************
*   Macro of Vars
*******************************************************************************/
#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON) || (DCM_OBD_08_ENABLED == STD_ON) || (DCM_OBD_09_ENABLED == STD_ON))
#define DCM_OBD_REQ_DATA(idx)                    (Dcm_OBDServiceReqData[idx])
#endif
#if(DCM_OBD_01_ENABLED == STD_ON)
#define DCM_OBD_01_AVAIL_PID(RowIdx, Idx)        (Dcm_OBDService01_AvailPID[RowIdx][Idx])
#endif
#if(DCM_OBD_02_ENABLED == STD_ON)
#define DCM_OBD_02_AVAIL_PID(RowIdx, Idx)        (Dcm_OBDService02_AvailPID[RowIdx][Idx])
#endif
#if(DCM_OBD_08_ENABLED == STD_ON)
#define DCM_OBD_08_AVAIL_TID(RowIdx, Idx)        (Dcm_OBDService08_AvailTID[RowIdx][Idx])
#endif
#if(DCM_OBD_09_ENABLED == STD_ON) 
#define DCM_OBD_09_AVAIL_INFO(RowIdx, Idx)       (Dcm_OBDService09_AvailInfoType[RowIdx][Idx])

#define DCM_OBD_INFOTYPE_INDEX                   (Dcm_OBDInfoTypeIndex)
#define DCM_OBD_INFOTYPE_DATA_INDEX              (Dcm_OBDInfoTypeDataIndex)
#endif
#if((DCM_OBD_03_ENABLED == STD_ON) || (DCM_OBD_07_ENABLED == STD_ON) || (DCM_OBD_0A_ENABLED == STD_ON))
#define DCM_OBD_DTC_COUNTER                      (Dcm_OBDDtcCounter)
#endif



/*******************************************************************************
* Declarations and definitions of Internal interfaces
*******************************************************************************/
#define DCM_START_SEC_CODE
#include "Dcm_MemMap.h"

#if(DCM_OBD_SUPPORT == STD_ON)
STATIC FUNC(void, DCM_CODE) DsdInternal_OBD_ReqErrorReset
(
    void
);
#endif

#if(DCM_OBD_01_ENABLED == STD_ON)
STATIC FUNC(Std_ReturnType, DCM_CODE) DspInternal_01_ReadPidData
(
    uint8 ReqPID,
    uint8 *DataBuffer,
    uint32 *Length
);
#endif

#if(DCM_OBD_02_ENABLED == STD_ON)
STATIC FUNC(Std_ReturnType, DCM_CODE) DspInternal_02_ReadPidData
(
    uint8 ReqPID,
    uint8 ReqFrame,
    uint8 *DataBuffer,
    uint32 *Length
);
#endif

#if(DCM_OBD_09_ENABLED == STD_ON)
STATIC FUNC(Std_ReturnType, DCM_CODE) DspInternal_09_ReadInfoTypeData
(
    Dcm_OpStatusType OpStatus,
    uint8 *DataBuffer,
    uint8 *Length
);
#endif


#if(DCM_OBD_SUPPORT == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DsdInternal_OBD_ReqErrorReset
*
* Description: This function is used by OBD services to reset Dcm state when
*              there is something wrong in request data.
*
* Inputs: None
*
* Outputs: None
*
* Return: None
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(void, DCM_CODE) DsdInternal_OBD_ReqErrorReset
(
    void
)
{
    /*Start S3 Timer*/
    if(DCM_SESSION_IDX != DCM_DEFAULT_IDX)
    {
        SetS3Timer(DCM_CFG_PCL_S3SERVER(DCM_ACTIVE_PCL_ID));
    }
    else
    {
        COMM_DCM_INACTIVEDIAGNOSTIC(DCM_ACTIVE_PCL_ID, DCM_ACTIVE_CONNECTION_ID);
    }

    DcmInternal_InitMsgContext();
    ClearP2Timer();
    ClearRespPendCounter();
    ResetDcmState();
}
#endif


#if(DCM_OBD_01_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_01_ReadPidData
*
* Description: Read the data of one PID.
*
* Inputs: ReqPID
*
* Outputs: DataBuffer, Length
*
* Return: Std_ReturnType
*
* Limitations: Only used by 01 services
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_01_ReadPidData
(
    uint8 ReqPID,
    uint8 *DataBuffer,
    uint32 *Length
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 BytePos;

    for(i = (uint8)0; i < DCM_CFG_PID_NUM; i++)
    {
        if((DCM_CFG_PID_ID(i) == ReqPID) && (DCM_CFG_PID_USED(i) == TRUE) \
            && (DCM_CFG_PID_SERVICE(i) != DCM_SERVICE_02))
        {
            if(*Length <  DCM_CFG_PID_SIZE(i))
            {
                Result = E_NOT_OK;
            }
            else
            {
                *Length = DCM_CFG_PID_SIZE(i);
                for(j = (uint8)0; j < (*Length); j++)
                {
                    /*SWS_Dcm_00623*//*SWS_Dcm_00944*/
                    DataBuffer[j] = DCM_DATA_CLEAR;
                }
                /*Read the data value of the PID.*/
                for(j = (uint8)0; j < DCM_CFG_PID_DATA_NUM(i); j++)
                {
                    if(DCM_CFG_PID_DATA_SERVICE01(i,j) != NULL_PTR)
                    {
                        BytePos = (uint8)(DCM_CFG_PID_DATA_POS(i,j)>>3U);
                        /*SWS_Dcm_00408*/
                        Result = (*DCM_CFG_PID_DATA_SERVICE01_FNC(i,j))((DataBuffer + BytePos));
                        if(Result != E_OK)
                        {
                            Result = E_NOT_OK;
                            break;/*for(j = 0; j < DCM_CFG_PID_DATA_NUM(i); j++)*/
                        }
                    }
                }/*for(j = 0; j < DCM_CFG_PID_DATA_NUM(i); j++)*/
            }/*if(*Length <  DCM_CFG_PID_SIZE(i))*/

            break;/*for(i = 0; i < DCM_CFG_PID_NUM; i++)*/
        }
    }

    if(i == DCM_CFG_PID_NUM)
    {
        /*It means that the ReqPID is not supported in the ECU.*/
        *Length = (uint32)0;
    }
    return Result;
}
#endif

#if(DCM_OBD_02_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_02_ReadPidData
*
* Description: Read the data of one PID.
*
* Inputs: ReqPID, ReqFrame
*
* Outputs: DataBuffer, Length
*
* Return: Std_ReturnType
*
* Limitations: Only used by 02 services
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_02_ReadPidData
(
    uint8 ReqPID,
    uint8 ReqFrame,
    uint8 *DataBuffer,
    uint32 *Length
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 BytePos;
    uint16 DemDataLength;/*Temporarily no effect*/
#if(DCM_DEM_SUPPORT == STD_ON)
    uint32 Dtc = 0;
#endif

    for(i = (uint8)0; i < DCM_CFG_PID_NUM; i++)
    {
        if((DCM_CFG_PID_ID(i) == ReqPID) && (DCM_CFG_PID_USED(i) == TRUE) \
            && (DCM_CFG_PID_SERVICE(i) != DCM_SERVICE_01))
        {
            if(*Length <  DCM_CFG_PID_SIZE(i))
            {
                Result = E_NOT_OK;
            }
            else
            {
                *Length = DCM_CFG_PID_SIZE(i);
                DemDataLength = DCM_CFG_PID_SIZE(i);

                for(j = (uint8)0; j < (*Length); j++)
                {
                    /*SWS_Dcm_00973*//*SWS_Dcm_00974*/
                    DataBuffer[j] = DCM_DATA_CLEAR;
                }

#if(DCM_DEM_SUPPORT == STD_ON)
                /*Read the data value of the PID.*/
                if(ReqPID == (uint8)0x02)
                {
                    /*SWS_Dcm_00279*//*Special PID need processed specially.*/
                    Result = Dem_DcmGetDTCOfOBDFreezeFrame(ReqFrame, &Dtc, DEM_DTC_FORMAT_OBD);
                    if(Result == E_OK)
                    {
                        DataBuffer[0] = (uint8)(Dtc>>8);
                        DataBuffer[1] = (uint8)Dtc;
                    }
                    else
                    {
                        Result = E_OK;
                        /*SWS_Dcm_01061*/
                    }
                }
                else/*(ReqPID != (uint8)0x02)*/
#endif/*#if(DCM_DEM_SUPPORT == STD_ON)*/
                {
                    for(j = (uint8)0; j < DCM_CFG_PID_DATA_NUM(i); j++)
                    {
                        BytePos = (uint8)(DCM_CFG_PID_DATA_POS(i,j)>>3U);
                        /*SWS_Dcm_00286*/
#if(DCM_DEM_SUPPORT == STD_ON)
                        Result = Dem_DcmReadDataOfOBDFreezeFrame(ReqPID, j, \
                                    (DataBuffer + BytePos), &DemDataLength);
#else
                        Result = Dcm_Rte_OBD_ReadDataOfOBDFreezeFrame(ReqPID, j, \
                                    (DataBuffer + BytePos), &DemDataLength);
#endif
                        if(Result != E_OK)
                        {
                            Result = E_NOT_OK;
                            break;/*for(j = 0; j < DCM_CFG_PID_DATA_NUM(i); j++)*/
                        }
                    }
                }/*if(ReqPID == (uint8)0x02)*/
            }/*if(*Length <  DCM_CFG_PID_SIZE(i))*/

            break;/*for(i = 0; i < DCM_CFG_PID_NUM; i++)*/
        }
    }

    if(i == DCM_CFG_PID_NUM)
    {
        /*It means that the ReqPID is not supported in the ECU.*/
        *Length = (uint32)0;
    }
    return Result;
}
#endif

#if(DCM_OBD_09_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_09_ReadInfoTypeData
*
* Description: Read the data of one InfoType.
*
* Inputs: OpStatus
*
* Outputs: DataBuffer, Length
*
* Return: Std_ReturnType
*
* Limitations: Only used by 09 services
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_09_ReadInfoTypeData
(
    Dcm_OpStatusType OpStatus,
    uint8 *DataBuffer,
    uint8 *Length
)
{
    Std_ReturnType Result = E_OK;
    uint8 DataOrder;
    uint8 *DataElementBuffer;
    uint8 DataLength;
    EcucFncVehInfoDataReadDef DataReadFnc;

    for( ; DCM_OBD_INFOTYPE_DATA_INDEX < DCM_CFG_INFOTYPE_DATA_NUM(DCM_OBD_INFOTYPE_INDEX); )
    {
        /*SWS_Dcm_00423*/
        DataReadFnc = DCM_CFG_INFOTYPE_DATA_FNC(DCM_OBD_INFOTYPE_INDEX, DCM_OBD_INFOTYPE_DATA_INDEX);
        DataOrder = DCM_CFG_INFOTYPE_DATA_ORDER(DCM_OBD_INFOTYPE_INDEX, DCM_OBD_INFOTYPE_DATA_INDEX);
        DataElementBuffer = (DataBuffer + DataOrder);
        DataLength = (*Length - DataOrder);
        Result = (*DataReadFnc)(OpStatus, DataElementBuffer, &DataLength);

        if(Result != E_OK)
        {
            break;
        }
        else/*Result == E_OK*/
        {
            if(DCM_CFG_INFOTYPE_NOD_PRO(DCM_OBD_INFOTYPE_INDEX) == TRUE)
            {
                /*SWS_Dcm_01167*//*constr_6045: In case the responsibility is on provider side
                (DcmDspVehInfoNODIProvResp is set to TRUE), only one DcmDspVehInfoData container
                shall be allowed.*/
                *Length = (DataOrder + DataLength);
                break;/*for( ; DCM_OBD_INFOTYPE_DATA_INDEX < DCM_CFG_INFOTYPE_DATA_NUM(DCM_OBD_INFOTYPE_INDEX); )*/
            }
            else
            {
                /*SWS_Dcm_00684*/
                if((DCM_OBD_INFOTYPE_DATA_INDEX + (uint8)1) == DCM_CFG_INFOTYPE_DATA_NUM(DCM_OBD_INFOTYPE_INDEX))
                {
                    DataLength = DCM_CFG_INFOTYPE_DATA_SIZE(DCM_OBD_INFOTYPE_INDEX, DCM_OBD_INFOTYPE_DATA_INDEX);
                    *Length = (DataOrder + DataLength);
                }

                DCM_OBD_INFOTYPE_DATA_INDEX++;
            }
        }
    }

    return Result;
}
#endif

#define DCM_STOP_SEC_CODE
#include "Dcm_MemMap.h"


/*******************************************************************************
* Definitions of internal global Function
*******************************************************************************/
#define DCM_START_SEC_CODE
#include "Dcm_MemMap.h"

#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON) || (DCM_OBD_08_ENABLED == STD_ON) || (DCM_OBD_09_ENABLED == STD_ON))
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DcmInternal_Init_AvailabilityParameters
*
* Description: Based on the configured PIDs, TIDs and InfoTypes, initialize and set
*              the data that can be read by 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0
*              and 0xE0 request.
*
* Inputs: None
*
* Outputs: None
*
* Return: None
*
* Limitations: Only used by 01, 02, 08, 09 services.
********************************************************************************
END_FUNCTION_HDR*/
FUNC(void, DCM_CODE) DcmInternal_Init_AvailabilityParameters
(
    void
)
{
    uint16 i;
    uint8 RowPara = 0;
#if(DCM_OBD_01_ENABLED == STD_ON)
    uint8 RowMax_Service01 = 0;
#endif
#if(DCM_OBD_02_ENABLED == STD_ON)
    uint8 RowMax_Service02 = 0;
#endif
#if(DCM_OBD_08_ENABLED == STD_ON)
    uint8 RowMax_Service08 = 0;
#endif
#if(DCM_OBD_09_ENABLED == STD_ON)
    uint8 RowMax_Service09 = 0;
#endif
    uint8 BytePos = 0;
    uint8 BitPos = 0;

    for(RowPara = 0; RowPara < (uint8)8; RowPara++)
    {
        for(i = 0; i < (uint8)4; i++)
        {
#if(DCM_OBD_01_ENABLED == STD_ON)
            DCM_OBD_01_AVAIL_PID(RowPara, i) = (uint8)0;
#endif
#if(DCM_OBD_02_ENABLED == STD_ON)
            DCM_OBD_02_AVAIL_PID(RowPara, i) = (uint8)0;
#endif
#if(DCM_OBD_08_ENABLED == STD_ON)
            DCM_OBD_08_AVAIL_TID(RowPara, i) = (uint8)0;
#endif
#if(DCM_OBD_09_ENABLED == STD_ON)
            DCM_OBD_09_AVAIL_INFO(RowPara, i) = (uint8)0;
#endif
        }
    }

#if((DCM_OBD_01_ENABLED == STD_ON) || (DCM_OBD_02_ENABLED == STD_ON))
    for(i = 0; i < DCM_CFG_PID_NUM; i++)
    {
        if(DCM_CFG_PID_USED(i) == TRUE)
        {
            RowPara = (DCM_CFG_PID_ID(i)/(uint8)0x20);
            BytePos = ((DCM_CFG_PID_ID(i)%(uint8)0x20 - 1)/(uint8)8);
            BitPos = (7 - ((DCM_CFG_PID_ID(i)%(uint8)0x20 - 1)%(uint8)8));

#if(DCM_OBD_01_ENABLED == STD_ON)
            if(DCM_CFG_PID_SERVICE(i) != DCM_SERVICE_02)
            {
                DCM_OBD_01_AVAIL_PID(RowPara, BytePos) |= ((uint8)0x01 << BitPos);
                if(RowMax_Service01 < RowPara)
                {
                    RowMax_Service01 = RowPara;
                }
            }
#endif/*#if(DCM_OBD_01_ENABLED == STD_ON)*/

#if(DCM_OBD_02_ENABLED == STD_ON)
            if(DCM_CFG_PID_SERVICE(i) != DCM_SERVICE_01)
            {
                DCM_OBD_02_AVAIL_PID(RowPara, BytePos) |= ((uint8)0x01 << BitPos);
                if(RowMax_Service02 < RowPara)
                {
                    RowMax_Service02 = RowPara;
                }
            }
#endif/*#if(DCM_OBD_02_ENABLED == STD_ON)*/
        }
    }

#if(DCM_OBD_01_ENABLED == STD_ON)
    for(i = 0; i < RowMax_Service01; i++)
    {
        DCM_OBD_01_AVAIL_PID(i, 3) |= ((uint8)0x01);
    }
#endif/*#if(DCM_OBD_01_ENABLED == STD_ON)*/

#if(DCM_OBD_02_ENABLED == STD_ON)
    for(i = 0; i < RowMax_Service02; i++)
    {
        DCM_OBD_02_AVAIL_PID(i, 3) |= ((uint8)0x01);
    }
#endif/*#if(DCM_OBD_02_ENABLED == STD_ON)*/
#endif/*#if((DCM_OBD_01_ENABLED == STD_ON)||(DCM_OBD_02_ENABLED == STD_ON))*/


#if(DCM_OBD_08_ENABLED == STD_ON)
    for(i = 0; i < DCM_CFG_TID_NUM; i++)
    {
        RowPara = (DCM_CFG_TID_CONTROL_TEST_ID(i)/(uint8)0x20);
        BytePos = ((DCM_CFG_TID_CONTROL_TEST_ID(i)%(uint8)0x20 - 1)/(uint8)8);
        BitPos = (7 - ((DCM_CFG_TID_CONTROL_TEST_ID(i)%(uint8)0x20 - 1)%(uint8)8));

        DCM_OBD_08_AVAIL_TID(RowPara, BytePos) |= ((uint8)0x01 << BitPos);
        if(RowMax_Service08 < RowPara)
        {
            RowMax_Service08 = RowPara;
        }
    }

    for(i = 0; i < RowMax_Service08; i++)
    {
        DCM_OBD_08_AVAIL_TID(i, 3) |= ((uint8)0x01);
    }
#endif/*#if(DCM_OBD_08_ENABLED == STD_ON)*/


#if(DCM_OBD_09_ENABLED == STD_ON)
    for(i = 0; i < DCM_CFG_INFOTYPE_NUM; i++)
    {
        RowPara = (DCM_CFG_INFOTYPE_ID(i)/(uint8)0x20);
        BytePos = ((DCM_CFG_INFOTYPE_ID(i)%(uint8)0x20 - 1)/(uint8)8);
        BitPos = (7 - ((DCM_CFG_INFOTYPE_ID(i)%(uint8)0x20 - 1)%(uint8)8));

        DCM_OBD_09_AVAIL_INFO(RowPara, BytePos) |= ((uint8)0x01 << BitPos);
        if(RowMax_Service09 < RowPara)
        {
            RowMax_Service09 = RowPara;
        }
    }

    for(i = 0; i < RowMax_Service09; i++)
    {
        DCM_OBD_09_AVAIL_INFO(i, 3) |= ((uint8)0x01);
    }
#endif/*#if(DCM_OBD_09_ENABLED == STD_ON)*/
}
#endif

#if(DCM_OBD_01_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_01_RequestCurrentPowertrainDiagnosticData SWS_Dcm_00243
*
* Description: This function is the code implementation of the processing logic
*              for the 0x01 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_01_RequestCurrentPowertrainDiagnosticData
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 RowPara;
    uint8 ReqPID;
    Dcm_MsgLenType DataLength;
    (void)OpStatus;

    if((pMsgContext->reqDataLen) > DCM_REQ_LEGTH_7_BYTE)
    {
        Result = E_NOT_OK;
        /*Reset Dcm, do not send NRC 0x13.*/
        /*DsdInternal_OBD_ReqErrorReset();*/
    }
    else
    {
        /*SWS_Dcm_00943*/
        if(((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
            {
                DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
                if(((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0)
                {
                    Result = E_NOT_OK;
                    /*SWS_Dcm_00943*/
                    /*Reset Dcm, do not send any negative response.*/
                    /*DsdInternal_OBD_ReqErrorReset();*/
                    break;
                }
            }
        }
        else
        {
            for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
            {
                DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
                if(((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
                {
                    Result = E_NOT_OK;
                    /*SWS_Dcm_00943*/
                    /*Reset Dcm, do not send any negative response.*/
                    /*DsdInternal_OBD_ReqErrorReset();*/
                    break;
                }
            }
        }
    }

    if(Result == E_OK)
    {
        if((DCM_OBD_REQ_DATA(0) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            /*SWS_Dcm_00407*//*Request PIDs are availability PIDs.*/
            pMsgContext->resDataLen = (Dcm_MsgLenType)1;

            for(i = 0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)
            {
                RowPara = (DCM_OBD_REQ_DATA(i) / DCM_OBD_AVAILABILITY_PARAMETER);

                if((RowPara == (uint8)0) || ((DCM_OBD_01_AVAIL_PID((RowPara - 1), 3) & (uint8)0x01) != (uint8)0))
                {
                    /*Put the request availability PID in response message buffer.*/
                    pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA(i);
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;

                    for(j = 0; j < (uint8)4; j++)
                    {
                        pMsgContext->resData[pMsgContext->resDataLen + j] = DCM_OBD_01_AVAIL_PID(RowPara, j);
                    }
                    pMsgContext->resDataLen += (Dcm_MsgLenType)4;
                }
            }
        }
        else
        {
            /*One byte PID*/
            pMsgContext->resDataLen = (Dcm_MsgLenType)1;

            for(i = 0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)
            {
                ReqPID = DCM_OBD_REQ_DATA(i);
                /*One byte PID*/
                DataLength = (pMsgContext->resMaxDataLen - pMsgContext->resDataLen - (Dcm_MsgLenType)1);

                Result = DspInternal_01_ReadPidData(ReqPID, \
                        &(pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)1]), &DataLength);
                if((Result == E_OK) && (DataLength != 0))
                {
                    pMsgContext->resData[pMsgContext->resDataLen] = ReqPID;
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;
                    pMsgContext->resDataLen += DataLength;
                }
            }
        }
    }

    if((Result == E_NOT_OK) || (pMsgContext->resDataLen == (Dcm_MsgLenType)1))
    {
        /*if Result equals E_OK and the response length is 1,
        it means that no request PIDs supported in the ECU.*/
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        /*Send positive response.*/
        pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
    }

    return Result;
}
#endif

#if(DCM_OBD_02_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_02_RequestPowertrainFreezeFrameData SWS_Dcm_00244
*
* Description: This function is the code implementation of the processing logic
*              for the 0x02 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_02_RequestPowertrainFreezeFrameData
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 RowPara;
    uint8 ReqPID;
    uint8 ReqFrame;
    Dcm_MsgLenType DataLength;
    (void)OpStatus;

    if(((pMsgContext->reqDataLen) > DCM_REQ_LEGTH_7_BYTE) || (!((pMsgContext->reqDataLen) & 0x01U)))
    {
        Result = E_NOT_OK;
        /*Reset Dcm, do not send NRC 0x13.*/
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        /*Check the validity of request data.*/
        /*SWS_Dcm_00972*//*SWS_Dcm_00409*/
        if(((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i += (uint8)2)
            {
                if((((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0) \
                    || (pMsgContext->reqData[i+(uint8)1] != 0))
                {
                    Result = E_NOT_OK;
                    /*SWS_Dcm_00972*//*SWS_Dcm_00409*/
                    /*Reset Dcm, do not send any negative response.*/
                    /*DsdInternal_OBD_ReqErrorReset();*/
                    break;
                }
            }
        }
        else
        {
            for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i += (uint8)2)
            {
                if((((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0) \
                    || (pMsgContext->reqData[i+(uint8)1] != 0))
                {
                    Result = E_NOT_OK;
                    /*SWS_Dcm_00972*//*SWS_Dcm_00409*/
                    /*Reset Dcm, do not send any negative response.*/
                    /*DsdInternal_OBD_ReqErrorReset();*/
                    break;
                }
            }
        }
    }

    if(Result == E_OK)
    {
        /*Copy the request data into local buffer.*/
        for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
        {
            DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
        }

        /*Calculate the response message.*/
        if((DCM_OBD_REQ_DATA(0) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            /*SWS_Dcm_00284*//*Request PIDs are availability PIDs.*/
            pMsgContext->resDataLen = (Dcm_MsgLenType)1;

            for(i = 0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i += (uint8)2)
            {
                RowPara = (DCM_OBD_REQ_DATA(i) / DCM_OBD_AVAILABILITY_PARAMETER);

                if((RowPara == (uint8)0) || ((DCM_OBD_02_AVAIL_PID((RowPara - 1), 3) & (uint8)0x01) != (uint8)0))
                {
                    /*Put the request availability PID in response message buffer.*/
                    pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA(i);
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;
                    /*Put the request frame number in response message buffer.*/
                    pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA((i + (uint8)1));
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;

                    for(j = 0; j < (uint8)4; j++)
                    {
                        pMsgContext->resData[pMsgContext->resDataLen + j] = DCM_OBD_02_AVAIL_PID(RowPara, j);
                    }
                    pMsgContext->resDataLen += (Dcm_MsgLenType)4;
                }
            }
        }
        else
        {
            /*Request PIDs are not availability PIDs.*/
            pMsgContext->resDataLen = (Dcm_MsgLenType)1;

            for(i = 0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i += (uint8)2)
            {
                ReqPID = DCM_OBD_REQ_DATA(i);
                ReqFrame = DCM_OBD_REQ_DATA((i + (uint8)1]));
                /*One byte PID and one byte frame*/
                DataLength = (pMsgContext->resMaxDataLen - pMsgContext->resDataLen - (Dcm_MsgLenType)2);

                Result = DspInternal_02_ReadPidData(ReqPID, ReqFrame, \
                        &(pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)2]), &DataLength);
                if((Result == E_OK) && (DataLength != 0))
                {
                    /*SWS_Dcm_00287*//*SWS_Dcm_01254*/
                    pMsgContext->resData[pMsgContext->resDataLen] = ReqPID;
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;
                    pMsgContext->resData[pMsgContext->resDataLen] = ReqFrame;
                    pMsgContext->resDataLen += (Dcm_MsgLenType)1;
                    pMsgContext->resDataLen += DataLength;
                }
            }
        }
    }

    /*SWS_Dcm_01252*//*SWS_Dcm_01253*//*SWS_Dcm_01254*/
    if((Result == E_NOT_OK) || (pMsgContext->resDataLen == (Dcm_MsgLenType)1))
    {
        /*if Result equals E_OK and the response length is 1,
        it means that no request PIDs supported in the ECU.*/
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        /*Send positve respnse.*/
        pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
    }

    return Result;
}
#endif


#if((DCM_OBD_03_ENABLED == STD_ON)||(DCM_OBD_07_ENABLED == STD_ON)||(DCM_OBD_0A_ENABLED == STD_ON))
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_03_07_0A_ObtainingDTC SWS_Dcm_00245, SWS_Dcm_00410, SWS_Dcm_00411
*
* Description: This function is the code implementation of the processing logic
*              for the 0x03, 0x07 and 0x0A service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_03_07_0A_ObtainingDTC
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
#if(DCM_DEM_SUPPORT == STD_ON)
    uint32 GetDtc;
    Dem_UdsStatusByteType GetDtcStatus;
#endif

    if(OpStatus == DCM_INITIAL)
    {
        if((pMsgContext->reqDataLen) != (Dcm_MsgLenType)1)
        {
            Result = E_NOT_OK;
            /*Reset Dcm, do not send NRC 0x13.*/
            /*DsdInternal_OBD_ReqErrorReset();*/
        }
        else
        {
            DCM_OBD_DTC_COUNTER = DCM_DATA_CLEAR;
#if(DCM_DEM_SUPPORT == STD_ON)
            if(DCM_REQ_SERVICE == DCM_03_SERVICE)
            {
                /*SWS_Dcm_00289*//*SWS_Dcm_00077*/
                Result = Dem_SetDTCFilter((Dem_UdsStatusByteType)0x08, DEM_DTC_KIND_EMISSION_REL_DTCS, \
                            DEM_DTC_FORMAT_OBD, DEM_DTC_ORIGIN_OBD_RELEVANT_MEMORY, FALSE, DEM_SEVERITY_NO_SEVERITY, FALSE);
            }
            else if(DCM_REQ_SERVICE == DCM_07_SERVICE)
            {
                /*SWS_Dcm_00412*//*SWS_Dcm_00077*/
                Result = Dem_SetDTCFilter((Dem_UdsStatusByteType)0x04, DEM_DTC_KIND_EMISSION_REL_DTCS, \
                            DEM_DTC_FORMAT_OBD, DEM_DTC_ORIGIN_OBD_RELEVANT_MEMORY, FALSE, DEM_SEVERITY_NO_SEVERITY, FALSE);
            }
            else/*(DCM_REQ_SERVICE == DCM_0A_SERVICE)*/
            {
                /*SWS_Dcm_00330*//*SWS_Dcm_00077*/
                Result = Dem_SetDTCFilter((Dem_UdsStatusByteType)0x00, DEM_DTC_KIND_EMISSION_REL_DTCS, \
                            DEM_DTC_FORMAT_OBD, DEM_DTC_ORIGIN_PERMANENT_MEMORY, FALSE, DEM_SEVERITY_NO_SEVERITY, FALSE);
            }

            /*if Result == E_NOT_OK, Reset Dcm, do not send any negative response.*/
#endif
        }/*if((pMsgContext->reqDataLen) != (Dcm_MsgLenType)1)*/
    }/*if(OpStatus == DCM_INITIAL)*/

    if(Result == E_OK)
    {
#if(DCM_DEM_SUPPORT == STD_ON)
        do
        {
            /*SWS_Dcm_01227*//*SWS_Dcm_01228*/
            Result = Dem_GetNextFilteredDTC(&GetDtc, &GetDtcStatus);

            if(Result == E_OK)
            {
                pMsgContext->resData[2U + (DCM_OBD_DTC_COUNTER * 2U)] = (uint8)(GetDtc >> 8U);
                pMsgContext->resData[3U + (DCM_OBD_DTC_COUNTER * 2U)] = (uint8)GetDtc;
                DCM_OBD_DTC_COUNTER++;
            }
            else if(Result == DEM_PENDING)
            {
                /*03/07/0A are not allowed to send 0x78 negtive response.*/
                Result = E_NOT_OK;
            }
            else/*Result == DEM_NO_SUCH_ELEMENT or E_NOT_OK*/
            {
                /*GetNextFilteredDTC is over*/
            }
        } while(Result == E_OK);
#else
        Result = Dcm_Rte_OBD_ObtainingDTC(DCM_REQ_SERVICE, &(pMsgContext->resData[DCM_INDEX_2]), &DCM_OBD_DTC_COUNTER);
#endif
    }

    if(Result == E_OK)
    {
        /*SWS_Dcm_01227*//*SWS_Dcm_01228*//*Send positve respnse.*/
        pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
        pMsgContext->resData[DCM_INDEX_1] = DCM_OBD_DTC_COUNTER;
        pMsgContext->resDataLen = (DCM_INDEX_2 + (DCM_OBD_DTC_COUNTER * 2U));
    }
    else
    {
        /*Reset Dcm*/
        DsdInternal_OBD_ReqErrorReset();
    }

    return Result;
}
#endif

#if(DCM_OBD_04_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_04_ClearEmissionRelatedDiagnosticInformation SWS_Dcm_00246
*
* Description: This function is the code implementation of the processing logic
*              for the 0x04 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_04_ClearEmissionRelatedDiagnosticInformation
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
#if(DCM_DEM_SUPPORT == STD_ON)
    Dem_ReturnClearDTCType ClearResult = DEM_CLEAR_OK;
#endif

    if(OpStatus == DCM_INITIAL)
    {
        if((pMsgContext->reqDataLen) != (Dcm_MsgLenType)1)
        {
            Result = E_NOT_OK;
            /*Reset Dcm, do not send NRC 0x13.*/
            DsdInternal_OBD_ReqErrorReset();
        }
        else
        {
#if(DCM_DEM_SUPPORT == STD_ON)
            /*SWS_Dcm_00004*/
            Result = Dem_SelectDTC(DemClient, DEM_DTC_GROUP_ALL, DEM_DTC_FORMAT_OBD, DEM_DTC_FORMAT_OBD);
            /*Dem_SelectDTC has only two return values: E_OK and DEM_BUSY.*/
            if(Result == DEM_BUSY)
            {
                *pErrorCode = DCM_E_CONDITIONSNOTCORRECT;
#if(DCM_CAR_PLATFORM == DCM_SAIC_PLATFORM)
                Dcm_SetNRC22Reason(DCM_NRC22_REASON_4);
#endif
                Result = E_NOT_OK;
            }
#endif
        }
    }

    if(Result == E_OK)
    {
#if(DCM_DEM_SUPPORT == STD_ON)
        Result = Dem_ClearDTC(DemClient);

        if(Result == DEM_PENDING)
        {
            /*SWS_Dcm_00703*/
            Result = DCM_E_PENDING;
        }
#else
        Result = Dcm_Rte_OBD_ClearDTC(OpStatus);

        if(Result == DCM_E_PENDING)
        {
            /*SWS_Dcm_00703*/
        }
#endif
        else if(Result == E_OK)
        {
            /*SWS_Dcm_00413*//*Send positve respnse.*/
            pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
            pMsgContext->resDataLen = (Dcm_MsgLenType)1;
        }
        else/*(Result == DEM_CLEAR_FAILED / DEM_CLEAR_BUSY / DEM_CLEAR_MEMORY_ERROR / E_NOT_OK)*/
        {
            /*SWS_Dcm_00704*//*SWS_Dcm_00967*//*SWS_Dcm_01067*/
            *pErrorCode = DCM_E_CONDITIONSNOTCORRECT;
#if(DCM_CAR_PLATFORM == DCM_SAIC_PLATFORM)
            Dcm_SetNRC22Reason(DCM_NRC22_REASON_4);
#endif
            Result = E_NOT_OK;
        }
    }

    return Result;
}
#endif

#if(DCM_OBD_06_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_06_RequestOnBoardMonitoringTestResults SWS_Dcm_00414
*
* Description: This function is the code implementation of the processing logic
*              for the 0x06 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_06_RequestOnBoardMonitoringTestResults
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 ReqMID;
    uint32 MIDValue;/*Used for availability MID*/
#if(DCM_DEM_SUPPORT == STD_ON)
    uint8 NumOfTIDs;/*Number of TIDs*/
    uint8 TIDValue;/*Std./Manuf. Defined TID*/
    uint8 UaSID;/*Unit And Scaling ID*/
    uint16 TestValue;/*Test Value*/
    uint16 LowLimValue;/*Min Test Limit/Lower limit value*/
    uint16 UppLimValue;/*Max Test Limit/Upper limit value*/
#else
    uint32 DataLength = 0;
#endif
    (void)OpStatus;

    if((((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0) \
        && ((pMsgContext->reqDataLen) > DCM_REQ_LEGTH_7_BYTE))
    {
        Result = E_NOT_OK;
        /*Reset Dcm, do not send NRC 0x13.*/
        /*DsdInternal_OBD_ReqErrorReset();*/
    }
    else if(((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
    {
        for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
        {
            DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
            if(((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0)
            {
                /*SWS_Dcm_00945*/
                Result = E_NOT_OK;
                /*Reset Dcm, do not send any negative response.*/
                /*DsdInternal_OBD_ReqErrorReset();*/
                break;
            }
        }
    }
    else if((((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0) \
        && ((pMsgContext->reqDataLen) != (Dcm_MsgLenType)2))
    {
        /*SWS_Dcm_00956*/
        Result = E_NOT_OK;
        /*Reset Dcm, do not send NRC 0x13.*/
        /*DsdInternal_OBD_ReqErrorReset();*/
    }
    else
    {
        /*do nothig*/
    }

    if((Result == E_OK) && (((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0))
    {
        pMsgContext->resDataLen = (Dcm_MsgLenType)1;
        /*SWS_Dcm_00957*/
        for(i = (uint8)0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)
        {
            ReqMID = DCM_OBD_REQ_DATA(i);
#if(DCM_DEM_SUPPORT == STD_ON)
            Result = Dem_DcmGetAvailableOBDMIDs(ReqMID, &MIDValue);
#else
            Result = Dcm_Rte_OBD_GetAvailableOBDMIDs(ReqMID, &MIDValue);
#endif
            if(Result == E_OK)
            {
                pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA(i);
                pMsgContext->resDataLen += (Dcm_MsgLenType)1;

                pMsgContext->resData[pMsgContext->resDataLen] = (uint8)(MIDValue>>24);
                pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)1] = (uint8)(MIDValue>>16);
                pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)2] = (uint8)(MIDValue>>8);
                pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)3] = (uint8)MIDValue;
                pMsgContext->resDataLen += (Dcm_MsgLenType)4;
            }
        }
    }
    else if((Result == E_OK) && (((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0))
    {
        /*SWS_Dcm_00958*/
        ReqMID = (pMsgContext->reqData[DCM_INDEX_1]);
        pMsgContext->resDataLen = (Dcm_MsgLenType)1;
#if(DCM_DEM_SUPPORT == STD_ON)
        Result = Dem_DcmGetNumTIDsOfOBDMID(ReqMID, &NumOfTIDs);

        if((Result == E_OK) && (NumOfTIDs > (uint8)0))
        {
            for(i = 0; i < NumOfTIDs; i++)
            {
                Result = Dem_DcmGetDTRData(ReqMID, i, &TIDValue, &UaSID, &TestValue, &LowLimValue, &UppLimValue);
                if(Result == E_OK)
                {
                    pMsgContext->resData[pMsgContext->resDataLen] = ReqMID;
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)1] = TIDValue;
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)2] = UaSID;
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)3] = (uint8)(TestValue>>8);
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)4] = (uint8)TestValue;
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)5] = (uint8)(LowLimValue>>8);
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)6] = (uint8)LowLimValue;
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)7] = (uint8)(UppLimValue>>8);
                    pMsgContext->resData[pMsgContext->resDataLen + (Dcm_MsgLenType)8] = (uint8)UppLimValue;
                    pMsgContext->resDataLen += (Dcm_MsgLenType)9;
                }
                else
                {
                    Result = E_NOT_OK;
                    break;
                }
            }/*for(i = 0; i < NumOfTIDs; i++)*/
        }
        else
        {
            Result = E_NOT_OK;
        }/*if((Result == E_OK) && (NumOfTIDs > (uint8)0))*/
#else
        Result = Dcm_Rte_OBD_GetDTRData(ReqMID, &(pMsgContext->resData[DCM_INDEX_2]), &DataLength);

        if(Result == E_OK)
        {
            pMsgContext->resData[DCM_INDEX_1] = ReqMID;
            pMsgContext->resDataLen += DataLength;
        }
#endif
    }
    else
    {
        /*do nothing*/
    }

    if(Result != E_OK)
    {
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        /*Send positve respnse.*/
        pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
    }

    return Result;
}
#endif

#if(DCM_OBD_08_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_08_RequestControlOfOnBoardSystem SWS_Dcm_00417
*
* Description: This function is the code implementation of the processing logic
*              for the 0x08 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_08_RequestControlOfOnBoardSystem
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 RowPara;
    uint8 ReqTID;
    (void)OpStatus;

    if((pMsgContext->reqDataLen) > DCM_REQ_LEGTH_7_BYTE)
    {
        Result = E_NOT_OK;
        /*Reset Dcm, do not send NRC 0x13.*/
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        if(((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
            {
                DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
                if(((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0)
                {
                    Result = E_NOT_OK;
                    /*SWS_Dcm_00947*//*Reset Dcm, do not send any negative response.*/
                    DsdInternal_OBD_ReqErrorReset();
                    break;
                }
            }
        }
    }

    if((Result == E_OK) && (((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0))
    {
        /*SWS_Dcm_00418*//*Request TIDs are availability TIDs.*/
        pMsgContext->resDataLen = (Dcm_MsgLenType)1;

        for(i = 0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)
        {
            RowPara = (DCM_OBD_REQ_DATA(i) / DCM_OBD_AVAILABILITY_PARAMETER);

            if((RowPara == (uint8)0) || ((DCM_OBD_08_AVAIL_TID((RowPara - 1), 3) & (uint8)0x01) != (uint8)0))
            {
                /*Put the request availability TID in response message buffer.*/
                pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA(i);
                pMsgContext->resDataLen += (Dcm_MsgLenType)1;

                for(j = 0; j < (uint8)4; j++)
                {
                    pMsgContext->resData[pMsgContext->resDataLen + j] = DCM_OBD_08_AVAIL_TID(RowPara, j);
                }
                pMsgContext->resDataLen += (Dcm_MsgLenType)4;
            }
        }
    }
    else if((Result == E_OK) && (((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0))
    {
        /*Copy the request data into local buffer.*/
        for(i = DCM_INDEX_2; i < pMsgContext->reqDataLen; i++)
        {
            DCM_OBD_REQ_DATA((i - (uint8)2)) = (pMsgContext->reqData[i]);
        }

        /*Check the request TID whether supported in the ECU
        and the request data length equals to the value in configuration.*/
        Result = E_NOT_OK;
        ReqTID = (pMsgContext->reqData[DCM_INDEX_1]);

        for(i = 0; i < DCM_CFG_TID_NUM; i++)
        {
            if((ReqTID == DCM_CFG_TID_CONTROL_TEST_ID(i)) \
                && ((pMsgContext->reqDataLen - (Dcm_MsgLenType)2) == DCM_CFG_TID_CONTROL_IN_SIZE(i)))
            {
                Result = E_OK;
                break;
            }
        }

        if(Result == E_OK)
        {
            /*SWS_Dcm_00948*/
            for(j = 0; j < DCM_CFG_TID_CONTROL_OUT_SIZE(i); j++)
            {
                pMsgContext->resData[j + DCM_INDEX_2] = DCM_DATA_CLEAR;
            }
            /*SWS_Dcm_00419*//*SWS_Dcm_00691*//*Call the function to process the request data.*/
            Result = (*DCM_CFG_TID_CONTROL_FNC(i))(&(pMsgContext->resData[DCM_INDEX_2]), &DCM_OBD_REQ_DATA(0));
            /*SWS_Dcm_00420*/
            if(Result == E_OK)
            {
                /*Send positve respnse.*/
                pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
                pMsgContext->resData[DCM_INDEX_1] = ReqTID;
                pMsgContext->resDataLen = (DCM_INDEX_2 + DCM_CFG_TID_CONTROL_OUT_SIZE(i));
            }
            else
            {
                /*SWS_Dcm_01192*/
                *pErrorCode = DCM_E_CONDITIONSNOTCORRECT;
#if(DCM_CAR_PLATFORM == DCM_SAIC_PLATFORM)
                Dcm_SetNRC22Reason(DCM_NRC22_REASON_8);
#endif
                Result = E_NOT_OK;
            }
        }
        else/*Result == E_NOT_OK*/
        {
            /*Reset Dcm, do not send any negative response.*/
            DsdInternal_OBD_ReqErrorReset();
        }
    }
    else
    {
        /*do nothing*/
    }

    return Result;
}
#endif

#if(DCM_OBD_09_ENABLED == STD_ON)
/* BEGIN_FUNCTION_HDR
********************************************************************************
* Function Name: DspInternal_09_RequestVehicleInformation SWS_Dcm_00421
*
* Description: This function is the code implementation of the processing logic
*              for the 0x09 service
*
* Inputs: OpStatus, pMsgContext
*
* Outputs: pErrorCode
*
* Return: Std_ReturnType
*
* Limitations: None
********************************************************************************
END_FUNCTION_HDR*/
FUNC(Std_ReturnType, DCM_CODE) DspInternal_09_RequestVehicleInformation
(
    Dcm_OpStatusType OpStatus,
    P2VAR(Dcm_MsgContextType, AUTOMATIC, DCM_VAR) pMsgContext,
    P2VAR(Dcm_NegativeResponseCodeType, AUTOMATIC, DCM_VAR) pErrorCode
)
{
    Std_ReturnType Result = E_OK;
    uint8 i;
    uint8 j;
    uint8 RowPara;
    uint8 ReqInfoType;
    uint8 DataLength;
    uint8 *DataBuffer;

    if(OpStatus == DCM_INITIAL)
    {
        DCM_OBD_INFOTYPE_INDEX = DCM_DATA_CLEAR;
        DCM_OBD_INFOTYPE_DATA_INDEX = DCM_DATA_CLEAR;

        if(((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0)
        {
            if((pMsgContext->reqDataLen) > DCM_REQ_LEGTH_7_BYTE)
            {
                Result = E_NOT_OK;
                /*Reset Dcm, do not send NRC 0x13.*/
                DsdInternal_OBD_ReqErrorReset();
            }
            else
            {
                for(i = DCM_INDEX_1; i < pMsgContext->reqDataLen; i++)
                {
                    DCM_OBD_REQ_DATA((i - (uint8)1)) = (pMsgContext->reqData[i]);
                    if(((pMsgContext->reqData[i]) % DCM_OBD_AVAILABILITY_PARAMETER) != 0)
                    {
                        /*SWS_Dcm_00949*/
                        Result = E_NOT_OK;
                        /*Reset Dcm, do not send any negative response.*/
                        DsdInternal_OBD_ReqErrorReset();
                        break;
                    }
                }
            }
            
        }
        else
        {
            if((pMsgContext->reqDataLen) != (Dcm_MsgLenType)2)
            {
                /*request InfoType not supported*/
                Result = E_NOT_OK;
                /*Reset Dcm, do not send NRC 0x13.*/
                DsdInternal_OBD_ReqErrorReset();
            }
            else
            {
                /*One byte ServiceId and one byte InfoType, then continue to read InfoType data.*/
                ReqInfoType = (pMsgContext->reqData[DCM_INDEX_1]);
                Result = E_NOT_OK;

                for(i = (uint8)0; i < DCM_CFG_INFOTYPE_NUM; i++)
                {
                    if(ReqInfoType == DCM_CFG_INFOTYPE_ID(i))
                    {
                        Result = E_OK;
                        DCM_OBD_INFOTYPE_INDEX = i;
                        break;
                    }
                }

                if(Result == E_NOT_OK)
                {
                    /*request InfoType not supported*/
                    /*Reset Dcm, do not send NRC 0x13.*/
                    DsdInternal_OBD_ReqErrorReset();
                }
                else
                {
                    /*One byte ServiceId and one byte InfoType, then continue to read InfoType data.*/
                    pMsgContext->resDataLen = (Dcm_MsgLenType)2;
                }
            }
        }
    }

    /*Read data*/
    if((Result == E_OK) \
        && (((pMsgContext->reqData[DCM_INDEX_1]) % DCM_OBD_AVAILABILITY_PARAMETER) == 0))
    {
        pMsgContext->resDataLen = (Dcm_MsgLenType)1;
        /*SWS_Dcm_00422*/
        for(i = (uint8)0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)
        {
            RowPara = ((DCM_OBD_REQ_DATA(i)) / DCM_OBD_AVAILABILITY_PARAMETER);

            if((RowPara == (uint8)0) || ((DCM_OBD_09_AVAIL_INFO((RowPara - 1), 3) & (uint8)0x01) != (uint8)0))
            {
                /*Put the request availability PID in response message buffer.*/
                pMsgContext->resData[pMsgContext->resDataLen] = DCM_OBD_REQ_DATA(i);
                pMsgContext->resDataLen += (Dcm_MsgLenType)1;

                for(j = 0; j < (uint8)4; j++)
                {
                    pMsgContext->resData[pMsgContext->resDataLen + j] = DCM_OBD_09_AVAIL_INFO(RowPara, j);
                }
                pMsgContext->resDataLen += (Dcm_MsgLenType)4;
            }
        }/*for(i = (uint8)0; i < (pMsgContext->reqDataLen - (Dcm_MsgLenType)1); i++)*/
    }
    else if(Result == E_OK)
    {
        /*One byte ServiceId and one byte InfoType.*/
        if(pMsgContext->resMaxDataLen > (DCM_DATA_U8_MAX + DCM_INDEX_2))
        {
            DataLength = DCM_DATA_U8_MAX;
        }
        else
        {
            DataLength = (pMsgContext->resMaxDataLen - DCM_INDEX_2);
        }
        DataBuffer = &(pMsgContext->resData[DCM_INDEX_2]);
        /*SWS_Dcm_00423*//*Read the InfoType data*/
        Result = DspInternal_09_ReadInfoTypeData(OpStatus, DataBuffer, &DataLength);

        if(Result == E_OK)
        {
            /*Send positve respnse.*/
            pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
            pMsgContext->resData[DCM_INDEX_1] = (pMsgContext->reqData[DCM_INDEX_1]);
            pMsgContext->resDataLen = (DCM_INDEX_2 + DataLength);
        }
        else if(Result == E_NOT_OK)
        {
            /*SWS_Dcm_01191*/
            *pErrorCode = DCM_E_CONDITIONSNOTCORRECT;
#if(DCM_CAR_PLATFORM == DCM_SAIC_PLATFORM)
            Dcm_SetNRC22Reason(DCM_NRC22_REASON_9);
#endif
        }
        else/*Result == DCM_E_PENDING*/
        {
            /*Call the function next task loop.*/
        }
    }
    else
    {
        /*do nothing*/
    }

    if((Result == E_NOT_OK) || (pMsgContext->resDataLen == (Dcm_MsgLenType)1))
    {
        /*if Result equals E_OK and the response length is 1,
        it means that no request infotypes supported in the ECU.*/
        DsdInternal_OBD_ReqErrorReset();
    }
    else
    {
        /*Send positive response.*/
        pMsgContext->resData[DCM_SID_INDEX] = DCM_REQ_SERVICE;
    }

    return Result;
}
#endif

#define DCM_STOP_SEC_CODE
#include "Dcm_MemMap.h"