gd32450i-eval/app/bmc/msghndlr/Storage/SDRDevice/SDR.c

/*****************************************************************
 *****************************************************************
 ***                                                            **
 ***    (C)Copyright 2005-2006, American Megatrends Inc.        **
 ***                                                            **
 ***            All Rights Reserved.                            **
 ***                                                            **
 ***        6145-F, Northbelt Parkway, Norcross,                **
 ***                                                            **
 ***        Georgia - 30071, USA. Phone-(770)-246-8600.         **
 ***                                                            **
 *****************************************************************
 ******************************************************************
 *
 * SDR.c
 * SDR functions.
 *
 *  Author: Govind Kothandapani <govindk@ami.com>
 *
 ******************************************************************/
//#include "main.h"
#include "com_IPMI_SDRRecord.h"
#include "SDR.h"
#include "SDRRecord.h"
#include <string.h>
#include "Support.h"
#include "SDRFunc.h"
#include "main.h"


/**
 * NVRAM Handles
**/
#define NVRH_USERCONFIG 0
#define NVRH_CHCONFIG     0
#define NVRH_SDR		0

/* Reserved bit macro definitions */
#define RESERVED_BITS_PARTIALADDSDR                     0xF0 //(BIT7 | BIT6 | BIT5 | BIT4)

#if SDR_DEVICE == 1

#define SUPPORT_MULTI_CONTROLLER 1
/*** Local Definitions ***/

#define SDR_FIRST_FREE_BYTE()   ((( uint8_t*)g_BMCInfo.SDRConfig.SDRRAM) + g_BMCInfo.SDRConfig.SDRRAM->Size)

#define MAX_SDR_LEN             25

#define MAX_RES_LEN             128
#define SDR_VERSION             0x51
#define CMD_RUN_INITIALIZATION_AGENT                0x2C
#define MANAGEMENT_DEV_LOC_REC	0x12

#define PARTIAL_ADD_SDR_SUPPORT             0x04
#define RESERVE_SDR_SUPPORT                 0x02
#define GET_SDR_REPOSITORY_ALLOC_SUPPORT    0x01
#define NON_MODAL_SUPPORT                   0x20
#define NO_SUPPORT                          0x00
#define DELETE_SDR_SUPPORT                  0x08



#define MAX_OEM_REC_LEN  64

#define SDR_ALLOC_UNIT_SIZE                 0x10
#define SDR_MAX_RECORD_SIZE                 0x80
#define SDR_ERASE_COMPLETED                 0x01
#define SDR_INIT_COMPLETED                  0x01

#define ENABLE_SELECTED_EVENT_MSG   0x10
#define DISABLE_SELECTED_EVENT_MSG  0x20

#define OEM_SDR_NM_REC             0x0D

/**
 * @brief Size of SDR Record
**/
#define SDR_SIZE(SDRRecHdr)     (sizeof (SDRRecHdr_T) + (SDRRecHdr)->Len)

/**
 * @brief Size the SDR Record occupies in the memory
**/
#define SDR_SIZE_IN_MEM(SDRRecHdr)                                  \
    (((SDR_SIZE(SDRRecHdr) & 0x0f) == 0) ? SDR_SIZE(SDRRecHdr) :    \
                                    (SDR_SIZE(SDRRecHdr) & 0xf0) + 0x10)

/*** Prototype Declarations ***/
static          uint8_t            PreCheckSDRUpdateModeCmd ( uint8_t* pRes);
static          uint16_t          SDR_ReserveSDRRepository (void);
static     SDRRecHdr_T*    GetLastSDRRec (void);
//static          void            UpdateRepositoryInfo (void);
static     SDRRecHdr_T*    SDR_GetSDRRec (uint16_t RecID, uint16_t ReservationID);

//static          void            SDRInitAgent (void);

//static          uint8_t           ValidateSDRSize (uint8_t SDRType, uint8_t Size);  
//const uint8_t SDRSize [][2] = {  
////      { SDR Type,                 Maximum Length },  
//        { FULL_SDR_REC,                         64 },  
//        { COMPACT_SDR_REC,                      48 },  
//        { EVENT_ONLY_SDR_REC,                   33 },  
//        { ENTITY_ASSOCIATION_SDR_REC,           16 },  
//        { DEV_REL_ENTITY_ASSOCIATION_SDR_REC,   32 },  
//        { GENERIC_DEVICE_LOCATOR_SDR_REC,       32 },  
//        { FRU_DEVICE_LOCATOR_SDR_REC,           32 },  
//        { MGMT_CTRL_DEV_LOCATOR_SDR_REC,        32 },  
//        { MGMT_CTRL_CONFIRMATION_SDR_REC,       32 },  
//        { BMC_MSG_CHANNEL_INFO_REC,             16 },  
//    };  


static          uint16_t          SDR_AddSDRRec ( SDRRecHdr_T* pSDRRecHdr);

static          uint16_t          SDR_PartialAddSDR ( uint8_t* SDRData, uint8_t Offset, uint8_t Size,uint8_t IsLast, uint16_t ReservationID);


#define CLEAR_SDR_INITIATE_ERASE    0xAA
#define CLEAR_SDR_GET_STATUS        0x00
static          int             SDR_ClearSDRRepository (uint16_t ReservationID, uint8_t InitOrStatus);

//static 		uint16_t		SDR_DeleteSDR (uint16_t ReservationID, uint16_t RecID);

/*---------------------------------------
 * GetSDRRepositoryInfo
 *---------------------------------------*/
int
GetSDRRepositoryInfo ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
     SDRRepositoryInfo_T* pSDRRepInfoRes =
                        ( SDRRepositoryInfo_T*) pRes;

    memcpy (pSDRRepInfoRes, &g_BMCInfo.SDRConfig.RepositoryInfo, sizeof (SDRRepositoryInfo_T));
    pSDRRepInfoRes->CompletionCode = CC_NORMAL;
    
    return sizeof (SDRRepositoryInfo_T);
}


/*---------------------------------------
 * GetSDRRepositoryAllocInfo
 *---------------------------------------*/
int
GetSDRRepositoryAllocInfo ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
     SDRRepositoryAllocInfo_T* pSDRRepAllocInfoRes =
                        ( SDRRepositoryAllocInfo_T*) pRes;

    memcpy (pSDRRepAllocInfoRes, &g_BMCInfo.SDRConfig.RepositoryAllocInfo,
                        sizeof (SDRRepositoryAllocInfo_T));
    pSDRRepAllocInfoRes->CompletionCode = CC_NORMAL;
    
    return sizeof (SDRRepositoryAllocInfo_T);
}

/*---------------------------------------
 * ReserveSDRRepository
 *---------------------------------------*/
int
ReserveSDRRepository ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
    
    ReserveSDRRepositoryRes_T*  pResSDRRepRes =
                                    ( ReserveSDRRepositoryRes_T*) pRes;

	/* Shouldnt allow to reserve when the SDR is in update mode */
	if( TRUE == g_BMCInfo.SDRConfig.UpdatingSDR )
	{
		  pResSDRRepRes->CompletionCode = CC_SDR_REP_IN_UPDATE_MODE;
		  return sizeof (pResSDRRepRes->CompletionCode);
	}
          
    pResSDRRepRes->ReservationID  = SDR_ReserveSDRRepository ();
    g_BMCInfo.SDRConfig.PartAddbytes = 0; 
    pResSDRRepRes->CompletionCode = CC_NORMAL;

    return sizeof (ReserveSDRRepositoryRes_T);
}


/*---------------------------------------
 * GetSDR
 *---------------------------------------*/
int GetSDR ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
	SDRRecHdr_T*     pSDRRec;
	GetSDRReq_T*     pGetSDRReq = ( GetSDRReq_T*) pReq;
	GetSDRRes_T*     pGetSDRRes = ( GetSDRRes_T*) pRes;
	
	uint8_t SDRLen = 0;

    if (TRUE != PreCheckSDRUpdateModeCmd (pRes))
    {
        return sizeof (uint8_t);  /* error code set in func */
    }

    /* If the Offset is Not zero then its A partial get.. / if SDR is in update mode
    	then check for the reservation id 		*/

    if ((pGetSDRReq->Offset == 0) && (FALSE == g_BMCInfo.SDRConfig.UpdatingSDR ))
    {
        pSDRRec = GetSDRRec (pGetSDRReq->RecID);
    }
    else 
    {
        pSDRRec = SDR_GetSDRRec ( pGetSDRReq->RecID, pGetSDRReq->ReservationID );
    }

    if (0 == pSDRRec)
    {
        pGetSDRRes->CompletionCode = g_BMCInfo.SDRConfig.SDRError;
        return sizeof (uint8_t);
    }

    SDRLen = pSDRRec->Len+sizeof(SDRRecHdr_T);

    if((0xFF == pGetSDRReq->Size) && (SDRLen >= pGetSDRReq->Offset))
    {
        pGetSDRReq->Size =  SDRLen - pGetSDRReq->Offset;
    }

    /* Check for Max Request Bytes */
    if ((pGetSDRReq->Size > MAX_SDR_LEN) || (pGetSDRReq->Size > SDRLen) || (pGetSDRReq->Offset > SDRLen) 
        || (pGetSDRReq->Size > (SDRLen-pGetSDRReq->Offset)))
    {
        pGetSDRRes->CompletionCode = CC_CANNOT_RETURN_REQ_BYTES;
        return sizeof (uint8_t);
    }

    /* Copy the response */
    pGetSDRRes->CompletionCode = CC_NORMAL;
    pGetSDRRes->NextRecID      = SDR_GetNextSDRId (pSDRRec->ID);
    memcpy (pGetSDRRes + 1,
              (( uint8_t*) pSDRRec) + pGetSDRReq->Offset,
              pGetSDRReq->Size);

    return sizeof (GetSDRRes_T) + pGetSDRReq->Size;
}


