/***************************************************************** ***************************************************************** *** ** *** (C)Copyright 2005-2006, American Megatrends Inc. ** *** ** *** All Rights Reserved. ** *** ** *** 6145-F, Northbelt Parkway, Norcross, ** *** ** *** Georgia - 30071, USA. Phone-(770)-246-8600. ** *** ** ***************************************************************** ***************************************************************** ****************************************************************** * * sensor.c * Sensor functions. * * Author: Govind Kothandapani * Bakka Ravinder Reddy ******************************************************************/ #include "MsgHndlr.h" #include "sensor_tbl.h" #include "com_IPMI_Sensor.h" #include "Support.h" #include "Sensor.h" #include "SDRFunc.h" #include "SensorEvent.h" #include #include "main.h" /* Reserved bit macro definitions */ #define RESERVED_BITS_SETSENSORTYPE 0X80 //(BIT7) #define RESERVED_BITS_REARMSENSOR_REARMALLEVENTS 0X7F //(BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1 | BIT0) #define RESERVED_BITS_REARMSENSOR_REARMASSEVT2_1 0XF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_REARMSENSOR_REARMDEASSEVT2_1 0XF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_REARMSENSOR_REARMASSEVT2_2 0X80 //(BIT7) #define RESERVED_BITS_REARMSENSOR_REARMDEASSEVT2_2 0X80 //(BIT7) #define RESERVED_BITS_SETSENSORTHRESHOLDS 0XC0 //(BIT7 | BIT6) #define RESERVED_BITS_SETSENEVTEN_FLAGS 0X0F //(BIT3 | BIT2 | BIT1 | BIT0) #define RESERVED_BITS_SETSENEVTEN_ASSERTIONMASK 0X8000 #define RESERVED_BITS_SETSENEVTEN_DEASSERTIONMASK 0X8000 #define RESERVED_BITS_SETSENRD_ASSEVTOCCBYTE_1 0xF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_SETSENRD_DEASSEVTOCCBYTE_1 0xF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_SETSENRD_ASSEVTOCCBYTE_2 0x80 //(BIT7) #define RESERVED_BITS_SETSENRD_DEASSEVTOCCBYTE_2 0x80 //(BIT7) #define SENSOR_THRESOLD_ACCESS_BITS 0x0c //(BIT2 | BIT3) #define SENSOR_HYSTERESIS_ACCESS_BITS 0x30 //(BIT4 | BIT5) #if SENSOR_DEVICE == 1 /*** Local Definitions ***/ //#define NUM_SENSORS() (g_BMCInfo.SenConfig.NumThreshSensors + g_BMCInfo.SenConfig.NumNonThreshSensors) #define FULL_SDR_REC 0x01 #define COMPACT_SDR_REC 0x02 #define OEM_SDR_FRU_REC 0xf1 #define OEM_SDR_NM_REC 0x0D #define FL_STATIC_SENSOR 0x00 #define FL_NUM_LUN(NUM_LUN) NUM_LUN #define LWR_NON_CRIT 0x01 #define LWR_CRIT 0x02 #define LWR_NON_REC 0x04 #define UPR_NON_CRIT 0x08 #define UPR_CRIT 0x10 #define UPR_NON_REC 0x20 #define EVENT_MSG_MASK 0x80 #define SCAN_MASK 0x40 #define ENABLE_DISABLE_EVENT_MASK 0x30 #define DO_NOT_CHANGE 0x00 #define ENABLE_SELECTED_EVENT_MSG 0x10 #define DISABLE_SELECTED_EVENT_MSG 0x20 #define CC_INVALID_ATTEMPT_TO_SET 0x80 #define MIN_SET_SEN_READING_CMD_LEN 3 #define LEN_FOR_EVT_DATA 10 #define MAX_SET_SEN_READ_LEN 10 #define LEN_FOR_ASSERT_DATA 5 #define LEN_FOR_DEASSERT_DATA 7 #define LEN_FOR_SETSENSOR_DATA 3 #define NOT_FOUND_SCAN_DISABLED -1 #define NOT_FOUND_SCAN_ENABLED -2 #define ENTITY_FOUND 1 #define ENTITY_NOT_FOUND 0 #define DCMI_TEMP_READING 0x0 #define DCMI_INST_NUMBER 0x1 /*** Local typedefs ***/ /** * @struct SR_SensorInfo_T * @brief Sensor Information. **/ typedef struct { /* CAUTION Order of members dependent on Response structures */ uint8_t M_LSB; uint8_t M_MSB_Tolerance; uint8_t B_LSB; uint8_t B_MSB_Accuracy; uint8_t Accuracy_MSB_Exp; uint8_t RExp_BExp; uint8_t PositiveHysterisis; uint8_t NegativeHysterisis; uint8_t LowerNonCritical; uint8_t LowerCritical; uint8_t LowerNonRecoverable; uint8_t UpperNonCritical; uint8_t UpperCritical; uint8_t UpperNonRecoverable; uint8_t EventFlags; uint16_t AssertionMask; uint16_t DeAssertionMask; uint8_t EventTypeCode; uint16_t ReadWriteThreshMask; uint8_t SensorInit; uint8_t SensorNum; } SR_SensorInfo_T; /*** Global Variables ***/ // uint8_t g_NumThreshSensors; // uint8_t g_NumNonThreshSensors; // uint8_t g_FRUInfo[MAX_PDK_FRU_SUPPORTED]; //FRUInfo_T *m_FRUInfo[MAX_PDK_FRU_SUPPORTED]; //uint8_t m_total_frus=0; //Sensor-Type Sensor-specific-offset static const uint8_t sensor_presence [][2] = { {PROCESSOR, PROCESSOR_PRESENCE_DETECTED}, {POWER_SUPPLY, POWER_SUPPLY_PRESENCE_DETECTED}, {POWER_SUPPLY, POWER_SUPPLY_OUT_OF_RANGE_PRESENT}, {MEMORY, MEMORY_PRESENCE_DETECTED}, {ENTITY_PRESENCE, ENTITY_PRESENCE_ENTITY_PRESENT}, {BATTERY, BATTERY_PRESENCE_DETECTED} }; #define SENSOR_PRESENCE_COUNT (sizeof(sensor_presence)/ sizeof(sensor_presence[0])) /*** Prototype Declaration ***/ //static void FindNumSensors (void); /*--------------------------------------- * InitSensor *---------------------------------------*/ int InitSensorInfo () { SensorInfo_T* pSensorInfo; SensorSharedMem_T* pSMSharedMem; SDRRecHdr_T* pSDRRec; int i; pSMSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; /* Update Sensor Properties & Get SDR & initialize sensors */ for (i = 0; i < g_BMCInfo.SenConfig.ValidSensorCnt; i++) { pSensorInfo = (SensorInfo_T*)&pSMSharedMem->SensorInfo [i]; g_BMCInfo.SenConfig.ValidSensorList[i] = sensor_tbl[i].sensor_number; pSensorInfo->SensorNumber = sensor_tbl[i].sensor_number; pSensorInfo->SensorReading = 0; pSensorInfo->SensorMonitorInterval = sensor_tbl[i].monitor_interval; pSensorInfo->SensorState = sensor_tbl[i].monitor_state; pSensorInfo->PowerOnDelay = sensor_tbl[i].poweron_delay; pSensorInfo->SysResetDelay = sensor_tbl[i].reset_delay; pSDRRec = SR_FindSDR(pSensorInfo->SensorNumber); SR_LoadSDRDefaults(pSDRRec, pSensorInfo); pSensorInfo->SDRRec = (SDRRecHdr_T*)pSDRRec; } return 0; } /*--------------------------------------- * InitSensor *---------------------------------------*/ int InitSensorDev () { int i; sensor_tbl_t* pSensorDev = NULL; for(i=0;idevice_init(); } return 0; } /*----------------------------------------- * SR_FindSDR *-----------------------------------------*/ SDRRecHdr_T* SR_FindSDR (uint8_t SensorNum) { SDRRecHdr_T* sr = SDR_GetFirstSDRRec (); FullSensorRec_T* sfs = NULL; CompactSensorRec_T* scs = NULL; while(sr != 0) { if (sr->Type == FULL_SDR_REC) { sfs = (FullSensorRec_T*) sr; if (sfs->SensorNum == SensorNum) { return sr; } } else if (sr->Type == COMPACT_SDR_REC) { scs = (CompactSensorRec_T*) sr; if (scs->SensorNum == SensorNum) { return sr; } } /* Get the next record */ sr = SDR_GetNextSDRRec (sr); } return NULL; } /*----------------------------------------- * SR_LoadSDRDefaults * CAUTION !! this function has to be called * after acquiring a sensor shared memory mutex *-----------------------------------------*/ extern void SR_LoadSDRDefaults (SDRRecHdr_T* sr, SensorInfo_T* pSensorInfo) { FullSensorRec_T* sfs; CompactSensorRec_T* scs; // Populater sensor information for Threshold sensors if (sr->Type == FULL_SDR_REC) { sfs = ( FullSensorRec_T*) sr; pSensorInfo->SensorOwnerLun = sfs->OwnerLUN; /* Multi-LUN support */ pSensorInfo->SensorNumber = sfs->SensorNum; pSensorInfo->M_LSB = sfs->M; pSensorInfo->M_MSB_Tolerance = sfs->M_Tolerance; pSensorInfo->B_LSB = sfs->B; pSensorInfo->B_MSB_Accuracy = sfs->B_Accuracy; pSensorInfo->Accuracy_MSB_Exp = sfs->Accuracy; pSensorInfo->RExp_BExp = sfs->R_B_Exp; pSensorInfo->Units1 = sfs->Units1; pSensorInfo->Units2 = sfs->Units2; pSensorInfo->Units3 = sfs->Units3; pSensorInfo->RecordID = sfs->hdr.ID; pSensorInfo->PosHysteresis = sfs->PositiveHysterisis; pSensorInfo->NegHysteresis = sfs->NegativeHysterisis; pSensorInfo->SensorInit = sfs->SensorInit; pSensorInfo->SettableThreshMask = (sfs->DiscreteReadingMask); pSensorInfo->SensorCaps = sfs->SensorCaps; pSensorInfo->SensorTypeCode = sfs->SensorType; pSensorInfo->OEMField = sfs->OEMField ; if (pSensorInfo->SensorInit & BIT4) { if (pSensorInfo->SettableThreshMask & BIT8) { pSensorInfo->LowerNonCritical = sfs->LowerNonCritical; } if (pSensorInfo->SettableThreshMask & BIT9) { pSensorInfo->LowerCritical = sfs->LowerCritical; } if (pSensorInfo->SettableThreshMask & BIT10) { pSensorInfo->LowerNonRecoverable = sfs->LowerNonRecoverable; } if (pSensorInfo->SettableThreshMask & BIT11) { pSensorInfo->UpperNonCritical = sfs->UpperNonCritical; } if (pSensorInfo->SettableThreshMask & BIT12) { pSensorInfo->UpperCritical = sfs->UpperCritical; } if (pSensorInfo->SettableThreshMask & BIT13) { pSensorInfo->UpperNonRecoverable = sfs->UpperNonRecoverable; } } pSensorInfo->EventFlags = 0; pSensorInfo->EventFlags |= sfs->SensorInit & BIT6; pSensorInfo->EventFlags |= (sfs->SensorInit & BIT5) << 2; pSensorInfo->EventFlags |= sfs->SensorInit & BIT5; pSensorInfo->AssertionEventEnablesByte1 = (sfs->AssertionEventMask) & 0xFF; pSensorInfo->AssertionEventEnablesByte2 = ((sfs->AssertionEventMask) >> 8) & 0xFF; pSensorInfo->DeassertionEventEnablesByte1= (sfs->DeAssertionEventMask) & 0xFF; pSensorInfo->DeassertionEventEnablesByte2= ((sfs->DeAssertionEventMask) >> 8) & 0xFF; pSensorInfo->EventTypeCode = sfs->EventTypeCode; pSensorInfo->SensorReadType = sfs->EventTypeCode; } else if (sr->Type == COMPACT_SDR_REC) { scs = ( CompactSensorRec_T*) sr; pSensorInfo->SensorOwnerLun = scs->OwnerLUN; /* Multi-LUN support */ pSensorInfo->SensorNumber = scs->SensorNum; pSensorInfo->EventFlags = 0; pSensorInfo->EventFlags |= scs->SensorInit & BIT6; pSensorInfo->EventFlags |= (scs->SensorInit & BIT5) << 2; pSensorInfo->EventFlags |= scs->SensorInit & BIT5; pSensorInfo->AssertionEventEnablesByte1 = (scs->AssertionEventMask) & 0xFF; pSensorInfo->AssertionEventEnablesByte2 = ((scs->AssertionEventMask) >> 8) & 0xFF; pSensorInfo->DeassertionEventEnablesByte1= (scs->DeAssertionEventMask) & 0xFF; pSensorInfo->DeassertionEventEnablesByte2= ((scs->DeAssertionEventMask) >> 8) & 0xFF; pSensorInfo->SensorInit = scs->SensorInit; pSensorInfo->SettableThreshMask = (scs->DiscreteReadingMask); pSensorInfo->PosHysteresis = scs->PositiveHysteris; pSensorInfo->NegHysteresis = scs->NegativeHysterisis; pSensorInfo->EventTypeCode = scs->EventTypeCode; pSensorInfo->SensorReadType = scs->EventTypeCode; pSensorInfo->SensorTypeCode = scs->SensorType; pSensorInfo->SensorCaps = scs->SensorCaps; pSensorInfo->Units1 = scs->Units1; pSensorInfo->Units2 = scs->Units2; pSensorInfo->Units3 = scs->Units3; pSensorInfo->OEMField = scs->OEMField ; } } /*--------------------------------------- * GetDevSDRInfo *---------------------------------------*/ int GetDevSDRInfo ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSDRInfoRes_T* pGetDevSDRInfoRes = (GetSDRInfoRes_T*) pRes; /* Fill in response data */ pGetDevSDRInfoRes->CompletionCode = CC_NORMAL; pGetDevSDRInfoRes->NumSensor = g_BMCInfo.SenConfig.ValidSensorCnt; pGetDevSDRInfoRes->Flags = 0x01; /* BIT7 = 0 (static sensors), BIT0 = 1 (on LUN 0) */ pGetDevSDRInfoRes->TimeStamp = 0; return sizeof (GetSDRInfoRes_T); } /*--------------------------------------- * GetDevSDR *---------------------------------------*/ int GetDevSDR ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { return GetSDR (pReq, ReqLen, pRes); } /*--------------------------------------- * GetDevSDR *---------------------------------------*/ int ReserveDevSDRRepository ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { return ReserveSDRRepository (pReq, ReqLen, pRes); } /*--------------------------------------- * SetSensorType *---------------------------------------*/ int SetSensorType ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { printf("SetSensorType not implement\r\n"); // //pRes [0] = CC_INV_CMD; // //return sizeof (*pRes); // SetSensorTypeReq_T * pSetSensorTypeReq=( SetSensorTypeReq_T *)pReq; // SetSensorTypeRes_T * pSetSensorTypeRes=( SetSensorTypeRes_T *)pRes; // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // /* Check for the reserved bytes should b zero */ // if ( 0 != (pSetSensorTypeReq->EventTypeCode & RESERVED_BITS_SETSENSORTYPE ) ) // { // pSetSensorTypeRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo[BMCInst].SensorSharedMemMutex, WAIT_INFINITE); // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // if (!pSenSharedMem->SensorInfo [pSetSensorTypeReq->SensorNum].IsSensorPresent) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // /* return sdr record not present completion code */ // pSetSensorTypeRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // return sizeof (*pRes); // } // pSenSharedMem->SensorInfo[pSetSensorTypeReq->SensorNum].SensorTypeCode=pSetSensorTypeReq->SensorType; // pSenSharedMem->SensorInfo[pSetSensorTypeReq->SensorNum].EventTypeCode=pSetSensorTypeReq->EventTypeCode; // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // pSetSensorTypeRes->CompletionCode=CC_NORMAL; // return sizeof(*pSetSensorTypeRes); return 0; } /*--------------------------------------- * GetSensorType *---------------------------------------*/ int GetSensorType ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { //pRes [0] = CC_INV_CMD; // return sizeof (*pRes); GetSensorTypeReq_T * pGetSensorTypeReq=( GetSensorTypeReq_T *)pReq; GetSensorTypeRes_T * pGetSensorTypeRes=( GetSensorTypeRes_T *)pRes; SensorInfo_T* pSensorInfo = NULL; pSensorInfo = getSensorInfo(pGetSensorTypeReq->SensorNum); pGetSensorTypeRes->CompletionCode=CC_NORMAL; pGetSensorTypeRes->SensorType=pSensorInfo->SensorTypeCode; pGetSensorTypeRes->EventTypeCode=pSensorInfo->EventTypeCode; return sizeof(*pGetSensorTypeRes); } /*--------------------------------------- * ReArmSensor *---------------------------------------*/ int ReArmSensor ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { printf("ReArmSensor not implement\r\n"); // MsgPkt_T Msg; // HQueue_T hSMHndlr_Q; // ReArmSensorReq_T ReArmSensorReq; // ReArmSensorReq_T* pReArmSensorReq = &ReArmSensorReq; // ReArmSensorRes_T* pReArmSensorRes = ( ReArmSensorRes_T*) pRes; // _fmemset (&ReArmSensorReq, 0, sizeof (ReArmSensorReq_T)); // _fmemcpy (&ReArmSensorReq, pReq, ReqLen); // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // /* if request length is invalid */ // if ((ReqLen < 2) || (ReqLen > sizeof (ReArmSensorReq_T))) // { // /* return request invalid length completion code */ // pReArmSensorRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // /* Check for the reserved bytes should b zero */ // if ( 0 != (pReArmSensorReq->ReArmAllEvents & RESERVED_BITS_REARMSENSOR_REARMALLEVENTS ) ) // { // pReArmSensorRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo.SensorSharedMemMutex, WAIT_INFINITE); // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // /* Check for the reserved bits */ // if (pSenSharedMem->SensorInfo [pReArmSensorReq->SensorNum].SensorReadType == THRESHOLD_SENSOR_CLASS) // { // if ((pReArmSensorReq->ReArmAssertionEvents2 & RESERVED_BITS_REARMSENSOR_REARMASSEVT2_1) || // (pReArmSensorReq->ReArmDeassertionEvents2 & RESERVED_BITS_REARMSENSOR_REARMDEASSEVT2_1)) // { // pReArmSensorRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return sizeof (*pRes); // } // } // else // { // if ((pReArmSensorReq->ReArmAssertionEvents2 & RESERVED_BITS_REARMSENSOR_REARMASSEVT2_2) || // (pReArmSensorReq->ReArmDeassertionEvents2 & RESERVED_BITS_REARMSENSOR_REARMDEASSEVT2_2)) // { // pReArmSensorRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return sizeof (*pRes); // } // } // if (g_BMCInfo.IpmiConfig.OPMASupport == 1) // { // if (pSenSharedMem->GlobalSensorScanningEnable == FALSE) // { // pReArmSensorRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return sizeof (*pRes); // } // } // if (!pSenSharedMem->SensorInfo [pReArmSensorReq->SensorNum].IsSensorPresent) // { // /* return sdr record not present completion code */ // pReArmSensorRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return sizeof (*pRes); // } // Msg.Param = PARAM_REARM_SENSOR; // Msg.Size = sizeof (ReArmSensorReq_T); // _fmemcpy(Msg.Data, &ReArmSensorReq, sizeof (ReArmSensorReq_T)); // /* Post to sensormonitor task Thread to rearm this sensor */ // GetQueueHandle(SM_HNDLR_Q,&hSMHndlr_Q,BMCInst); // if ( -1 != hSMHndlr_Q ) // { // PostMsg(&Msg, SM_HNDLR_Q,BMCInst); // /* return normal completion code */ // pReArmSensorRes->CompletionCode = CC_NORMAL; // }else // { // /* return normal completion code */ // pReArmSensorRes->CompletionCode = 0xFF; // } // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return (sizeof(ReArmSensorRes_T)); return 1; } /*--------------------------------------- * GetSensorEventStatus *---------------------------------------*/ int GetSensorEventStatus ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorEventStatusReq_T* pSensorEventStatusReq = ( GetSensorEventStatusReq_T*) pReq; GetSensorEventStatusRes_T* pSensorEventStatusRes = ( GetSensorEventStatusRes_T*) pRes; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorEventStatusReq->SensorNum); pSensorEventStatusRes->CompletionCode = CC_NORMAL; pSensorEventStatusRes->Flags = (pSensorInfo->EventFlags & 0xe0); /* Set optional response bytes to zero if event messages are disabled for this sensor */ if (0 == ((pSensorInfo->EventFlags) & BIT7)) { pSensorEventStatusRes->AssertionEvents1 = 0; pSensorEventStatusRes->AssertionEvents2 = 0; pSensorEventStatusRes->DeassertionEvents1 = 0; pSensorEventStatusRes->DeassertionEvents2 = 0; return sizeof (GetSensorEventStatusRes_T); } if (0 == ((pSensorInfo->SensorCaps) & BIT6)) { /* Get sensor event status history */ pSensorEventStatusRes->AssertionEvents1 = (pSensorInfo->AssertionHistoryByte1 & pSensorInfo->AssertionEventEnablesByte1); pSensorEventStatusRes->AssertionEvents2 = (pSensorInfo->AssertionHistoryByte2 & pSensorInfo->AssertionEventEnablesByte2); pSensorEventStatusRes->DeassertionEvents1 = (pSensorInfo->DeassertionHistoryByte1 & pSensorInfo->DeassertionEventEnablesByte1); pSensorEventStatusRes->DeassertionEvents2 = (pSensorInfo->DeassertionHistoryByte2 & pSensorInfo->DeassertionEventEnablesByte2); } else { /* Get present sensor event status */ pSensorEventStatusRes->AssertionEvents1 = (pSensorInfo->AssertionEventOccuredByte1 & pSensorInfo->AssertionEventEnablesByte1); pSensorEventStatusRes->AssertionEvents2 = (pSensorInfo->AssertionEventOccuredByte2 & pSensorInfo->AssertionEventEnablesByte2); pSensorEventStatusRes->DeassertionEvents1 = (pSensorInfo->DeassertionEventOccuredByte1 & pSensorInfo->DeassertionEventEnablesByte1); pSensorEventStatusRes->DeassertionEvents2 =(pSensorInfo->DeassertionEventOccuredByte2 & pSensorInfo->DeassertionEventEnablesByte2); } return sizeof (GetSensorEventStatusRes_T); } /*--------------------------------------- * SetSensorHysterisis *---------------------------------------*/ int SetSensorHysterisis ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { // SetSensorHysterisisReq_T* pSensorHysReq = // ( SetSensorHysterisisReq_T*) pReq; SetSensorHysterisisRes_T* pSensorHysRes = ( SetSensorHysterisisRes_T*) pRes; printf("SetSensorHysterisis not implement\r\n"); // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // if (g_BMCInfo.IpmiConfig.OPMASupport == 1) // { // if (pSenSharedMem->GlobalSensorScanningEnable == FALSE) // { // pSensorHysRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (*pRes); // } // } // /* Acquire Shared memory */ // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo.SensorSharedMemMutex, WAIT_INFINITE); // if (!pSenSharedMem->SensorInfo [pSensorHysReq->SensorNum].IsSensorPresent) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorHysRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // return sizeof (*pRes); // } // if (pSenSharedMem->SensorInfo [pSensorHysReq->SensorNum].SensorReadType != THRESHOLD_SENSOR_CLASS) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorHysRes->CompletionCode = CC_ILLEGAL_CMD_FOR_SENSOR_REC; // return sizeof (*pRes); // } // if(BIT5 != (pSenSharedMem->SensorInfo[pSensorHysReq->SensorNum].SensorCaps & (BIT5 | BIT4))) // { // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // //set operation is not allowed // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // /* Set the hysterisis values */ // pSenSharedMem->SensorInfo [pSensorHysReq->SensorNum].PosHysteresis = pSensorHysReq->PositiveHysterisis; // pSenSharedMem->SensorInfo [pSensorHysReq->SensorNum].NegHysteresis = pSensorHysReq->NegativeHysterisis; // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); pSensorHysRes->CompletionCode = CC_NORMAL; return sizeof (SetSensorHysterisisRes_T); } /*--------------------------------------- * GetSensorHysterisis *---------------------------------------*/ int GetSensorHysterisis ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorHysterisisReq_T* pSensorHysReq = ( GetSensorHysterisisReq_T*) pReq; GetSensorHysterisisRes_T* pSensorHysRes = ( GetSensorHysterisisRes_T*) pRes; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorHysReq->SensorNum); if (pSensorInfo->SensorReadType != THRESHOLD_SENSOR_CLASS) { pSensorHysRes->CompletionCode = CC_ILLEGAL_CMD_FOR_SENSOR_REC; return sizeof (*pRes); } if(SENSOR_HYSTERESIS_ACCESS_BITS == (pSensorInfo->SensorCaps & (BIT5 | BIT4))) { //set operation is not allowed *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } /* Get the hysterisis values */ pSensorHysRes->PositiveHysterisis = pSensorInfo->PosHysteresis; pSensorHysRes->NegativeHysterisis = pSensorInfo->NegHysteresis; pSensorHysRes->CompletionCode = CC_NORMAL; return sizeof (GetSensorHysterisisRes_T); } /*--------------------------------------- * SetSensorThresholds *---------------------------------------*/ int SetSensorThresholds ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { SetSensorThresholdReq_T* pSensorThreshReq = ( SetSensorThresholdReq_T*) pReq; SetSensorThresholdRes_T* pSensorThreshRes = ( SetSensorThresholdRes_T*) pRes; uint8_t SettableMask=0; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorThreshReq->SensorNum); SDRRecHdr_T* pSDRRec = SR_FindSDR(pSensorThreshReq->SensorNum); FullSensorRec_T* sfs = NULL; //CompactSensorRec_T* scs = NULL; if(pSDRRec->Type == FULL_SDR_REC) { sfs = (FullSensorRec_T*)pSDRRec; } /* Check for the reserved bytes should b zero */ if ( 0 != (pSensorThreshReq->SetFlags & RESERVED_BITS_SETSENSORTHRESHOLDS ) ) { pSensorThreshRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof (*pRes); } if (pSensorInfo->SensorReadType != THRESHOLD_SENSOR_CLASS) { pSensorThreshRes->CompletionCode = CC_ILLEGAL_CMD_FOR_SENSOR_REC; return sizeof (*pRes); } if(BIT3 != (pSensorInfo->SensorCaps & (BIT2 | BIT3))) { //set operation is not allowed *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } pSensorThreshRes->CompletionCode = CC_NORMAL; SettableMask=(uint8_t)(pSensorInfo->SettableThreshMask >> 8); /* Set the threshold values */ //if (pSenSharedMem->SensorInfo [pSensorThreshReq->SensorNum].SensorInit & BIT5) if ( (pSensorInfo->SensorInit & BIT4 ) && (SettableMask | pSensorThreshReq->SetFlags ) == SettableMask) //<> { if (pSensorThreshReq->SetFlags & LWR_CRIT) { pSensorInfo->LowerCritical = pSensorThreshReq->LowerCritical; if(sfs != NULL) {sfs->LowerCritical = pSensorThreshReq->LowerCritical;} } if (pSensorThreshReq->SetFlags & LWR_NON_CRIT) { pSensorInfo->LowerNonCritical = pSensorThreshReq->LowerNonCritical; if(sfs != NULL) {sfs->LowerNonCritical = pSensorThreshReq->LowerNonCritical;} } if (pSensorThreshReq->SetFlags & LWR_NON_REC) { pSensorInfo->LowerNonRecoverable = pSensorThreshReq->LowerNonRecoverable; if(sfs != NULL) {sfs->LowerNonRecoverable = pSensorThreshReq->LowerNonRecoverable;} } if (pSensorThreshReq->SetFlags & UPR_CRIT) { pSensorInfo->UpperCritical = pSensorThreshReq->UpperCritical; if(sfs != NULL) {sfs->UpperCritical = pSensorThreshReq->UpperCritical;} } if (pSensorThreshReq->SetFlags & UPR_NON_CRIT) { pSensorInfo->UpperNonCritical = pSensorThreshReq->UpperNonCritical; if(sfs != NULL) {sfs->UpperNonCritical = pSensorThreshReq->UpperNonCritical;} } if (pSensorThreshReq->SetFlags & UPR_NON_REC) { pSensorInfo->UpperNonRecoverable = pSensorThreshReq->UpperNonRecoverable; if(sfs != NULL) {sfs->UpperNonRecoverable = pSensorThreshReq->UpperNonRecoverable;} } if(g_BMCInfo.IpmiConfig.RearmSetSensorThreshold == 1) { /* Since Changes in Threshold .We have to monitor the sensor again .*/ /* Already the Sensor reached the particular state . so we have to reset for generate the event according to the new Event mask */ if ( 0 ==(pSensorInfo->SensorCaps & BIT6)) { /* Manual ReARM Sensor */ pSensorInfo->AssertionHistoryByte1=0; pSensorInfo->AssertionHistoryByte2=0; pSensorInfo->DeassertionHistoryByte1=0; pSensorInfo->DeassertionHistoryByte2=0; pSensorInfo->EventLevel=SENSOR_STATUS_NORMAL; pSensorInfo->HealthLevel= SENSOR_STATUS_NORMAL; }else { /* Auto ReARM Sensor */ pSensorInfo->EventLevel=SENSOR_STATUS_NORMAL; pSensorInfo->HealthLevel = SENSOR_STATUS_NORMAL; pSensorInfo->AssertionEventOccuredByte1 = 0; pSensorInfo->AssertionEventOccuredByte2 = 0; pSensorInfo->DeassertionEventOccuredByte1 = 0; pSensorInfo->DeassertionEventOccuredByte2 = 0; } } pSensorThreshRes->CompletionCode = CC_NORMAL; UpdateFlash(); } else { pSensorThreshRes->CompletionCode = CC_ILLEGAL_CMD_FOR_SENSOR_REC; } return sizeof (SetSensorThresholdRes_T); } /*--------------------------------------- * GetSensorThresholds *---------------------------------------*/ int GetSensorThresholds ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorThresholdReq_T* pSensorThreshReq = ( GetSensorThresholdReq_T*) pReq; GetSensorThresholdRes_T* pSensorThreshRes = ( GetSensorThresholdRes_T*) pRes; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorThreshReq->SensorNum); if (pSensorInfo->SensorReadType != THRESHOLD_SENSOR_CLASS) { pSensorThreshRes->CompletionCode = CC_ILLEGAL_CMD_FOR_SENSOR_REC; return sizeof (*pRes); } memset (pSensorThreshRes, 0, sizeof (GetSensorThresholdRes_T)); if(SENSOR_THRESOLD_ACCESS_BITS != (pSensorInfo->SensorCaps & (BIT2 | BIT3))) { pSensorThreshRes->GetFlags = pSensorInfo->SettableThreshMask & 0xFF; /* Get the Threshold values according to readable threshold flag */ if( pSensorThreshRes->GetFlags & BIT0 ) pSensorThreshRes->LowerNonCritical = pSensorInfo->LowerNonCritical; if( pSensorThreshRes->GetFlags & BIT1 ) pSensorThreshRes->LowerCritical = pSensorInfo->LowerCritical; if( pSensorThreshRes->GetFlags & BIT2 ) pSensorThreshRes->LowerNonRecoverable = pSensorInfo->LowerNonRecoverable; if( pSensorThreshRes->GetFlags & BIT3 ) pSensorThreshRes->UpperNonCritical = pSensorInfo->UpperNonCritical; if( pSensorThreshRes->GetFlags & BIT4 ) pSensorThreshRes->UpperCritical = pSensorInfo->UpperCritical; if( pSensorThreshRes->GetFlags & BIT5 ) pSensorThreshRes->UpperNonRecoverable = pSensorInfo->UpperNonRecoverable; } pSensorThreshRes->CompletionCode = CC_NORMAL; return sizeof (GetSensorThresholdRes_T); } /*--------------------------------------- * GetSensorReadingFactors *---------------------------------------*/ int GetSensorReadingFactors ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorReadingFactorReq_T* pSensorFactorsReq = ( GetSensorReadingFactorReq_T*) pReq; GetSensorReadingFactorRes_T* pSensorFactorsRes = ( GetSensorReadingFactorRes_T*) pRes; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorFactorsReq->SensorNum); memcpy (&(pSensorFactorsRes->M_LSB), &(pSensorInfo->M_LSB), sizeof (GetSensorReadingFactorRes_T) - (2 * sizeof (uint8_t))); pSensorFactorsRes->CompletionCode = CC_NORMAL; return sizeof (GetSensorReadingFactorRes_T); } /*--------------------------------------- * SetSensorEventEnable *---------------------------------------*/ int SetSensorEventEnable ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { // SensorInfo_T* pSensorInfo; // uint8_t LocalReq [6]; // SetSensorEventEnableReq_T* pSensorEvtEnReq; // SetSensorEventEnableRes_T* pSensorEvtEnRes = // ( SetSensorEventEnableRes_T*) pRes; printf("SetSensorEventEnable not implement\r\n"); // uint16_t AssertMask, DeassertMask; // uint16_t ValidMask = htoipmi_u16(0x0FFF); // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // uint16_t LUNSensorNum; // uint16_t *OwnerLUN = 0; // if (g_BMCInfo.IpmiConfig.OPMASupport == 1) // { // if (pSenSharedMem->GlobalSensorScanningEnable == FALSE) // { // pSensorEvtEnRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (*pRes); // } // } // AssertMask = DeassertMask = 0; // memset (LocalReq, 0, sizeof (LocalReq)); // memcpy (LocalReq, pReq, ReqLen); // pSensorEvtEnReq = ( SetSensorEventEnableReq_T*)LocalReq; // if(g_corefeatures.more_than_256_sensors == ENABLED) // { // OS_THREAD_TLS_GET(g_tls.OwnerLUN,OwnerLUN); // LUNSensorNum = ((*OwnerLUN & VALID_LUN) << 8 | pSensorEvtEnReq->SensorNum); // } // else // { // LUNSensorNum = pSensorEvtEnReq->SensorNum; // } // /* Atleast two bytes are expected remaining bytes (3,4,5,6) are optional */ // if ((ReqLen < sizeof(uint16_t)) || (ReqLen > sizeof (SetSensorEventEnableReq_T))) // { // pSensorEvtEnRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // /* Check for the reserved bytes should b zero */ // if ( 0 != (pSensorEvtEnReq->Flags & RESERVED_BITS_SETSENEVTEN_FLAGS ) ) // { // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // if (ReqLen > sizeof(uint16_t)) // { // /* Check for the reserved bits */ // if (pSenSharedMem->SensorInfo [LUNSensorNum].SensorReadType == THRESHOLD_SENSOR_CLASS) // { // if ((pSensorEvtEnReq->AssertionMask & ~ValidMask) || // (pSensorEvtEnReq->DeAssertionMask & ~ValidMask)) // { // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // else // { // if ((pSensorEvtEnReq->AssertionMask & RESERVED_BITS_SETSENEVTEN_ASSERTIONMASK) || // (pSensorEvtEnReq->DeAssertionMask & RESERVED_BITS_SETSENEVTEN_DEASSERTIONMASK)) // { // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // } // /* Get the sensor Info for the sensor */ // if(g_corefeatures.more_than_256_sensors == ENABLED) // { // pSensorInfo = GetSensorInfo (pSensorEvtEnReq->SensorNum, *OwnerLUN, BMCInst); // } // else // { // pSensorInfo = GetSensorInfo (pSensorEvtEnReq->SensorNum, 0x0, BMCInst); // } // if (NULL == pSensorInfo) // { // pSensorEvtEnRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // return sizeof (*pRes); // } // // If not threshold, adjust mask // if (pSensorInfo->EventTypeCode != 0x01) // { // ValidMask = htoipmi_u16(0x7FFF); // } // /* Acquire Shared memory */ // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo.SensorSharedMemMutex, WAIT_INFINITE); // if (!pSensorInfo->IsSensorPresent) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorEvtEnRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // return sizeof (*pRes); // } // /* Disable Events and scanning based on the flags */ // if (0 == (pSensorEvtEnReq->Flags & EVENT_MSG_MASK)) // { // /* DisableAllEventSensors () */ // } // if ((0 == (pSensorEvtEnReq->Flags & SCAN_MASK)) && (SCAN_MASK == (pSensorInfo->EventFlags & SCAN_MASK))) // { // // Check sensor accepts the ‘enable/disable scanning’ // if(0 == (pSensorInfo->SensorInit & BIT6)) // { // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // pSensorInfo->EventFlags |= BIT5; ///* Bit 5 - Unable to read */ // } // else if((SCAN_MASK == (pSensorEvtEnReq->Flags & SCAN_MASK)) && (0 == (pSensorInfo->EventFlags & SCAN_MASK))) // { // // Check sensor accepts the ‘enable/disable scanning’ // if(0 == (pSensorInfo->SensorInit & BIT6)) // { // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // pSensorInfo->EventFlags &= ~BIT5; ///* Bit 5 - Unable to read */ // } // pSensorInfo->EventFlags &= ~(EVENT_MSG_MASK | SCAN_MASK); // pSensorInfo->EventFlags |= (pSensorEvtEnReq->Flags & (EVENT_MSG_MASK | SCAN_MASK)); // AssertMask = // htoipmi_u16(((pSenSharedMem->SensorInfo [LUNSensorNum].AssertionEventEnablesByte2 << 8) | // (pSenSharedMem->SensorInfo [LUNSensorNum].AssertionEventEnablesByte1)) & ValidMask); // DeassertMask = // htoipmi_u16(((pSenSharedMem->SensorInfo [LUNSensorNum].DeassertionEventEnablesByte2 << 8) | // (pSenSharedMem->SensorInfo [LUNSensorNum].DeassertionEventEnablesByte1)) & ValidMask); // /* Enable disable assertion based on the flag */ // if(ENABLE_DISABLE_EVENT_MASK == (pSensorEvtEnReq->Flags & ENABLE_DISABLE_EVENT_MASK)) // { // // Flags [5:4] - 11b Reserved. // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorEvtEnRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // else if (ENABLE_SELECTED_EVENT_MSG == (pSensorEvtEnReq->Flags & ENABLE_DISABLE_EVENT_MASK)) // { // AssertMask |= ipmitoh_u16(pSensorEvtEnReq->AssertionMask); // DeassertMask |= ipmitoh_u16(pSensorEvtEnReq->DeAssertionMask); // } // else if (DISABLE_SELECTED_EVENT_MSG == (pSensorEvtEnReq->Flags & ENABLE_DISABLE_EVENT_MASK)) // { // AssertMask &= ~ipmitoh_u16(pSensorEvtEnReq->AssertionMask); // DeassertMask &= ~ipmitoh_u16(pSensorEvtEnReq->DeAssertionMask); // } // //For Threshold class sensors upper word bits are reserved // if(pSensorInfo->EventTypeCode == THRESHOLD_SENSOR_CLASS) // { // pSensorInfo->AssertionEventEnablesByte2 &= 0xF0; // pSensorInfo->AssertionEventEnablesByte2 |= (AssertMask >> 8); // } // else // { // pSensorInfo->AssertionEventEnablesByte2 = (AssertMask >> 8); // } // pSensorInfo->AssertionEventEnablesByte1 = (AssertMask) & 0xFF; // //For Threshold class sensors upper word bits are reserved // if(pSensorInfo->EventTypeCode == THRESHOLD_SENSOR_CLASS) // { // pSensorInfo->DeassertionEventEnablesByte2 &= 0xF0; // pSensorInfo->DeassertionEventEnablesByte2 |= (DeassertMask >> 8); // } // else // { // pSensorInfo->DeassertionEventEnablesByte2 = (DeassertMask >> 8); // } // pSensorInfo->DeassertionEventEnablesByte1 = (DeassertMask); // // For threshold sensors, reset the threshold state machine for the sensor // // in order to pickup any newly enabled events. // if(pSensorInfo->EventTypeCode == THRESHOLD_SENSOR_CLASS) // { // pSensorInfo->EventLevel=SENSOR_STATUS_NORMAL; // pSensorInfo->HealthLevel = SENSOR_STATUS_NORMAL; // } // pSensorEvtEnRes->CompletionCode = CC_NORMAL; // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); return sizeof (SetSensorEventEnableRes_T); } /*--------------------------------------- * GetSensorEventEnable *---------------------------------------*/ int GetSensorEventEnable ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorEventEnableReq_T* pSensorEvtEnReq = ( GetSensorEventEnableReq_T*) pReq; GetSensorEventEnableRes_T* pSensorEvtEnRes = ( GetSensorEventEnableRes_T*) pRes; SensorInfo_T* pSensorInfo = getSensorInfo(pSensorEvtEnReq->SensorNum); uint16_t ValidMask = (0x0FFF); if (pSensorInfo->EventTypeCode != 0x01) { ValidMask = (0x7FFF); } /* Get the assertion enables */ pSensorEvtEnRes->AssertionMask = (((pSensorInfo->AssertionEventEnablesByte2 << 8) | (pSensorInfo->AssertionEventEnablesByte1)) & ValidMask); /* Get the deassertion enables */ pSensorEvtEnRes->DeAssertionMask = (((pSensorInfo->DeassertionEventEnablesByte2 << 8) | (pSensorInfo->DeassertionEventEnablesByte1)) & ValidMask); /* Set the flags */ pSensorEvtEnRes->Flags = (pSensorInfo->EventFlags & 0xc0); pSensorEvtEnRes->CompletionCode = CC_NORMAL; return sizeof (GetSensorEventEnableRes_T); } /** * @fn CheckForEntityPresence * @brief This function checks for the entity presence bit * or the entity presence sensor. * @param[in] SensorNum - Sensor number for reading. * @param[in] EventTypeCode - Event type code of the sdr. * @param[in] SensorType - Sensor type of the sdr. * @retval ENTITY_FOUND, if present, * ENTITY_NOT_FOUND, if not present, * NOT_FOUND_SCAN_DISABLED, if not able to find, * NOT_FOUND_SCAN_ENABLED, if Scanning bit enabled but failed. */ static int CheckForEntityPresence (uint8_t SensorNum, uint8_t OwnerLUN, uint8_t EventTypeCode, uint8_t SensorType) { int RetVal = NOT_FOUND_SCAN_ENABLED; SensorInfo_T* pSensorInfo; int i; pSensorInfo = getSensorInfo(SensorNum); if( BIT0 == (BIT0 & pSensorInfo->SensorInit) ) { // If Event/Reading type code is 0x08 then look for // reading DEVICE_PRESENT to state the Entity Presence if( GENERIC_EVENT_TYPE_DEV_PRESENCE == EventTypeCode ) { if( DEVICE_PRESENT == pSensorInfo->SensorReading ) { RetVal = ENTITY_FOUND; } else { RetVal = ENTITY_NOT_FOUND; } } // If Event/Reading type code is 0x09 then look for // reading DEVICE_ENABLED to state the Entity Enabled else if( GENERIC_EVENT_TYPE_DEV_AVAILABLE == EventTypeCode ) { if( DEVICE_ENABLED == pSensorInfo->SensorReading ) { RetVal = ENTITY_FOUND; } else { RetVal = ENTITY_NOT_FOUND; } } // If Event/Reading Type code is 0x6f then look for the // special sensors like Processor, Memory etc., else if ( EVENT_TYPE_SENSOR_SPECIFIC == EventTypeCode ) { for(i = 0; i < SENSOR_PRESENCE_COUNT; i++) { if( SensorType == sensor_presence[i][0] ) { if( pSensorInfo->SensorReading == sensor_presence[i][1] ) RetVal = ENTITY_FOUND; else RetVal = ENTITY_NOT_FOUND; } } } return RetVal; } return NOT_FOUND_SCAN_DISABLED; } /** * @fn IsSensorPresence * @brief Check the presence bit for the entity or checks with * entity presence sensor to identify Entity presence * @param[in] EntityID - Entity id of the sensor. * @param[in] EntityIns - Entity instance of the sensor. * @param[in] SensorNum - Sensor number. * @retval 1, if present * 0, if not present * -1, if not able to find. */ static int IsSensorPresence (uint8_t EntityID, uint8_t EntityIns, uint8_t SensorNum, uint8_t OwnerLUN) { SDRRecHdr_T* sr = NULL; CommonSensorRec_T* scs = NULL; int RetVal, tmpRet = -1; sr = SDR_GetFirstSDRRec (); while (0 != sr) { // Populate sensor information for Threshold sensors if (FULL_SDR_REC == sr->Type || COMPACT_SDR_REC == sr->Type) { /* Populate sensor information for full or Compact Record */ scs = ( CommonSensorRec_T*) sr; // Check for EntityId and EntityIns if((EntityID == scs->EntityID) && (EntityIns == scs->EntityIns) && ((SensorNum != scs->SensorNum) || (OwnerLUN != scs->OwnerLUN)) ) { RetVal = CheckForEntityPresence (scs->SensorNum, scs->OwnerLUN, scs->EventTypeCode, scs->SensorType); if( NOT_FOUND_SCAN_DISABLED != RetVal && NOT_FOUND_SCAN_ENABLED != RetVal) { return RetVal; } else if( NOT_FOUND_SCAN_ENABLED == RetVal) { // An Entity is present if there is at least one active // sensor for the Entity (and there is no explicit sensor saying // the Entity is 'absent'). // A sensor is 'active' if scanning is enabled. // We can return this value only after searching all the sensors. tmpRet = 1; } } } /* Get the next record */ sr = SDR_GetNextSDRRec (sr); } return tmpRet; } /** * @fn IsEntityAssociationPresence * @brief Check the EntityID and Entity instance to see if the entity is * a container entity in an entity-association. If so, check to * see if any of the contained entities are present, if so, assume * the container entity exists. * @param[in] EntityID - Entity id of the sensor. * @param[in] EntityIns - Entity instance of the sensor. * @retval 1, if present * 0, if not present * -1, if not able to find. */ static int IsEntityAssociationPresence (uint8_t EntityID, uint8_t EntityIns) { //TODO return -1; } /** * @fn IsFRUPresence * @brief Check the entity to see if FRU device is present. * @param[in] EntityID - Entity id of the sensor. * @param[in] EntityIns - Entity instance of the sensor. * @retval 1, if present * 0, if not present * -1, if not able to find. */ static int IsFRUPresence (uint8_t EntityID, uint8_t EntityIns) { printf("IsFRUPresence not implement\r\n"); // SDRRecHdr_T* sr = NULL; // FRUDevLocatorRec_T* frudl; // FRUReadReq_T FRUReadReq; // uint8_t FRUReadRes[64]; // sr = SDR_GetFirstSDRRec (BMCInst); // while (0 != sr) // { // // Check for FRU Device locator SDR Record // if (sr->Type == FRU_DEVICE_LOCATOR_SDR_REC) // { // frudl = ( FRUDevLocatorRec_T*) sr; // frudl->EntityID, frudl->EntityIns); // // If EntityID and EntityIns are equal try to read the fru data. // if(frudl->EntityID == EntityID && // frudl->EntityIns == EntityIns) // { // FRUReadReq.FRUDeviceID=frudl->FRUIDSlaveAddr; // FRUReadReq.Offset=0x0; // FRUReadReq.CountToRead=sizeof(FRUCommonHeader_T); // ReadFRUData((uint8_t *)&FRUReadReq, sizeof(FRUReadReq_T), FRUReadRes); // if (((FRUReadRes_T *)FRUReadRes)->CompletionCode == FRU_ACCESSIBLE) // { // return 1; // } // else // { // return 0; // } // } // } // sr = SDR_GetNextSDRRec (sr); // } return -1; } /** * @fn InitSensorScanningBit * @brief Initializes all the sensor's Scanning bit with respect * to the presence of the entity * @retval 0. */ int InitSensorScanningBit() { SDRRecHdr_T* sr = NULL; CommonSensorRec_T* scs = NULL; int RetVal; SensorInfo_T* pSensorInfo = NULL; uint16_t LUNSensorNum; sr = SDR_GetFirstSDRRec (); while (0 != sr) { // Populater sensor information for Threshold sensors if (FULL_SDR_REC == sr->Type || COMPACT_SDR_REC == sr->Type) { scs = ( CommonSensorRec_T*) sr; RetVal = 1; if( BIT7 == (BIT7 & scs->SensorCaps) ) { /* As per IPMI Spec Section 40.2 * Entity presence can be detected if any one of the following point is * Satisfied, * 1. If there is an active sensor that includes a presence bit, * or the entity has an active Entity Presence sensor, * use the sensor to determine the presence of the entity. * 2. Check the SDRs to see if the entity is a container entity * in an entity-association. If so, check to see if any of the * contained entities are present, if so, assume the container * entity exists. Note that this may need to be iterative. * 3. The entity is present is there is a FRU device for the * entity, and the FRU device is present. */ RetVal = IsSensorPresence(scs->EntityID, scs->EntityIns, scs->SensorNum, scs->OwnerLUN); if( -1 == RetVal ) { RetVal = IsEntityAssociationPresence(scs->EntityID, scs->EntityIns); if( -1 == RetVal ) { RetVal = IsFRUPresence(scs->EntityID, scs->EntityIns); } } } LUNSensorNum = (scs->SensorNum); /* * [7] - 0b = All Event Messages disabled from this sensor * [6] - 0b = sensor scanning disabled * [5] - 1b = reading/state unavailable */ if(1 == RetVal) { pSensorInfo = getSensorInfo(LUNSensorNum); if((BIT0 | BIT1) == (pSensorInfo->SensorInit & (BIT0 | BIT1))) { /* Enabling Sensor Scanning and Event Messages*/ pSensorInfo->EventFlags = EVENT_AND_SCANNING_ENABLE; } else if(BIT1 == (pSensorInfo->SensorInit & BIT1)) { /* Enabling Event Messages */ pSensorInfo->EventFlags = EVENT_MSG_MASK; } else if(BIT0 == (pSensorInfo->SensorInit & BIT0)) { /*Enabling Scanning*/ pSensorInfo->EventFlags = SCAN_MASK; } if(0 == (pSensorInfo->SensorInit & BIT0)) { /* Reading Unavailable */ pSensorInfo->EventFlags |= READING_UNAVAILABLE; } } else { pSensorInfo->EventFlags = READING_UNAVAILABLE; if(BIT1 == (pSensorInfo->SensorInit & BIT1)) { /* Enabling Event Messages */ pSensorInfo->EventFlags |= EVENT_MSG_MASK; } } } /* Get the next record */ sr = SDR_GetNextSDRRec (sr); } printf("Leaving : %s with 0\n", __func__); return 0; } /* Compare two sensor values. * Returns -1 if val1 < val2 * Returns 0 if val1 == val2 * Returns 1 if val1 > val2 */ int CompareValues(uint8_t isSigned, uint8_t val1, uint8_t val2) { int retval = 0; // default to equal // Signed comparison int8_t sval1, sval2; /* Do comparison based on isSigned flag */ if (FALSE == isSigned) { // Unsigned comparison if (val1 < val2) { retval = -1; } else if (val1 > val2) { retval = 1; } } else { sval1 = (int8_t)val1; sval2 = (int8_t)val2; if (sval1 < sval2) { retval = -1; } else if (sval1 > sval2) { retval = 1; } } return retval; } /*----------------------------------------- * GetSensorReading *-----------------------------------------*/ int GetSensorReading ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetSensorReadingReq_T* pSensorReadReq = ( GetSensorReadingReq_T*) pReq; GetSensorReadingRes_T* pSensorReadRes = ( GetSensorReadingRes_T*) pRes; uint16_t SensorReading; uint8_t SensorIsSigned = FALSE; SensorInfo_T * pSensorInfo = NULL; pSensorInfo = getSensorInfo(pSensorReadReq->SensorNum); pSensorReadRes->Flags = pSensorInfo->EventFlags & 0xe0; if (0 != (pSensorInfo->EventFlags & BIT5)) { pSensorReadRes->SensorReading = 0; pSensorReadRes->CompletionCode = CC_NORMAL; pSensorReadRes->ComparisonStatus = (((uint8_t) (pSensorReadRes->SensorReading & 0x00FF)) & ((uint8_t) (pSensorInfo->SettableThreshMask & 0x00FF)) ); pSensorReadRes->OptionalStatus = (((uint8_t) (pSensorReadRes->SensorReading >> 8)) & ((uint8_t)(pSensorInfo->SettableThreshMask >> 8)) ); // For Discrete sensor, [7] - reserved. Returned as 1b. Ignore on read. pSensorReadRes->OptionalStatus |= 0x80; return sizeof (GetSensorReadingRes_T); } pSensorReadRes->CompletionCode = CC_NORMAL; SensorReading = pSensorInfo->SensorReading; pSensorReadRes->SensorReading = 0; SensorIsSigned = (0 != (pSensorInfo->Units1 & 0xC0)) ? TRUE : FALSE; if (THRESHOLD_SENSOR_CLASS == pSensorInfo->EventTypeCode) { pSensorReadRes->SensorReading = (SensorReading & 0x00FF); //notice pSensorReadRes->ComparisonStatus = 0x00; if((pSensorInfo->DeassertionEventEnablesByte2 & BIT6) == BIT6 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->UpperNonRecoverable) >= 0) { pSensorReadRes->ComparisonStatus |= BIT5; } } if((pSensorInfo->DeassertionEventEnablesByte2 & BIT5) == BIT5 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->UpperCritical) >= 0) { pSensorReadRes->ComparisonStatus |= BIT4; } } if((pSensorInfo->DeassertionEventEnablesByte2 & BIT4) == BIT4 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->UpperNonCritical) >= 0) { pSensorReadRes->ComparisonStatus |= BIT3; } } if((pSensorInfo->AssertionEventEnablesByte2 & BIT6) == BIT6 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->LowerNonRecoverable) <= 0) { pSensorReadRes->ComparisonStatus |= BIT2; } } if((pSensorInfo->AssertionEventEnablesByte2 & BIT5) == BIT5 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->LowerCritical) <= 0) { pSensorReadRes->ComparisonStatus |= BIT1; } } if((pSensorInfo->AssertionEventEnablesByte2 & BIT4) == BIT4 ) { if (CompareValues(SensorIsSigned, pSensorReadRes->SensorReading, pSensorInfo->LowerNonCritical) <= 0) { pSensorReadRes->ComparisonStatus |= BIT0; } } pSensorReadRes->ComparisonStatus &= ((pSensorInfo->SettableThreshMask >> 8) & 0xFF); pSensorReadRes->OptionalStatus = 0; // For Threshold sensor, [7:6] - reserved. Returned as 1b. Ignore on read. pSensorReadRes->ComparisonStatus |= 0xC0; } else { pSensorReadRes->ComparisonStatus = (((uint8_t) (SensorReading & 0x00FF)) & ((uint8_t) (pSensorInfo->SettableThreshMask & 0x00FF)) ); pSensorReadRes->OptionalStatus = (((uint8_t) (SensorReading >> 8)) & ((uint8_t)(pSensorInfo->SettableThreshMask >> 8)) ); // For Discrete sensor, [7] - reserved. Returned as 1b. Ignore on read. pSensorReadRes->OptionalStatus |= 0x80; } return sizeof (GetSensorReadingRes_T); } /*----------------------------------------- * SetSensorReading *-----------------------------------------*/ int SetSensorReading ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { printf("SetSensorReading not implement\r\n"); // SetSensorReadingReq_T* pSensorReadReq = // ( SetSensorReadingReq_T*) pReq; // SetSensorReadingRes_T* pSensorReadRes = // ( SetSensorReadingRes_T*) pRes; // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // /* Check for the reserved bits */ // if (pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].SensorReadType == THRESHOLD_SENSOR_CLASS) // { // if (((ReqLen>=LEN_FOR_ASSERT_DATA) && (pSensorReadReq->AssertionEventOccuredByte2 & RESERVED_BITS_SETSENRD_ASSEVTOCCBYTE_1)) || // ((ReqLen>=LEN_FOR_DEASSERT_DATA) && (pSensorReadReq->DeAssertionEventOccuredByte2 & RESERVED_BITS_SETSENRD_DEASSEVTOCCBYTE_1))) // { // pSensorReadRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // else // { // if (((ReqLen>=LEN_FOR_ASSERT_DATA) && (pSensorReadReq->AssertionEventOccuredByte2 & RESERVED_BITS_SETSENRD_ASSEVTOCCBYTE_2)) || // ((ReqLen>=LEN_FOR_DEASSERT_DATA) && (pSensorReadReq->DeAssertionEventOccuredByte2 & RESERVED_BITS_SETSENRD_DEASSEVTOCCBYTE_2))) // { // pSensorReadRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // if (g_BMCInfo.IpmiConfig.OPMASupport == 1) // { // if (pSenSharedMem->GlobalSensorScanningEnable == FALSE) // { // pSensorReadRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (*pRes); // } // } // /* Acquire Shared memory */ // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo.SensorSharedMemMutex, WAIT_INFINITE); // if (!pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].IsSensorPresent) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_SDR_REC_NOT_PRESENT; // return sizeof (*pRes); // } // if (ReqLen < MIN_SET_SEN_READING_CMD_LEN) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // /* Check if the sensor is settable */ // if (0 == GET_SETTABLE_SENSOR_BIT(pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].SensorInit)) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_INVALID_ATTEMPT_TO_SET; // return sizeof (*pRes); // } // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].Operation = pSensorReadReq->Operation; // /* Set Sensor Event Data based on the Operation byte */ // switch (GET_EVENT_DATA_OP(pSensorReadReq->Operation)) // { // case WRITE_NO_EVTDATA1: // pSensorReadReq->EvtData1 &= 0xF0; // /* Intentional Fall thru */ // case WRITE_EVTDATA1: // if (LEN_FOR_EVT_DATA != ReqLen) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // /* Update EvtData fields */ // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].EvtData1 = pSensorReadReq->EvtData1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].EvtData2 = pSensorReadReq->EvtData2; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].EvtData3 = pSensorReadReq->EvtData3; // break; // } // /* Check Length for Assertion Set Opetation */ // if (0 != GET_ASSERT_EVT_OP(pSensorReadReq->Operation)) // { // if ((ReqLen < LEN_FOR_ASSERT_DATA) || (ReqLen > MAX_SET_SEN_READ_LEN)) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // } // /* Set Sensor Assertion Event based on the Operation byte */ // switch (GET_ASSERT_EVT_OP(pSensorReadReq->Operation)) // { // case CLEAR_ASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte1 &= pSensorReadReq->AssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte2 &= pSensorReadReq->AssertionEventOccuredByte2; // break; // case SET_ASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte1 |= pSensorReadReq->AssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte2 |= pSensorReadReq->AssertionEventOccuredByte2; // break; // case WRITE_ASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte1 |= pSensorReadReq->AssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].AssertionEventOccuredByte2 |= pSensorReadReq->AssertionEventOccuredByte2; // break; // } // /* Check Length for Assertion Set Opetation */ // if (0 != GET_DEASSERT_EVT_OP(pSensorReadReq->Operation)) // { // if ((ReqLen < LEN_FOR_DEASSERT_DATA) || (ReqLen > MAX_SET_SEN_READ_LEN)) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // } // /* Set Sensor DeAssertion Event based on the Operation byte */ // switch (GET_DEASSERT_EVT_OP(pSensorReadReq->Operation)) // { // case CLEAR_DEASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte1 &= pSensorReadReq->DeAssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte2 &= pSensorReadReq->DeAssertionEventOccuredByte2; // break; // case SET_DEASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte1 |= pSensorReadReq->DeAssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte2 |= pSensorReadReq->DeAssertionEventOccuredByte2; // break; // case WRITE_DEASSERT_BITS: // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte1 |= pSensorReadReq->DeAssertionEventOccuredByte1; // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].DeassertionEventOccuredByte2 |= pSensorReadReq->DeAssertionEventOccuredByte2; // break; // } // /* Check Length for Set Sensor Reading Operation */ // if (0 != GET_SETSENSOR_OP(pSensorReadReq->Operation)) // { // if ((ReqLen < LEN_FOR_SETSENSOR_DATA) || (ReqLen > MAX_SET_SEN_READ_LEN)) // { // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // pSensorReadRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // /* Set new Sensor Reading */ // pSenSharedMem->SensorInfo [pSensorReadReq->SensorNum].SensorReading = pSensorReadReq->SensorReading; // } // pSensorReadRes->CompletionCode = CC_NORMAL; // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo.SensorSharedMemMutex); // return sizeof (SetSensorReadingRes_T); return 0; } /*------------------------------------------- * GetSensorSDR *-------------------------------------------*/ SDRRecHdr_T* SR_GetSensorSDR (uint8_t SensorNum) { SDRRecHdr_T* SDRRec; /* Search for the record containing the sensor */ SDRRec = SDR_GetFirstSDRRec (); while (0 != SDRRec) { switch (SDRRec->Type) { case FULL_SDR_REC : if ((( FullSensorRec_T*) SDRRec)->SensorNum == SensorNum) { return SDRRec; } break; case COMPACT_SDR_REC: { uint16_t SharedRecs = ((( CompactSensorRec_T*) SDRRec)->RecordSharing) & SHARED_RECD_COUNT; if ((SensorNum == (( CompactSensorRec_T*) SDRRec)->SensorNum ) || ((SensorNum >= ((( CompactSensorRec_T*) SDRRec)->SensorNum )) && (SensorNum < ((( CompactSensorRec_T*) SDRRec)->SensorNum + SharedRecs))) ) { return SDRRec; } } break; default : break; } /* Get the next record */ SDRRec = SDR_GetNextSDRRec (SDRRec); if (0 == SDRRec) { return 0; } } return 0; } ///** // * @brief Update global variables with number sensors. //**/ //static void //FindNumSensors () //{ // SDRRecHdr_T* pSDRRec; // FullSensorRec_T* pFSR; // CompactSensorRec_T* pCSR; // pFSR = 0; // pCSR = 0; // /* Get First SDR Record */ // pSDRRec = SDR_GetFirstSDRRec (); // while (0 != pSDRRec) // { // switch (pSDRRec->Type) // { // case FULL_SDR_REC : // pFSR = ( FullSensorRec_T*) pSDRRec; // if (THRESHOLD_SENSOR_CLASS == pFSR->EventTypeCode) // { // g_BMCInfo.SenConfig.NumThreshSensors++; // } // else // { // g_BMCInfo.SenConfig.NumNonThreshSensors++; // } // break; // case COMPACT_SDR_REC : // pCSR = ( CompactSensorRec_T*) pSDRRec; // if (THRESHOLD_SENSOR_CLASS == pCSR->EventTypeCode) // { // g_BMCInfo.SenConfig.NumThreshSensors += ( (pCSR->RecordSharing) & SHARED_RECD_COUNT); // } // else // { // g_BMCInfo.SenConfig.NumNonThreshSensors += ( (pCSR->RecordSharing) & SHARED_RECD_COUNT); // } // break; // default: // break; // } // /* Get the next record */ // pSDRRec = SDR_GetNextSDRRec (pSDRRec); // } // printf("Thereshold Sensors = %d\n",g_BMCInfo.SenConfig.NumThreshSensors); // printf("Non Thershold Sensors = %d\n",g_BMCInfo.SenConfig.NumNonThreshSensors); // return; //} int GetRecordIdsforDCMISensor (uint8_t EntityID,uint8_t SensorType, uint8_t EntityInstance, uint8_t StartingEntityInstance, uint16_t* pBuf, uint8_t* pTotalValidInstances) { printf("GetRecordIdsforDCMISensor not implement\r\n"); // int i, ValidInstances; // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // if (0 != EntityInstance) // { // *pTotalValidInstances = 0; // ValidInstances = 0; // /* Acquire Shared memory to populate sensor information */ // //OS_ACQUIRE_MUTEX(m_hSensorSharedMemMutex, SHARED_MEM_TIMEOUT); // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo[BMCInst].SensorSharedMemMutex, WAIT_INFINITE); // for (i = 0; i < MAX_SENSOR_NUMBERS + 1; i++ ) // { // if ((TRUE == pSenSharedMem->SensorInfo [i].IsDCMITempsensor) && (pSenSharedMem->SensorInfo[i].SDRRec->Type == FULL_SDR_REC) ) // { // if(SensorType != pSenSharedMem->SensorInfo[i].SensorTypeCode) // { // /*Check the Sensor type*/ // continue; // } // if ((((EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (EntityID == IPMI_INLET_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_INLET_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (EntityID == IPMI_CPU_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_CPU_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)))) // { // *pTotalValidInstances += 1; // if (EntityInstance == pSenSharedMem->SensorInfo [i].EntiryInstance) // { // pBuf [0] = pSenSharedMem->SensorInfo [i].RecordID; // ValidInstances = 1; // } // } // } // } // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // return ValidInstances; // } // else // { // *pTotalValidInstances = 0; // ValidInstances = 0; // /* Acquire Shared memory to populate sensor information */ // //OS_ACQUIRE_MUTEX(m_hSensorSharedMemMutex, SHARED_MEM_TIMEOUT); // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo[BMCInst].SensorSharedMemMutex, WAIT_INFINITE); // for (i = StartingEntityInstance; i < MAX_SENSOR_NUMBERS + 1; i++ ) // { // if ((TRUE == pSenSharedMem->SensorInfo [i].IsDCMITempsensor) && (pSenSharedMem->SensorInfo[i].SDRRec->Type == FULL_SDR_REC) ) // { // if(SensorType != pSenSharedMem->SensorInfo[i].SensorTypeCode) // { // /*Check the Sensor type*/ // continue; // } // if ((((EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (EntityID == IPMI_INLET_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_INLET_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (EntityID == IPMI_CPU_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_CPU_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)))) // { // *pTotalValidInstances += 1; // if (ValidInstances < 8) // { // pBuf [ValidInstances] = pSenSharedMem->SensorInfo [i].RecordID; // ValidInstances += 1; // } // } // } // } // /* Release mutex for Sensor shared memory */ // //OS_RELEASE_MUTEX(m_hSensorSharedMemMutex); // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // return (ValidInstances > 8) ? 8: ValidInstances; // } return 0; } int GetDCMITempReading(uint8_t EntityID,uint8_t SensorType, uint8_t EntityInstance, uint8_t StartingEntityInstance, uint8_t* pBuf, uint8_t* pTotalValidInstances) { printf("GetDCMITempReading not implement\r\n"); // int i, ValidInstances,j = 0; // SensorSharedMem_T* pSenSharedMem; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // pSenSharedMem = ( SensorSharedMem_T*)&g_BMCInfo.SensorSharedMem; //m_hSensorSharedMem; // SDRRecHdr_T* pSDRRec; // FullSensorRec_T* FullSDR; // float convreading = 0; // uint8_t MinReading = 0, MaxReading = 0,Linear = 0; // if (0 != EntityInstance) // { // *pTotalValidInstances = 0; // ValidInstances = 0; // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo[BMCInst].SensorSharedMemMutex, WAIT_INFINITE); // for (i = 0; i < MAX_SENSOR_NUMBERS + 1; i++ ) // { // if ((TRUE == pSenSharedMem->SensorInfo [i].IsDCMITempsensor) && (pSenSharedMem->SensorInfo[i].SDRRec->Type == FULL_SDR_REC) ) // { // if(SensorType != pSenSharedMem->SensorInfo[i].SensorTypeCode) // { // /*Check the Sensor type*/ // continue; // } // if ((((EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (EntityID == IPMI_INLET_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_INLET_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (EntityID == IPMI_CPU_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_CPU_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)))) // { // *pTotalValidInstances += 1; // if (EntityInstance == pSenSharedMem->SensorInfo [i].EntiryInstance) // { // if( !( pSenSharedMem->SensorInfo[i].EventFlags & 0x40) || (pSenSharedMem->SensorInfo[i].EventFlags & 0x20) ) // { // printf("event flag is disabled\n"); // pBuf[DCMI_TEMP_READING] = 0; // pBuf[DCMI_INST_NUMBER] = 0; // } // else // { // pSDRRec = GetSDRRec(pSenSharedMem->SensorInfo[i].SDRRec->ID,BMCInst); // // FullSDR = ( FullSensorRec_T *)pSDRRec; // MinReading = FullSDR->MinReading; // MaxReading = FullSDR->MaxReading; // Linear = FullSDR->Linearization; // // ipmi_conv_reading(pSenSharedMem->SensorInfo[i].SDRRec->Type, pSenSharedMem->SensorInfo[i].SensorReading, &convreading, MinReading,MaxReading, pSenSharedMem->SensorInfo[i].Units1,Linear, pSenSharedMem->SensorInfo[i].M_LSB, // pSenSharedMem->SensorInfo[i].B_LSB, pSenSharedMem->SensorInfo[i].M_MSB_Tolerance, pSenSharedMem->SensorInfo[i].B_MSB_Accuracy, pSenSharedMem->SensorInfo[i].RExp_BExp); // pBuf [DCMI_TEMP_READING] = (int8_t)convreading; // pBuf [DCMI_INST_NUMBER] = EntityInstance; // } // ValidInstances = 1; // } // } // } // } // /* Release mutex for Sensor shared memory */ // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // return ValidInstances; // } // else // { // *pTotalValidInstances = 0; // ValidInstances = 0; // OS_THREAD_MUTEX_ACQUIRE(&g_BMCInfo[BMCInst].SensorSharedMemMutex, WAIT_INFINITE); // for (i = StartingEntityInstance; i < MAX_SENSOR_NUMBERS + 1; i++ ) // { // if ((TRUE == pSenSharedMem->SensorInfo [i].IsDCMITempsensor) && (pSenSharedMem->SensorInfo[i].SDRRec->Type == FULL_SDR_REC) ) // { // if(SensorType != pSenSharedMem->SensorInfo[i].SensorTypeCode) // { // /*Check the Sensor type*/ // continue; // } // if ((((EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (EntityID == IPMI_INLET_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_INLET_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_INLET_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (EntityID == IPMI_CPU_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_CPU_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_CPU_TEMP_ENTITY_ID))) || // (((EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)) && ((pSenSharedMem->SensorInfo [i].EntityID == DCMI_BASEBOARD_TEMP_ENTITY_ID) || (pSenSharedMem->SensorInfo [i].EntityID == IPMI_BASEBOARD_TEMP_ENTITY_ID)))) // { // *pTotalValidInstances += 1; // if (ValidInstances < 8) // { // if( !( pSenSharedMem->SensorInfo[i].EventFlags & 0x40) || (pSenSharedMem->SensorInfo[i].EventFlags & 0x20) ) // { // pBuf[DCMI_TEMP_READING + j] = 0; // pBuf[DCMI_INST_NUMBER + j] = 0; // j = j+2; // } // else // { // pSDRRec = GetSDRRec(pSenSharedMem->SensorInfo[i].SDRRec->ID,BMCInst); // FullSDR = ( FullSensorRec_T *)pSDRRec; // MinReading = FullSDR->MinReading; // MaxReading = FullSDR->MaxReading; // Linear = FullSDR->Linearization; // // ipmi_conv_reading(pSenSharedMem->SensorInfo[i].SDRRec->Type, pSenSharedMem->SensorInfo[i].SensorReading, &convreading, MinReading,MaxReading, pSenSharedMem->SensorInfo[i].Units1,Linear, pSenSharedMem->SensorInfo[i].M_LSB, // pSenSharedMem->SensorInfo[i].B_LSB, pSenSharedMem->SensorInfo[i].M_MSB_Tolerance, pSenSharedMem->SensorInfo[i].B_MSB_Accuracy, pSenSharedMem->SensorInfo[i].RExp_BExp); // // pBuf[ j++] = (int8_t)convreading; // pBuf[ j++] = pSenSharedMem->SensorInfo[i].EntiryInstance; // TDBG("j value %d\n",j); // } // ValidInstances += 1; // } // } // } // } // OS_THREAD_MUTEX_RELEASE(&g_BMCInfo[BMCInst].SensorSharedMemMutex); // return (ValidInstances > 8) ? 8: ValidInstances; // } return 0; } #endif /* SENSOR_DEVICE */