/*---------------------------------------
 * AddSDR
 *---------------------------------------*/
int
AddSDR ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
    uint16_t       RecID;
     SDRRecHdr_T* pSDRRec    = ( SDRRecHdr_T*) pReq;
     AddSDRRes_T* pAddSDRRes = ( AddSDRRes_T*) pRes;
     

    /*Check the Minimum length of the SDR record*/
    if(ReqLen < sizeof(SDRRecHdr_T))
    {
        *pRes = CC_REQ_INV_LEN;
        return sizeof(uint8_t);
    }

    /*Check the SDR length*/
    if((ReqLen - sizeof(SDRRecHdr_T)) != pSDRRec->Len)
    {
        *pRes = CC_REQ_INV_LEN;
        return sizeof(uint8_t);
    }

    if (TRUE != PreCheckSDRUpdateModeCmd (pRes))
    {
        return sizeof (uint8_t);  /* error code set in func */
    }
    RecID = SDR_AddSDRRec (pSDRRec);
    if (INVALID_RECORD_ID == RecID)
    {
        pAddSDRRes->CompletionCode = g_BMCInfo.SDRConfig.SDRError;
        return sizeof (pAddSDRRes->CompletionCode);
    }
    pAddSDRRes->CompletionCode  = CC_NORMAL;
    pAddSDRRes->RecID           = RecID;
  
    return sizeof (AddSDRRes_T);
}


/*---------------------------------------
 * PartialAddSDR
 *---------------------------------------*/
int
PartialAddSDR ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
    uint8_t                Size;
    uint16_t               RecID;
     PartialAddSDRReq_T*  pPartialAddReq = ( PartialAddSDRReq_T*) pReq;
     PartialAddSDRRes_T*  pPartialAddRes = ( PartialAddSDRRes_T*) pRes;
     

    if( ReqLen < sizeof(PartialAddSDRReq_T))
    {
        pPartialAddRes->CompletionCode = CC_REQ_INV_LEN;
        return sizeof (pPartialAddRes->CompletionCode);
    }	

    /* Check for the reserved bytes should b zero */

    if  ( 0 !=  (pPartialAddReq->Progress & RESERVED_BITS_PARTIALADDSDR ) )
    {
        pPartialAddRes->CompletionCode = CC_INV_DATA_FIELD;
        return sizeof(uint8_t);	
    }

    if (TRUE != PreCheckSDRUpdateModeCmd (pRes))
    {
        return sizeof (uint8_t);  /* error code set in func */
    }

    Size  = ReqLen - sizeof (PartialAddSDRReq_T);
    if(0 == pPartialAddReq->Offset )
    {
        g_BMCInfo.SDRConfig.TrackPOffset =0;
        g_BMCInfo.SDRConfig.TrackRecID =pPartialAddReq->RecID;
    }
    else if((g_BMCInfo.SDRConfig.TrackPOffset) != pPartialAddReq->Offset || g_BMCInfo.SDRConfig.TrackRecID != pPartialAddReq->RecID)
    {
        pPartialAddRes->CompletionCode = CC_INV_DATA_FIELD;
        return sizeof (pPartialAddRes->CompletionCode);
    }

    RecID = SDR_PartialAddSDR (( uint8_t*)(pPartialAddReq + 1),
                           pPartialAddReq->Offset,
                           Size,
                           pPartialAddReq->Progress & 0xf,
                           pPartialAddReq->ReservationID);

    if (RecID == INVALID_RECORD_ID)
    {
        pPartialAddRes->CompletionCode = g_BMCInfo.SDRConfig.SDRError;
        return sizeof (pPartialAddRes->CompletionCode);
    }

    pPartialAddRes->CompletionCode  = CC_NORMAL;
    pPartialAddRes->RecID           = RecID;

     g_BMCInfo.SDRConfig.TrackPOffset +=Size;
     g_BMCInfo.SDRConfig.TrackRecID =RecID;   //We are updating the available or alloted   Record ID 
   
    return sizeof (PartialAddSDRRes_T);
}


/*---------------------------------------
 * DeleteSDR
 *---------------------------------------*/
int
DeleteSDR ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
	printf("DeleteSDR not implement\r\n");
//     BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//    DeleteSDRReq_T* pDeleteSDRReq = ( DeleteSDRReq_T*)pReq;
//    DeleteSDRRes_T* pDeleteSDRRes  = ( DeleteSDRRes_T*)pRes;
//    uint16_t RecID;

//    OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SDRConfig.SDRMutex, WAIT_INFINITE);
//    if (TRUE != PreCheckSDRUpdateModeCmd (pRes,BMCInst))
//    {
//        OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SDRConfig.SDRMutex);
//        return sizeof (uint8_t);  /* error code set in func */
//    }
//    RecID=SDR_DeleteSDR ( pDeleteSDRReq->ReservationID, pDeleteSDRReq->RecID,BMCInst);
//    if(RecID == INVALID_RECORD_ID )
//    {
//        OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SDRConfig.SDRMutex);
//        pDeleteSDRRes->CompletionCode = g_BMCInfo[BMCInst].SDRConfig.SDRError;
//        return sizeof (pDeleteSDRRes->CompletionCode);
//    }
//    pDeleteSDRRes->CompletionCode = CC_NORMAL;
//    pDeleteSDRRes->RecID = RecID;

//    OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SDRConfig.SDRMutex);
//	// To send notification to CIM
//    if(g_PDKCIMEventHandle[PDKCIMEVENT_NOTIFYSERVERUPDATETOCIM] != NULL)
//    {       
//	uint8 CMD;
//	// Set bits for SDR Event & Delete operation
//	CMD = 0x13;
//	((int(*)(uint8, uint16))g_PDKCIMEventHandle[PDKCIMEVENT_NOTIFYSERVERUPDATETOCIM])(CMD, RecID);
//	
//    }

    return sizeof (DeleteSDRRes_T);
}


/*---------------------------------------
 * ClearSDRRepository
 *---------------------------------------*/
int
ClearSDRRepository ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
    int            status;
     ClearSDRReq_T* pClrSDRReq = ( ClearSDRReq_T*) pReq;
     ClearSDRRes_T* pClrSDRRes = ( ClearSDRRes_T*) pRes;
     

    if (TRUE != PreCheckSDRUpdateModeCmd (pRes))
    {
        return sizeof (uint8_t);  /* error code set in func */
    }

    if(pClrSDRReq->CLR[0] != 'C'  || pClrSDRReq->CLR[1] != 'L'  || pClrSDRReq->CLR[2] != 'R' )
    {
        pClrSDRRes->CompletionCode= CC_PASSWORD_TEST_FAILED;
        return sizeof(uint8_t);
    }

    status = SDR_ClearSDRRepository (pClrSDRReq->ReservationID,pClrSDRReq->InitOrStatus);
    if (0 != status)
    {
        pClrSDRRes->CompletionCode = g_BMCInfo.SDRConfig.SDRError;
        return sizeof (pClrSDRRes->CompletionCode);
    }

    pClrSDRRes->CompletionCode = CC_NORMAL;
    pClrSDRRes->EraseProgress  = SDR_ERASE_COMPLETED;
 
    return sizeof (ClearSDRRes_T);
}


/*---------------------------------------
 * GetSDRRepositoryTime
 *---------------------------------------*/
int
GetSDRRepositoryTime ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
	//TODO
    uint32_t                      SDRTime = 0;
    GetSDRRepositoryTimeRes_T*  pGetSDRTimeRes =
                                ( GetSDRRepositoryTimeRes_T*) pRes;
    

     /* Get the time */
//    SDRTime = GetSelTimeStamp ();
    pGetSDRTimeRes->CompletionCode  = CC_NORMAL;
    pGetSDRTimeRes->Time            = SDRTime;

    return sizeof (GetSDRRepositoryTimeRes_T);
}


/*--------------------------------------
 *  * SetSDRRepositoryTime
 *   * -------------------------------------*/
int
SetSDRRepositoryTime ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
	//TODO
    SetSDRRepositoryTimeReq_T* pSetSDRTimeReq = ( SetSDRRepositoryTimeReq_T*) pReq;
    

    pSetSDRTimeReq->Time = (pSetSDRTimeReq->Time);

    //SET_SYSTEM_TIME_STAMP (&pSetSDRTimeReq->Time);

    /* Resetting the SELTimeUTCOffset to default value */
//    pBMCInfo->GenConfig.SELTimeUTCOffset = UNSPECIFIED_UTC_OFFSET;

    /*Write to NVRAM*/
//    FlushIPMI((uint8_t*)&pBMCInfo->GenConfig,(uint8_t*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr,
//                      sizeof(GENConfig_T));

    pRes [0] = CC_NORMAL;
    return sizeof (*pRes);
}


/*---------------------------------------
 * EnterSDRUpdateMode
 *---------------------------------------*/
int
EnterSDRUpdateMode ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
     EnterSDRUpdateModeRes_T* pEnterSDRUpdateModeRes =
                                ( EnterSDRUpdateModeRes_T*) pRes;
    
  

    g_BMCInfo.SDRConfig.UpdatingSDR       = TRUE;
    g_BMCInfo.SDRConfig.UpdatingChannel   = 0;//*curchannel  & 0xF;
    pEnterSDRUpdateModeRes->CompletionCode = CC_NORMAL;

    return sizeof (EnterSDRUpdateModeRes_T);
}


/*------------------------------------------
 * ExitSDRUpdateMode
 *------------------------------------------*/
int
ExitSDRUpdateMode ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
     ExitSDRUpdateModeRes_T*  pExitSDRUpdateModeRes =
                            ( ExitSDRUpdateModeRes_T*) pRes;
     

    if (TRUE != PreCheckSDRUpdateModeCmd (pRes))
    {
        return sizeof (uint8_t);  /* error code set in func */
    }

    g_BMCInfo.SDRConfig.UpdatingSDR = FALSE;

    pExitSDRUpdateModeRes->CompletionCode = CC_NORMAL;
   
    return sizeof (ExitSDRUpdateModeRes_T);
}


/*-------------------------------------------------
 * RunInitializationAgent
 *--------------------------------------------------*/
int
RunInitializationAgent ( uint8_t* pReq, uint8_t ReqLen,  uint8_t* pRes)
{
	printf("RunInitializationAgent not implement\r\n");
//     RunInitAgentRes_T*   pRunInitAgentRes =
//                        ( RunInitAgentRes_T*) pRes;
//     BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst];

//    /* Reserved bit Checking */
//    if((pReq[0] & 0xFE)  != 0x00)
//    {
//        pRes [0] = CC_INV_DATA_FIELD;
//        return sizeof (*pRes);
//    }

//    OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SDRConfig.SDRMutex, WAIT_INFINITE);
//    if (0 != pReq[0])
//    {
//        InitSDR (BMCInst);
//        SDRInitAgent (BMCInst);
//        // The sensor monitor loop has been made 0 for
//        // initializing the sensor scanning bit.
//        pBMCInfo->SenConfig.SensorMonitorLoopCount = 0;
//    }
//    pRunInitAgentRes->CompletionCode = CC_NORMAL;
//    pRunInitAgentRes->Status         = SDR_INIT_COMPLETED;
//    OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SDRConfig.SDRMutex);

    return sizeof (RunInitAgentRes_T);
}

/*-----------------------------------------
 * GetSDRRec
 *-----------------------------------------*/
 SDRRecHdr_T*
GetSDRRec (uint16_t RecID)
{
     SDRRecHdr_T*  pSDRRec;

    /* If ID == 0x0000  return first record */
    if (0 == RecID)
    {
        pSDRRec = SDR_GetFirstSDRRec ();
        if (0== pSDRRec)	/* is SDR empty? */
        {
            g_BMCInfo.SDRConfig.SDRError = CC_SDR_REC_NOT_PRESENT;
            return 0;
        }
        return pSDRRec;
    }

    /* If ID == 0xFFFF return the last record */
    if (0xFFFF == RecID)
    {
        return GetLastSDRRec ();
    }

    pSDRRec = SDR_GetFirstSDRRec ();
    while (TRUE)
    {
        if (0== pSDRRec)
        {
            g_BMCInfo.SDRConfig.SDRError = CC_SDR_REC_NOT_PRESENT;
            return 0;
        }
        if (pSDRRec->ID == RecID)
        {
            return pSDRRec;
        }
        pSDRRec = SDR_GetNextSDRRec (pSDRRec);
    }
}


/*-----------------------------------------------------
 * InitSDR
 *-----------------------------------------------------*/
int InitSDR ()
{
//	uint8_t* 			pSDRRec;
//	SDRRecHdr_T*      	pSDRRecord;
//    int             	i;				/* Multi-LUN support index will have more than 256 sensors*/

//    uint8_t     OEM_Recdata[MAX_OEM_REC_LEN];
//    BMCInfo_t* 	pBMCInfo = &g_BMCInfo;

//    pBMCInfo->SDRConfig.SDRRAM = ( SDRRepository_T*) GetSDRSELNVRAddr(NVRH_SDR, BMCInst);
//    pSDRRec    = GetSDRSELNVRAddr (NVRH_SDR + sizeof(SDRRepository_T), BMCInst);
//    pBMCInfo->SDRConfig.SDRRAM->NumRecords    = 0;
//    pBMCInfo->SDRConfig.LatestRecordID     =0;
//    pBMCInfo->SDRConfig.SDRRAM->Size          = 16;          /* SDR Repository Header */
//#if (0x01 == MARK_FOR_DELETION_SUPPORT)
//    pBMCInfo->SDRConfig.NumMarkedRecords= 0;
//#endif
//    if (pBMCInfo->SDRConfig.RepositoryInfo.OpSupport & OVERFLOW_FLAG)
//    {
//        pBMCInfo->SDRConfig.RepositoryInfo.OpSupport &= ~OVERFLOW_FLAG;
//    }

//    printf ("Init SDR\n");

//    while (TRUE)
//    {
//#if (0x01 == MARK_FOR_DELETION_SUPPORT)
//        if ((0x5A == (( E2ROMHdr_T*)pSDRRec)->Valid)
//        || (0x01 == (( E2ROMHdr_T*)pSDRRec)->Valid) )
//        {
//            //count the records marked for deletion.
//            if (0x01 == (( E2ROMHdr_T*)pSDRRec)->Valid)
//            {
//                pBMCInfo->SDRConfig.NumMarkedRecords++;
//            }
//            else
//            {
//                pBMCInfo->SDRConfig.SDRRAM->NumRecords ++;
//            }
//#else
//        if (0x5A == (( E2ROMHdr_T*)pSDRRec)->Valid)
//        {
//            pBMCInfo->SDRConfig.SDRRAM->NumRecords ++;
//#endif

//            pBMCInfo->SDRConfig.LatestRecordID = ((SDRRecHdr_T *)((( E2ROMHdr_T*)pSDRRec)+1))->ID;
//            pBMCInfo->SDRConfig.SDRRAM->Size +=  (( E2ROMHdr_T*)pSDRRec)->Len;
//            pSDRRec += (( E2ROMHdr_T*)pSDRRec)->Len;
//        }
//        /* if No more Records */
//        else
//        {
//            break;
//        }
//    }

//   /* Check if SDR (valid record count) Empty */
//    if (0 == pBMCInfo->SDRConfig.SDRRAM->NumRecords)
//    {
//#if IPM_DEVICE == 1
//        pBMCInfo->Msghndlr.SelfTestByte |= GST_SDR_EMPTY;
//#endif

//        printf ("SDR EMPTY \n");

//    }

//    /* Update the SDR Erase Time Stamp */
//   pBMCInfo->SDRConfig.RepositoryInfo.EraseTimeStamp = pBMCInfo->GenConfig.SDREraseTime ;


//    /* Update the repository information */
//    UpdateRepositoryInfo (BMCInst);

//    pSDRRecord = SDR_GetFirstSDRRec (BMCInst);
//    for (i=0; i < pBMCInfo->SDRConfig.SDRRAM->NumRecords && pSDRRecord != NULL; i++)
//    {
//      if ((OEM_SDRFRU_REC == pSDRRecord->Type)||(OEM_SDRNM_REC == pSDRRecord->Type))
//     {
//         uint8_t Rec_len;
//         Rec_len=pSDRRecord->Len ;
//         memcpy(OEM_Recdata , pSDRRecord ,sizeof(SDRRecHdr_T)+Rec_len);
//         if(g_PDKHandle[PDK_PROCESSOEMRECORD] != NULL)
//        {
//            ((void(*)(uint8_t *,int))g_PDKHandle[PDK_PROCESSOEMRECORD]) ((uint8_t*)&OEM_Recdata,BMCInst);
//        }
//     }
//      if(g_corefeatures.node_manager == ENABLED)
//      {
//        if(OEM_SDRNM_REC == pSDRRecord->Type)
//        {
//         OEM_NMRec_T* sonm;
//         sonm =(OEM_NMRec_T*) ( (UINT8*)pSDRRecord );

//         if(sonm->RecordSubType == OEM_SDR_NM_REC)
//           pBMCInfo->NMConfig.NMDevSlaveAddress = sonm->NMDevSlaveAddress;
//        }
//      }
//      if(g_PDKHandle[PDK_PROCESSSENSORDATARECORD] != NULL)
//      {
//          ((void(*)(uint8_t *,int))g_PDKHandle[PDK_PROCESSSENSORDATARECORD]) ((uint8_t*)pSDRRecord,BMCInst);
//      }

//     pSDRRecord = SDR_GetNextSDRRec (pSDRRecord,BMCInst);
//   }
//    
//    if(g_PDKHandle[PDK_AFTERSDRINIT] != NULL)
//    {
//        ((void(*)(uint8_t))g_PDKHandle[PDK_AFTERSDRINIT]) (BMCInst);
//    }
    
    return 0;
}


/*----------------------------------------------------------*
 * SDR_GetNextSDRId
 *----------------------------------------------------------*/
uint16_t
SDR_GetNextSDRId (uint16_t RecID)
{
     SDRRecHdr_T*  pSDRRec;

    pSDRRec = GetSDRRec(RecID);
    if (0 == pSDRRec)
    {
        return INVALID_RECORD_ID;
    }

    pSDRRec = SDR_GetNextSDRRec (pSDRRec);
    if (0 == pSDRRec)
    {
        /* return last record ID (0xFFFF) */
        printf (" No Records\n");
        return 0xFFFF;
    }
    else
    {
        return pSDRRec->ID;
    }
}


/*--------------------------------------------------
 * SDR_GetFirstSDRRec
 *--------------------------------------------------*/
 SDRRecHdr_T*
SDR_GetFirstSDRRec ()
{
    return ReadSDRRepository (NULL);
}


/*--------------------------------------------------
 * SDR_GetNextSDRRec
 *-------------------------------------------------*/
 SDRRecHdr_T*
SDR_GetNextSDRRec ( SDRRecHdr_T* pSDRRec)
{
    return ReadSDRRepository (pSDRRec);
}


/*--------------------------------------------------
 * ReadSDRRepository
 *-------------------------------------------------*/
 SDRRecHdr_T*
ReadSDRRepository ( SDRRecHdr_T* pSDRRec)
{
    E2ROMHdr_T* InternalHdr;
//    uint8_t SDRSize=0;

    if (pSDRRec == 0)
    {
        InternalHdr = ( E2ROMHdr_T*)(g_BMCInfo.pSDR + sizeof(SDRRepository_T));
    }
    else
    {
        
        InternalHdr = ( E2ROMHdr_T*)(( uint8_t*)pSDRRec + SDR_SIZE (pSDRRec));
        
        /* is address >= First free byte ? */
        if (( uint8_t*) InternalHdr >= ( uint8_t*)SDR_FIRST_FREE_BYTE() )
        {
            /* No more records to read */
            //log("No more records to read\r\n");
            return 0;
        }
        //log("Reading the next record of %x \r\n", pSDRRec->ID);
    }

    /* is SDR Empty ?*/
    if (g_BMCInfo.SDRConfig.SDRRAM->NumRecords == 0)
    {
        return 0;
    }

#if (0x01 == MARK_FOR_DELETION_SUPPORT)
    /* Fetch a Valid SDR */
    while (TRUE)
    {
        if( InternalHdr->Valid == 0x5a )
        {
            printf("Returning Valid record ID %x \n", (( SDRRecHdr_T*)(InternalHdr+1))->ID );
            return (( SDRRecHdr_T*)(InternalHdr+1));
        }

        InternalHdr = ( E2ROMHdr_T*) (((uint8_t*)InternalHdr) + InternalHdr->Len);

        /* is address >= First free byte ? */
        if (( uint8_t*) InternalHdr >= ( uint8_t*)SDR_FIRST_FREE_BYTE(BMCInst) )
        {
            log("No more valid records found \n");
            return 0;
        }
    }
#else
	return (( SDRRecHdr_T*)(InternalHdr+1));
#endif
}


/*--------------------------------------------------
 * WriteSDRRepository
 *-------------------------------------------------*/
void
WriteSDRRepository ( SDRRecHdr_T* pSDRRec, uint8_t Offset, uint8_t Size,uint8_t SdrSize)
{
	//TODO:
	printf("WriteSDRRepository not implement\r\n");
//     E2ROMHdr_T* InternalHdr = ( E2ROMHdr_T *)SDR_FIRST_FREE_BYTE(BMCInst);
//     uint8_t*      WriteAddr;

//    /* Update Validity and Length */
//    if ( Offset < sizeof(SDRRecHdr_T ) && ((Offset + Size) >= sizeof(SDRRecHdr_T)) )
//    {
//        InternalHdr->Valid  = 0x5A;
//        InternalHdr->Len    = SdrSize;
//    }

//    WriteAddr = ( uint8_t*)(InternalHdr+1);
//    memset((WriteAddr + Offset),0,SdrSize);
//    _fmemcpy ((WriteAddr + Offset), pSDRRec, Size);

    return ;
}


/**
 * @brief Check the SDR update mode.
 * @param pRes - Response.
 * @return TRUE/FALSE
**/
static uint8_t
PreCheckSDRUpdateModeCmd ( uint8_t* pRes)
{
	//TODO: when update SDR return FALSE.
    return TRUE;
}


/**
 * @brief Reserve the SDR Repository.
 * @return Reservation ID.
**/
static uint16_t
SDR_ReserveSDRRepository ()
{
    if (0xffff == g_BMCInfo.SDRConfig.ReservationID)
    {
        g_BMCInfo.SDRConfig.ReservationID = 1;
    }else
    {
        g_BMCInfo.SDRConfig.ReservationID++;
    }
    g_BMCInfo.SDRConfig.TrackPOffset =0;	
    return g_BMCInfo.SDRConfig.ReservationID;

}


/**
 * @brief Get an SDR record.
 * @param RecID         - SDR record ID.
 * @param ReservationID - SDR Reservation ID.
 * @return SDR record.
**/
static  SDRRecHdr_T*
SDR_GetSDRRec (uint16_t RecID, uint16_t ReservationID)
{

    /* Bail out with error, if both the conditions are False (Reservation not valid)
    1. Reservation ID matches, not equal to 0x00 & SDR is not in Update mode  /
    2. SDR is in Update mode & Reservation ID equals to 0x00
    */
    if ( !(((g_BMCInfo.SDRConfig.ReservationID == ReservationID) && (0x00 != ReservationID) && 
		(FALSE == g_BMCInfo.SDRConfig.UpdatingSDR)) || ((TRUE == g_BMCInfo.SDRConfig.UpdatingSDR) && 
		(0x00 == ReservationID))))
    {
        if( TRUE == g_BMCInfo.SDRConfig.UpdatingSDR )
        {
            g_BMCInfo.SDRConfig.SDRError = CC_SDR_REP_IN_UPDATE_MODE;
        }else /* Reservation ID doesn't match, return invalid reservation ID */
        {
            g_BMCInfo.SDRConfig.SDRError = CC_INV_RESERVATION_ID;
        }
        return 0;
    }

    return GetSDRRec (RecID);
}

//static uint8_t
//ValidateSDRSize (uint8_t SDRType, uint8_t Size)
//{
//	//TODO:
//	printf("ValidateSDRSize not implement\r\n");
//    int i;

//    IPMI_DBG_PRINT_2("ValidateSDR Type : 0x%X, Size : 0x%X\n", SDRType, Size);

//    if ((SDRType == OEM_SDRFRU_REC)||(SDRType == OEM_SDRNM_REC))
//        return TRUE;

//    for (i = 0; i < sizeof (SDRSize)/ 2; i++)
//    {
//        if ((SDRSize[i][0] == SDRType) && (SDRSize[i][1] >= Size))
//        {
//            return TRUE;
//        }
//    }
//    return FALSE;
//	return TRUE;
//}

/**
 * @brief Add an SDR record.
 * @param pSDRRec - SDR record.
 * @return Record ID.
**/
static uint16_t
SDR_AddSDRRec ( SDRRecHdr_T* pSDRRec)
{
	//TODO
	printf("SDR_AddSDRRec not implement\r\n");
//    uint16_t SDRSize;
//    uint8_t AllocSize;
//    int nRet; 

//    if (FALSE == ValidateSDRSize(pSDRRec->Type, pSDRRec->Len + sizeof (SDRRecHdr_T)))
//    {
//        g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_REQ_INV_LEN;
//        return INVALID_RECORD_ID;
//    }
//    
//    AllocSize =  SDR_SIZE (pSDRRec) + sizeof(E2ROMHdr_T);
//    if(0 != (AllocSize % SDR_ALLOC_UNIT_SIZE))
//    {
//             SDRSize = AllocSize + (SDR_ALLOC_UNIT_SIZE -(AllocSize % SDR_ALLOC_UNIT_SIZE));
//    }
//    else
//    {
//        SDRSize = AllocSize;
//    }

//    if (SDRSize > htoipmi_u16 (g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.FreeSpace))
//    {
//        g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport |= OVERFLOW_FLAG;
//        g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_OUT_OF_SPACE;
//        return INVALID_RECORD_ID;
//    }

//    /* Update the record ID */
//    pSDRRec->ID = g_BMCInfo[BMCInst].SDRConfig.LatestRecordID + 1;

//    /* Add this record to the end of the repository */
//    WriteSDRRepository (pSDRRec, 0, SDR_SIZE (pSDRRec),SDRSize,BMCInst);

//    /* Flush the sdr */
//    FlushSDR (SDR_FIRST_FREE_BYTE(BMCInst), SDRSize, nRet,BMCInst);
//#if IPM_DEVICE == 1
//    if (-1 == nRet)
//    {
//        g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_CANNOT_ACCESS_SDR;
//    }
//    else
//    {
//        g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_CANNOT_ACCESS_SDR;
//    }
//#endif

//    /* Update the fields in SDR Repository */
//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords++;
//    g_BMCInfo[BMCInst].SDRConfig.LatestRecordID++;

//#if IPM_DEVICE == 1
//    if (g_BMCInfo[BMCInst].Msghndlr.SelfTestByte & GST_SDR_EMPTY)
//    {
//        g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_SDR_EMPTY;
//    }
//#endif

//    
//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->Size += SDRSize;
//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->AddTimeStamp        = GetSelTimeStamp(BMCInst);
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.AddTimeStamp = GetSelTimeStamp(BMCInst);

//    /* Update the repository info */
//    UpdateRepositoryInfo (BMCInst);

//    /* Invalidate Reservation ID if any */
//    SDR_ReserveSDRRepository (BMCInst);

//    return pSDRRec->ID;
	return 0;
}



/**
 * @brief Add partial SDR record.
 * @param SDRData   - SDR Data.
 * @param Offset    - SDR offset.
 * @param Size      - Size of the data.
 * @param IsLast    - Is this a last record?
 * @param ReservationID - SDR reservation id.
 * @return the record id.
**/
static uint16_t
SDR_PartialAddSDR ( uint8_t* SDRData, uint8_t Offset, uint8_t Size,
                                     uint8_t IsLast, uint16_t ReservationID)

{
	//TODO
	printf("SDR_PartialAddSDR not implement\r\n");
//    uint16_t          RecID;
//       SDRRecHdr_T*    pSDRRecInNVR;
//    uint8_t SdrSize=0;
//    int nRet;
//    
//     /* Bail out with error, if both the conditions are False (Reservation not valid)
//    1. Reservation ID matches, not equal to 0x00 & SDR is not in Update mode  /
//    2. SDR is in Update mode & Reservation ID equals to 0x00
//    */
//    if ( !(((g_BMCInfo[BMCInst].SDRConfig.ReservationID == ReservationID) && (0x00 != ReservationID) && (FALSE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR)) ||
//    ((TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR) && (0x00 == ReservationID))))
//    {
//        if( TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR )
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_SDR_REP_IN_UPDATE_MODE;
//        }else //Reservation ID doesn't match, return invalid reservation ID.
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_RESERVATION_ID;
//        }
//        g_BMCInfo[BMCInst].SDRConfig.PartAddbytes=0;
//        return INVALID_RECORD_ID;
//    }

//    pSDRRecInNVR = ( SDRRecHdr_T*) (SDR_FIRST_FREE_BYTE(BMCInst) +
//                    sizeof (E2ROMHdr_T));
//    RecID = g_BMCInfo[BMCInst].SDRConfig.LatestRecordID + 1;

//    /* If the header is received completely, validate the size */
//    if ((Offset + Size) >= sizeof(SDRRecHdr_T))
//    {    
//        if ( Offset < sizeof(SDRRecHdr_T ))
//        {
//             SDRRecHdr_T SDRHdr;
//			
//            memcpy((uint8_t*)&SDRHdr, (uint8_t*)pSDRRecInNVR, Offset );
//            memcpy(((uint8_t*)&SDRHdr) + Offset, SDRData, sizeof(SDRRecHdr_T) - Offset);
//			
//            (( SDRRecHdr_T*) pSDRRecInNVR)->ID = SDRHdr.ID = RecID;
//            memcpy(  SDRData, ((uint8_t*)&SDRHdr) + Offset, sizeof(SDRRecHdr_T) - Offset );
//			
//            if (FALSE == ValidateSDRSize(SDRHdr.Type, SDRHdr.Len + sizeof (SDRRecHdr_T)))
//            {
//                g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_REQ_INV_LEN;
//                return INVALID_RECORD_ID;
//            }
//            SdrSize = SDRHdr.Len + sizeof (SDRRecHdr_T) + sizeof (E2ROMHdr_T);
//            if(0 != (SdrSize % SDR_ALLOC_UNIT_SIZE))
//            {
//                SdrSize += (SDR_ALLOC_UNIT_SIZE - (SdrSize % SDR_ALLOC_UNIT_SIZE)); 
//            }
//            if (SdrSize > ipmitoh_u16 (g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.FreeSpace))
//            {
//                g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport |= OVERFLOW_FLAG;
//                g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_OUT_OF_SPACE;
//                return INVALID_RECORD_ID;
//            }
//            g_BMCInfo[BMCInst].SDRConfig.PartAddbytes = SdrSize;

//            if ((Offset + Size) > (SDRHdr.Len + sizeof (SDRRecHdr_T)))
//            {
//                g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_DATA_FIELD;
//                return INVALID_RECORD_ID;
//            }
//        }
//        else if ((Offset + Size) > (pSDRRecInNVR->Len + sizeof (SDRRecHdr_T)))
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_DATA_FIELD;
//            return INVALID_RECORD_ID;
//        }
//    }    

//    if  ((IsLast == 1) && ((Offset + Size) != (pSDRRecInNVR->Len + sizeof (SDRRecHdr_T))))
//    {
//        g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INCOMPLETE_WRITTEN_BYTES;
//        return INVALID_RECORD_ID;
//    }

//    WriteSDRRepository (( SDRRecHdr_T*)SDRData, Offset, Size,SdrSize,BMCInst);
//  
//    /* If this is the last data update the data fields and flush. */
//    if (IsLast == 1)
//    {
//        /* Flush the sdr */
//        FlushSDR (SDR_FIRST_FREE_BYTE(BMCInst), g_BMCInfo[BMCInst].SDRConfig.PartAddbytes, nRet,BMCInst);
//#if IPM_DEVICE == 1
//        if (-1 == nRet)
//        {
//            g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_CANNOT_ACCESS_SDR;
//        }
//        else
//        {
//            g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_CANNOT_ACCESS_SDR;
//        }
//#endif

//        /* Update the fields in SDR Repository */
//        g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords ++;
//        g_BMCInfo[BMCInst].SDRConfig.LatestRecordID++;
//        g_BMCInfo[BMCInst].SDRConfig.TrackPOffset=0;

//#if IPM_DEVICE == 1
//        if (g_BMCInfo[BMCInst].Msghndlr.SelfTestByte & GST_SDR_EMPTY)
//        {
//            g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_SDR_EMPTY;
//        }
//#endif

//        g_BMCInfo[BMCInst].SDRConfig.SDRRAM->Size += g_BMCInfo[BMCInst].SDRConfig.PartAddbytes;
//        g_BMCInfo[BMCInst].SDRConfig.SDRRAM->AddTimeStamp        = GetSelTimeStamp(BMCInst);
//        g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.AddTimeStamp = GetSelTimeStamp(BMCInst);
//      
//        /* Update the repository info */
//        UpdateRepositoryInfo (BMCInst);
//        g_BMCInfo[BMCInst].SDRConfig.PartAddbytes =0;

//        /* Invalidate Reservation ID if any */
//        SDR_ReserveSDRRepository (BMCInst);

//	// To send notification to CIM
//	if(g_PDKCIMEventHandle[PDKCIMEVENT_NOTIFYSERVERUPDATETOCIM] != NULL)
//        {
//                uint8 CMD;
//		// Set bits for SDR Event & Add operation
//             CMD = 0x11;
//             ((int(*)(uint8, uint16))g_PDKCIMEventHandle[PDKCIMEVENT_NOTIFYSERVERUPDATETOCIM])(CMD, RecID);
//        }

//    }

//    return RecID;
	
	return 0;
}



///**
// * @brief Delete the SDR.
// * @param ReservationID - SDR reservation id.
// * @param RecordID        - SDR Record ID, which needs to be deleted
// * @return 0 if success, -1 if error.
//**/
//static uint16_t
//SDR_DeleteSDR (uint16_t ReservationID, uint16_t RecID)
//{
//	//TODO:
//	printf("SDR_DeleteSDR not implement\r\n");
//    //#define MARK_FOR_DELETION
//     SDRRecHdr_T*  pSDRRec = NULL;
//    int nRet;
//    BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst];
//#if (0x01 == MARK_FOR_DELETION_SUPPORT)
//     E2ROMHdr_T* pRec = NULL;
//#else
//     uint8_t* pDestLocation = NULL;
//     uint8_t* pSrcData = NULL;
//     uint8_t*	 pFreeBytes= NULL;
//     uint8_t deleteSDR_Size;
//     uint16_t  size;
//#endif

//    /* Bail out with error, if both the conditions are False (Reservation not valid)
//    1. Reservation ID matches, not equal to 0x00 & SDR is not in Update mode  /
//    2. SDR is in Update mode & Reservation ID equals to 0x00
//    */
//    if ( !(((g_BMCInfo[BMCInst].SDRConfig.ReservationID == ReservationID) && (0x00 != ReservationID) && (FALSE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR)) ||
//        ((TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR) && (0x00 == ReservationID))))
//    {
//        if( TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR )
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_SDR_REP_IN_UPDATE_MODE;
//        }else /* Reservation ID doesn't match, return invalid reservation ID */
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_RESERVATION_ID;
//        }
//        return INVALID_RECORD_ID;
//    }

//    while(TRUE)
//    {
//        pSDRRec = ReadSDRRepository(pSDRRec,BMCInst);
//        if (pSDRRec == 0)
//            {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_SDR_REC_NOT_PRESENT;
//            return INVALID_RECORD_ID;
//        }
//        if (pSDRRec->ID == RecID)
//        {
//#if (0x01 == MARK_FOR_DELETION_SUPPORT)
//            pRec = ((E2ROMHdr_T *) pSDRRec) -1;
//            pRec->Valid = 0x01;   /* Mark this record for deletion */
//            FlushSDR((uint8_t *)pRec, sizeof(pRec->Valid), nRet,BMCInst);
//#if IPM_DEVICE == 1
//            if (-1 == nRet)
//            {
//                g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_CANNOT_ACCESS_SDR;
//            }
//            else
//            {
//                g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_CANNOT_ACCESS_SDR;
//            }
//#endif
//            g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords--;
//            g_BMCInfo[BMCInst].SDRConfig.NumMarkedRecords++;
//#else
//            /* Delete SDR - delete the current SDR, and rearrange the subsequent SDR's */
//            pDestLocation = (uint8_t*)(((E2ROMHdr_T *) pSDRRec) -1);
//            deleteSDR_Size = (((E2ROMHdr_T *) pSDRRec) -1)->Len;

//            pSrcData = pDestLocation + deleteSDR_Size;

//            pFreeBytes = (uint8_t*)SDR_FIRST_FREE_BYTE(BMCInst);
//            size = ( uint8_t*) pFreeBytes - ( uint8_t*)pDestLocation;

//            _fmemcpy (pDestLocation, pSrcData, size-deleteSDR_Size);
//            _fmemset ((pFreeBytes - deleteSDR_Size), '\0', deleteSDR_Size );
//            g_BMCInfo[BMCInst].SDRConfig.SDRRAM->Size -= deleteSDR_Size;
//            FlushSDR(pDestLocation, size, nRet,BMCInst);
//#if IPM_DEVICE == 1
//            if (-1 == nRet)
//            {
//                g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_CANNOT_ACCESS_SDR;
//            }
//            else
//            {
//                g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_CANNOT_ACCESS_SDR;
//            }
//#endif
//            g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords--;
//#endif
//            /* Update the SDR Erase Timestamp */
//            g_BMCInfo[BMCInst].SDRConfig.SDRRAM->EraseTimeStamp        = GetSelTimeStamp (BMCInst);
//            g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.EraseTimeStamp = GetSelTimeStamp(BMCInst);

//            /* Store the SDR Ease Time Stamp in NVR */
//            pBMCInfo->GenConfig.SDREraseTime = g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.EraseTimeStamp;
//            FlushIPMI((uint8_t*)&pBMCInfo->GenConfig,(uint8_t*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr,
//                              sizeof(GENConfig_T),BMCInst);

//            /* Update the repository info */
//            UpdateRepositoryInfo (BMCInst);

//            /* Invalidate Reservation ID if any */
//            SDR_ReserveSDRRepository (BMCInst);

//            return RecID;
//        }
//    }
//return 0;

//}

/**
 * @brief Clear the SDR repository.
 * @param ReservationID - SDR reservation id.
 * @param InitOrStatus - Initiate erase or get status flag
 * @return 0 if success, -1 if error.
**/
static int
SDR_ClearSDRRepository (uint16_t ReservationID, uint8_t InitOrStatus)
{
	//TODO:
	printf("SDR_ClearSDRRepository not implement\r\n");
//    int nRet;
//     BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];

//    /* Bail out with error, if both the conditions are False (Reservation not valid)
//    1. Reservation ID matches, not equal to 0x00 & SDR is not in Update mode  /
//    2. SDR is in Update mode & Reservation ID equals to 0x00
//    */
//    if ( !(((g_BMCInfo[BMCInst].SDRConfig.ReservationID == ReservationID) && (0x00 != ReservationID) && (FALSE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR)) ||
//        ((TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR) && (0x00 == ReservationID))))
//    {
//        if( TRUE == g_BMCInfo[BMCInst].SDRConfig.UpdatingSDR )
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_SDR_REP_IN_UPDATE_MODE;
//        }else //Reservation ID doesn't match, return invalid reservation ID.
//        {
//            g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_RESERVATION_ID;
//        }
//        return -1;
//    }

//    // AAh = initiate erase, 00h = get erasure status.
//    if (InitOrStatus != CLEAR_SDR_INITIATE_ERASE &&
//            InitOrStatus != CLEAR_SDR_GET_STATUS)
//    {
//        g_BMCInfo[BMCInst].SDRConfig.SDRError = CC_INV_DATA_FIELD;
//        return -1;
//    }
//    else if (InitOrStatus == CLEAR_SDR_GET_STATUS)
//    {
//        return 0;
//    }
//    _fmemset ((( uint8_t*)g_BMCInfo[BMCInst].SDRConfig.SDRRAM + 16), 0xFF,(pBMCInfo->IpmiConfig.SDRAllocationSize * 1024) - 16 );

//    /* Flush the NVRAM */
//    FlushSDR (g_BMCInfo[BMCInst].SDRConfig.SDRRAM, (pBMCInfo->IpmiConfig.SDRAllocationSize * 1024), nRet,BMCInst);
//#if IPM_DEVICE == 1
//    if (-1 == nRet)
//    {
//        g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_CANNOT_ACCESS_SDR;
//    }
//    else
//    {
//        g_BMCInfo[BMCInst].Msghndlr.SelfTestByte &= ~GST_CANNOT_ACCESS_SDR;
//    }
//#endif

//    /* Clear the fields of the SDR */
//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords = 0;
//    g_BMCInfo[BMCInst].SDRConfig.LatestRecordID =0;
//#if (0x01 == MARK_FOR_DELETION_SUPPORT)
//    g_BMCInfo[BMCInst].SDRConfig.NumMarkedRecords=0;
//#endif
//    if (g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport & OVERFLOW_FLAG)
//    {
//        g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport &= ~OVERFLOW_FLAG;
//    }

//#if IPM_DEVICE == 1
//    g_BMCInfo[BMCInst].Msghndlr.SelfTestByte |= GST_SDR_EMPTY;
//#endif

//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->Size                  = 16;
//    g_BMCInfo[BMCInst].SDRConfig.SDRRAM->EraseTimeStamp        = GetSelTimeStamp (BMCInst);
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.EraseTimeStamp = GetSelTimeStamp(BMCInst);

//    /* Store the SDR Ease Time Stamp in NVR */
//    pBMCInfo->GenConfig.SDREraseTime = g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.EraseTimeStamp;
//    FlushIPMI((uint8_t*)&pBMCInfo->GenConfig,(uint8_t*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr,
//                      sizeof(GENConfig_T),BMCInst);

//    /* Update the Repository Info */
//    UpdateRepositoryInfo (BMCInst);

//    /* Invalidate Reservation ID if any */
//    SDR_ReserveSDRRepository (BMCInst);

    return 0;
}



/**
 * @brief Get the last SDR record.
 * @return the last SDR record.
**/
static  SDRRecHdr_T*
GetLastSDRRec ()
{
     SDRRecHdr_T*  pSDRRec;

    pSDRRec = SDR_GetFirstSDRRec ();
    while (TRUE)
    {
         SDRRecHdr_T*  pCurSDRRec;

        /* Save this record and get the next record */
        pCurSDRRec = pSDRRec;
        pSDRRec    = SDR_GetNextSDRRec (pSDRRec);

        /* If we have reached past the last return the last record */
        if (0 == pSDRRec)
        {
            return pCurSDRRec;
        }
    }
}


///**
// * @brief Update SDR repository information.
//**/
//static void
//UpdateRepositoryInfo ()
//{
//	//TODO:
//	printf("UpdateRepositoryInfo not implement\r\n");
	// BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//    /* Update the version */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.Version = SDR_VERSION;

//    /* Update the record count */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.RecCt = htoipmi_u16 (g_BMCInfo[BMCInst].SDRConfig.SDRRAM->NumRecords);

//    /* Update the free space available */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.FreeSpace = htoipmi_u16 (((pBMCInfo->IpmiConfig.SDRAllocationSize * 1024) - g_BMCInfo[BMCInst].SDRConfig.SDRRAM->Size));

//    /* Update the the operation support */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport=NO_SUPPORT;

//     if(g_PDKCmdsHandle[PDKCMDS_PDKISCOMMANDENABLED]!= NULL)
//     {
//        if(((int(*)(uint8_t,uint8_t*,uint8_t,int))g_PDKCmdsHandle[PDKCMDS_PDKISCOMMANDENABLED])(NETFN_STORAGE,NULL,CMD_RESERVE_SDR_REPOSITORY,BMCInst) == 0)
//        {
//           g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport|=RESERVE_SDR_SUPPORT;
//        }
//        if(((int(*)(uint8_t,uint8_t*,uint8_t,int))g_PDKCmdsHandle[PDKCMDS_PDKISCOMMANDENABLED])(NETFN_STORAGE,NULL,CMD_GET_SDR_REPOSITORY_ALLOCATION_INFO,BMCInst) == 0)
//        {
//           g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport|=NON_MODAL_SUPPORT+GET_SDR_REPOSITORY_ALLOC_SUPPORT;
//        }
//        if(((int(*)(uint8_t,uint8_t*,uint8_t,int))g_PDKCmdsHandle[PDKCMDS_PDKISCOMMANDENABLED])(NETFN_STORAGE,NULL,CMD_PARTIAL_ADD_SDR,BMCInst) == 0)
//        {      
//           g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport|=PARTIAL_ADD_SDR_SUPPORT;
//        }
//        if(((int(*)(uint8_t,uint8_t*,uint8_t,int))g_PDKCmdsHandle[PDKCMDS_PDKISCOMMANDENABLED])(NETFN_STORAGE,NULL,CMD_DELETE_SDR,BMCInst) == 0)
//        {
//           g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.OpSupport|=DELETE_SDR_SUPPORT;
//        }
//     }

//    /* Update the repository allocation information */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryAllocInfo.NumAllocUnits     = htoipmi_u16 (((pBMCInfo->IpmiConfig.SDRAllocationSize * 1024) - 16) / SDR_ALLOC_UNIT_SIZE); /* Because 16 bytes are reserved for header info */
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryAllocInfo.AllocUnitSize     = htoipmi_u16 (SDR_ALLOC_UNIT_SIZE);
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryAllocInfo.NumFreeAllocUnits = htoipmi_u16 (ipmitoh_u16 (g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.FreeSpace) /
//                                                SDR_ALLOC_UNIT_SIZE);
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryAllocInfo.LargestFreeBlock  = htoipmi_u16 (ipmitoh_u16 (g_BMCInfo[BMCInst].SDRConfig.RepositoryInfo.FreeSpace) /
//                                                SDR_ALLOC_UNIT_SIZE);
//    g_BMCInfo[BMCInst].SDRConfig.RepositoryAllocInfo.MaxRecSize        = SDR_MAX_RECORD_SIZE / SDR_ALLOC_UNIT_SIZE;
//}


///**
// * @brief SDR initialization agent.
//**/
//static void
//SDRInitAgent ()
//{
//	//TODO:
//	printf("SDRInitAgent not implement\r\n");
//    uint8_t             i,Count =0;
//    uint8_t             CmdRes [MAX_RES_LEN];
//     SDRRecHdr_T*      pSDRRec;
//    HQueue_T IfcQ;
//     BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];

//    if(g_PDKHandle[PDK_BEFOREINITAGENT] != NULL)
//    {
//         if(-1 == ((int(*)(int))g_PDKHandle[PDK_BEFOREINITAGENT]) (BMCInst))
//        {
//            return;
//        }
//    }


//#if SET_EVENT_RECEIVER == 1
//    /* Turn off Event Generation */
//    {
//        SetEvtRcvReq_T SetEvtRcvReq = { 0xFF, 0 };
//        SetEventReceiver (( uint8_t*)&SetEvtRcvReq,
//                          sizeof (SetEvtRcvReq_T), CmdRes,BMCInst);
//    }
//#endif
//    /* Get the MMC Controller addresses*/
//    pSDRRec = SDR_GetFirstSDRRec (BMCInst);

//        if(0 != GetQueueHandle(LAN_IFC_Q,&IfcQ,BMCInst))
//        {
//            IPMI_WARNING("Error in getting LanIfcQ Handle \n");
//        }

//        for (i=0; i < pBMCInfo->SDRConfig.SDRRAM->NumRecords && pSDRRec != NULL; i++)
//        {
//            if(MANAGEMENT_DEV_LOC_REC == pSDRRec->Type)
//            {
//                 MgmtCtrlrDevLocator_T* pMgmtDevLocRec = ( MgmtCtrlrDevLocator_T*)pSDRRec;
//                if(pBMCInfo->IpmiConfig.BMCSlaveAddr !=  pMgmtDevLocRec->DevSlaveAddr )
//                {
//                    pBMCInfo->MgmtTbl[Count].OWNERID=pMgmtDevLocRec->DevSlaveAddr; 
//                    pBMCInfo->MgmtTbl[Count++].PowerNotification=pMgmtDevLocRec->PowerStateNotification;
//                }
//            }
//            pSDRRec = SDR_GetNextSDRRec (pSDRRec,BMCInst);
//        }
//        pBMCInfo->MgmtTbl[Count].OWNERID= 0xff;

//#if SUPPORT_MULTI_CONTROLLER   == 1
//        /* Sending the Set Event Reciver Disable Command to all MMC in IPMB BUS */
//        if(pBMCInfo->IpmiConfig.PrimaryIPMBSupport == 0x01)
//        {
//            for(i=0; i<Count; i++)
//            {
//                MsgPkt_T		Req;
//                memset(&Req,0,sizeof(MsgPkt_T));
//                IPMIMsgHdr_T*	pIPMIMsgHdr = (IPMIMsgHdr_T*)Req.Data;
//                  SetEvtRcvReq_T* SetEvtRcvReq = ( SetEvtRcvReq_T*) &Req.Data[sizeof(IPMIMsgHdr_T)];
//                pIPMIMsgHdr->ResAddr	=pBMCInfo->MgmtTbl[i].OWNERID;
//                pIPMIMsgHdr->NetFnLUN	 = (NETFN_SENSOR<< 2) | BMC_LUN_00;
//                pIPMIMsgHdr->ChkSum 	= ~(pIPMIMsgHdr->ResAddr + pIPMIMsgHdr->NetFnLUN) + 1;
//                pIPMIMsgHdr->ReqAddr	= pBMCInfo->IpmiConfig.BMCSlaveAddr;
//                pBMCInfo->SDRConfig.IPMB_Seqnum++;
//                if (pBMCInfo->SDRConfig.IPMB_Seqnum >= 0x3F) { pBMCInfo->SDRConfig.IPMB_Seqnum = 0xFF; }
//                pIPMIMsgHdr->RqSeqLUN =   pBMCInfo->SDRConfig.IPMB_Seqnum<< 2;  /* Request Seq Num */
//                pIPMIMsgHdr->RqSeqLUN  |= BMC_LUN_00;       /* LUN =00 */
//                pIPMIMsgHdr->Cmd		= CMD_SET_EVENT_RECEIVER;
//                SetEvtRcvReq->RcvSlaveAddr 	  =0xFF ;
//                SetEvtRcvReq->RcvLUN =BMC_LUN_00;
//                Req.Param=BRIDGING_REQUEST;
//                Req.Channel=PRIMARY_IPMB_CHANNEL;
//                Req.Data [sizeof (IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T)] =
//                CalculateCheckSum2 (Req.Data, sizeof (IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T));
//                Req.Size = sizeof(IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T) +1 ; //Plus 1 for Check sum
//                /* Post Msg to IPMB  task  to send the set event  receiver	*/
//                if ( -1 != IfcQ )
//                {
//                    if(0 != PostMsg(&Req, IPMB_PRIMARY_IFC_Q,BMCInst))
//                    {
//                        IPMI_WARNING ("SDR.c : Error posting message to IPMBIfc_Q\n");
//                    }
//                    pBMCInfo->MgmtTbl[i].Status =TRUE;
//                }
//            }
//        }

//#endif


//#if SUPPORT_MULTI_CONTROLLER   == 1
//        /* Sending the Run Initalization Command to all MMC in IPMB BUS */
//        if(pBMCInfo->IpmiConfig.PrimaryIPMBSupport == 0x01)
//        {
//            for(i=0; i<Count; i++)
//            {
//                MsgPkt_T		Req;
//                memset(&Req,0,sizeof(MsgPkt_T));
//                IPMIMsgHdr_T*	pIPMIMsgHdr = (IPMIMsgHdr_T*)Req.Data;
//                pIPMIMsgHdr->ResAddr	=pBMCInfo->MgmtTbl[i].OWNERID;
//                pIPMIMsgHdr->NetFnLUN	 = (NETFN_STORAGE<< 2) | BMC_LUN_00;
//                /* Get Device ID */		 
//                //		 pIPMIMsgHdr->NetFnLUN	 = (NETFN_APP<< 2) | BMC_LUN_00;
//                pIPMIMsgHdr->ChkSum 	= ~(pIPMIMsgHdr->ResAddr + pIPMIMsgHdr->NetFnLUN) + 1;
//                pIPMIMsgHdr->ReqAddr	= pBMCInfo->IpmiConfig.BMCSlaveAddr;
//                Req.Channel=PRIMARY_IPMB_CHANNEL; 

//                g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum++;
//                if (g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum >= 0x3F) { g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum = 0xFF; }
//                pIPMIMsgHdr->RqSeqLUN =   g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum<< 2;	/* Request Seq Num */
//                pIPMIMsgHdr->RqSeqLUN  |= BMC_LUN_00; 	  /* LUN =00 */
//                Req.Param=BRIDGING_REQUEST;
//                pIPMIMsgHdr->Cmd		= CMD_RUN_INITIALIZATION_AGENT;
//                Req.Data[sizeof(IPMIMsgHdr_T)]=0x1; 
//                Req.Data [sizeof (IPMIMsgHdr_T) + 1] =
//                CalculateCheckSum2 (Req.Data, sizeof (IPMIMsgHdr_T) +1);
//                Req.Size = sizeof(IPMIMsgHdr_T) + 2;  //Plus 2 for  req data's

//                if ( -1 !=IfcQ  )
//                {
//                    if(0 != PostMsg(&Req, IPMB_PRIMARY_IFC_Q,BMCInst))
//                    {
//                        IPMI_WARNING ("SDR.c : Error posting message to IPMBIfc_Q\n");
//                    }
//                    pBMCInfo->MgmtTbl[i].Status =TRUE;
//                }
//            }
//        }
//#endif	


//    pSDRRec = SDR_GetFirstSDRRec (BMCInst);
//    for (i=0; i < pBMCInfo->SDRConfig.SDRRAM->NumRecords && pSDRRec != NULL; i++)
//    {
//        if (FULL_SDR_REC == pSDRRec->Type)
//        {
//            /* For all records of type 01h */
//             FullSensorRec_T* pFullRec = ( FullSensorRec_T*)pSDRRec;
//            uint16_t  ValidMask = htoipmi_u16(0x0FFF); 
//            // If not a threshold sensor, then 15 event bits are used.
//            if (pFullRec->EventTypeCode != 0x01)
//            {
//                ValidMask = htoipmi_u16(0x7FFF);
//            }
//            /* Disable Event & Scanning messages, if Disable is supported */
//            if (0x03 != (pFullRec->SensorCaps & 0x03))
//            {
//                SetSensorEventEnableReq_T SetSEReq;

//                // disable all events for sensor 
//                SetSEReq.SensorNum       = pFullRec->SensorNum;
//                SetSEReq.Flags		 = DISABLE_SELECTED_EVENT_MSG; // Event Disabled
//                SetSEReq.AssertionMask   = ValidMask;
//                SetSEReq.DeAssertionMask = ValidMask;

//                SetSensorEventEnable (( uint8_t*)&SetSEReq,
//                sizeof (SetSensorEventEnableReq_T), CmdRes,BMCInst);
//            }

//        /* Set Sensor Type */
//#if SET_SENSOR_TYPE != UNIMPLEMENTED
//            if (pFullRec->SensorInit & BIT2)
//            {
//                /* Set Sensor Type */
//                SetSensorTypeReq_T SetSensorTypeReq;
//                SetSensorTypeReq.SensorNum 	 = pFullRec->SensorNum;
//                SetSensorTypeReq.SensorType	 = pFullRec->SensorType;
//                SetSensorTypeReq.EventTypeCode  = pFullRec->EventTypeCode;
//                SetSensorType (( uint8_t*)&SetSensorTypeReq, sizeof(SetSensorTypeReq), CmdRes,BMCInst);
//            }
//#endif

//            /* Set Sensor Thresholds */
//            {
//                SetSensorThresholdReq_T SetThresholdReq;

//                SetThresholdReq.SensorNum            = pFullRec->SensorNum;
//                SetThresholdReq.SetFlags             = ((pFullRec->DiscreteReadingMask >> 8) & 0x3F);
//                if  (pFullRec->SensorInit & BIT4)
//                {
//                    SetThresholdReq.LowerNonCritical     = pFullRec->LowerNonCritical;
//                    SetThresholdReq.LowerCritical        = pFullRec->LowerCritical;
//                    SetThresholdReq.LowerNonRecoverable  = pFullRec->LowerNonRecoverable;
//                    SetThresholdReq.UpperNonCritical     = pFullRec->UpperNonCritical;
//                    SetThresholdReq.UpperCritical        = pFullRec->UpperCritical;
//                    SetThresholdReq.UpperNonRecoverable  = pFullRec->UpperNonRecoverable;

//                    SetSensorThresholds (( uint8_t*)&SetThresholdReq,
//                                                        sizeof (SetSensorThresholdReq_T), CmdRes,BMCInst);
//                }
//            }

//            /* Set Sensor Hysteresis */
//            {
//                SetSensorHysterisisReq_T SetHysteresisReq;

//                SetHysteresisReq.SensorNum           = pFullRec->SensorNum;
//                SetHysteresisReq.Reserved            = 0;
//                if  (pFullRec->SensorInit & BIT3) //Added for DR#31091
//                {
//                    SetHysteresisReq.PositiveHysterisis  = pFullRec->PositiveHysterisis;
//                    SetHysteresisReq.NegativeHysterisis  = pFullRec->NegativeHysterisis;

//                    SetSensorHysterisis (( uint8_t*)&SetHysteresisReq,
//                    sizeof (SetSensorHysterisisReq_T), CmdRes,BMCInst);
//                }
//            }

//            /* Enable Event & Scanning messages, if Disabled */
//            if (0x03 != (pFullRec->SensorCaps & 0x03))
//            {
//                SetSensorEventEnableReq_T SetSEReq;

//                SetSEReq.SensorNum       = pFullRec->SensorNum;
//                SetSEReq.Flags           = (pFullRec->SensorInit & BIT6) | ((pFullRec->SensorInit & BIT5) << 2) | ENABLE_SELECTED_EVENT_MSG; // Event Enabled
//                SetSEReq.AssertionMask   = (pFullRec->AssertionEventMask & ValidMask);
//                SetSEReq.DeAssertionMask = (pFullRec->DeAssertionEventMask & ValidMask);

//                SetSensorEventEnable (( uint8_t*)&SetSEReq,
//                                                        sizeof (SetSensorEventEnableReq_T), CmdRes,BMCInst);
//            }
//        }

//        if (pSDRRec->Type == COMPACT_SDR_REC)
//        {
//             CompactSensorRec_T* pCompactRec = ( CompactSensorRec_T*)pSDRRec;
//            uint16_t  ValidMask = htoipmi_u16(0x0FFF); 
//            // If not a threshold sensor, then 15 event bits are used.
//            if (pCompactRec->EventTypeCode != 0x01)
//            {
//                ValidMask = htoipmi_u16(0x7FFF);
//            }

//            /* Disable Event & Scanning messages, if Disable is supported */
//            if (0x03 != (pCompactRec->SensorCaps & 0x03))
//            {
//                SetSensorEventEnableReq_T SetSEReq;

//                SetSEReq.SensorNum       = pCompactRec->SensorNum;
//                SetSEReq.Flags		 = DISABLE_SELECTED_EVENT_MSG; // Event Disabled
//                SetSEReq.AssertionMask   = ValidMask;
//                SetSEReq.DeAssertionMask = ValidMask;

//                SetSensorEventEnable (( uint8_t*)&SetSEReq,
//                sizeof (SetSensorEventEnableReq_T), CmdRes,BMCInst);
//            }

//        /* Set Sensor Type */
//#if SET_SENSOR_TYPE != UNIMPLEMENTED
//            if (pCompactRec->SensorInit & BIT2)
//            {
//                /* Set Sensor Type */
//                SetSensorTypeReq_T SetSensorTypeReq;
//                SetSensorTypeReq.SensorNum 	 = pCompactRec->SensorNum;
//                SetSensorTypeReq.SensorType	 = pCompactRec->SensorType;
//                SetSensorTypeReq.EventTypeCode  = pCompactRec->EventTypeCode;
//                SetSensorType (( uint8_t*)&SetSensorTypeReq, sizeof(SetSensorTypeReq), CmdRes,BMCInst);
//            }
//#endif

//            /* Set Sensor Hysteresis */
//            {
//                SetSensorHysterisisReq_T SetHysteresisReq;

//                SetHysteresisReq.SensorNum           = pCompactRec->SensorNum;
//                SetHysteresisReq.Reserved            = 0;
//                SetHysteresisReq.PositiveHysterisis  = pCompactRec->PositiveHysteris;
//                SetHysteresisReq.NegativeHysterisis  = pCompactRec->NegativeHysterisis;

//                SetSensorHysterisis (( uint8_t*)&SetHysteresisReq,
//                                                    sizeof (SetSensorHysterisisReq_T), CmdRes,BMCInst);
//            }

//            /* Enable Event & Scanning messages, if Disabled */
//            if (0x03 != (pCompactRec->SensorCaps & 0x03))
//            {
//                SetSensorEventEnableReq_T SetSEReq;

//                SetSEReq.SensorNum       = pCompactRec->SensorNum;
//                SetSEReq.Flags           = (pCompactRec->SensorInit & BIT6) | ((pCompactRec->SensorInit & BIT5) << 2) |ENABLE_SELECTED_EVENT_MSG ; // Event Enabled
//                SetSEReq.AssertionMask   = (pCompactRec->AssertionEventMask & ValidMask);
//                SetSEReq.DeAssertionMask = (pCompactRec->DeAssertionEventMask & ValidMask);

//                SetSensorEventEnable (( uint8_t*)&SetSEReq,
//                                                        sizeof (SetSensorEventEnableReq_T), CmdRes,BMCInst);
//            }
//        }
//    pSDRRec = SDR_GetNextSDRRec (pSDRRec,BMCInst);
//    }



//#if SET_EVENT_RECEIVER == 0
//    /* Enable Event Generation */
//    {
//        SetEvtRcvReq_T SetEvtRcvReq = { 0x20, 0 };
//        SetEventReceiver (( uint8_t*)&SetEvtRcvReq, 
//                                        sizeof (SetEvtRcvReq_T), CmdRes,BMCInst);
//    }
//#endif


//#if SUPPORT_MULTI_CONTROLLER   == 1

//    /* Sending the Set Event Reciver enable Command to all MMC in IPMB BUS */
//    for(i=0;i<Count;i++)
//    {
//        MsgPkt_T        Req;
//        IPMIMsgHdr_T*   pIPMIMsgHdr = (IPMIMsgHdr_T*)Req.Data;
//          SetEvtRcvReq_T* SetEvtRcvReq = ( SetEvtRcvReq_T*) &Req.Data[sizeof(IPMIMsgHdr_T)];
//        pIPMIMsgHdr->ResAddr    =pBMCInfo->MgmtTbl[i].OWNERID;
//        pIPMIMsgHdr->NetFnLUN   = (NETFN_SENSOR<< 2) | BMC_LUN_00;
//        pIPMIMsgHdr->ChkSum     = ~(pIPMIMsgHdr->ResAddr + pIPMIMsgHdr->NetFnLUN) + 1;
//        pIPMIMsgHdr->ReqAddr    = pBMCInfo->IpmiConfig.BMCSlaveAddr;
//        Req.Channel=PRIMARY_IPMB_CHANNEL;

//        g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum++;
//        if (g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum >= 0x3F) { g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum = 0xFF; }
//        pIPMIMsgHdr->RqSeqLUN =   g_BMCInfo[BMCInst].SDRConfig.IPMB_Seqnum<< 2;  /* Request Seq Num */
//        pIPMIMsgHdr->RqSeqLUN  |= BMC_LUN_00;       /* LUN =00 */
//        pIPMIMsgHdr->Cmd        = CMD_SET_EVENT_RECEIVER;
//        SetEvtRcvReq->RcvSlaveAddr       = pBMCInfo->IpmiConfig.BMCSlaveAddr;
//        SetEvtRcvReq->RcvLUN =BMC_LUN_00;
//        Req.Param=BRIDGING_REQUEST;
//        Req.Data [sizeof (IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T)] =
//        CalculateCheckSum2 (Req.Data, sizeof (IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T));
//        Req.Size = sizeof(IPMIMsgHdr_T) + sizeof(SetEvtRcvReq_T)+1; // plus 1 for checksum

//        /* Post Msg to IPMB  task  to send the set event  receiver  */
//        if ( -1 != IfcQ )
//        {
//            if(0 != PostMsg(&Req, IPMB_PRIMARY_IFC_Q,BMCInst))
//            {
//                IPMI_WARNING ("SDR.c : Error posting message to IPMBIfc_Q\n");
//            }
//            pBMCInfo->MgmtTbl[i].Status =TRUE;
//        }
//        //PDK_SMCDelay(pBMCInfo->MgmtTbl[i].OWNERID);
//        //PDK_SMCDelay(0x40);
//        //sleep(3);
//    }


//#endif

//    if(g_PDKHandle[PDK_AFTERINITAGENT] != NULL)
//    {
//         ((int(*)(uint8_t,int))g_PDKHandle[PDK_AFTERINITAGENT]) (CmdRes[0],BMCInst);
//    }

//    return;
//}

#endif /* SDR_DEVICE */