From 3d20b3829eff8af61a2408f93ded2f9fbf3df8c1 Mon Sep 17 00:00:00 2001 From: "neethu.arambilsunny@sky.uk" Date: Mon, 28 Apr 2025 09:54:13 +0100 Subject: [PATCH 1/6] message --- ds/hdmiIn.cpp | 31 +++++ ds/include/hdmiIn.hpp | 3 + rpc/cli/dsHdmiIn.c | 66 ++++++++++ rpc/include/dsMgr.h | 7 + rpc/include/dsRpc.h | 17 +++ rpc/srv/dsHdmiIn.c | 294 +++++++++++++++++++++++++++++++++++++++++- 6 files changed, 415 insertions(+), 3 deletions(-) diff --git a/ds/hdmiIn.cpp b/ds/hdmiIn.cpp index a6418b7d..8c9fe8c2 100755 --- a/ds/hdmiIn.cpp +++ b/ds/hdmiIn.cpp @@ -547,6 +547,37 @@ void HdmiInput::getEdidVersion (int iHdmiPort, int *iEdidVersion) { printf ("%s:%d - EDID Version = %d\n", __PRETTY_FUNCTION__, __LINE__, *iEdidVersion); } +void HdmiInput::setVRRSupport(int iHdmiPort, bool vrrSupport) +{ + printf ("HdmiInput::setVRRSupport \r\n"); + dsError_t ret = dsHdmiInSetVRRSupport (static_cast(iHdmiPort), vrrSupport); + if (ret != dsERR_NONE) + { + throw Exception(ret); + } + printf ("%s:%d - Set VRR Support = %d\n", __PRETTY_FUNCTION__, __LINE__, vrrSupport); +} + +void HdmiInput::getVRRSupport (int iHdmiPort, bool *vrrSupport) { + printf ("HdmiInput::getVRRSupport \r\n"); + dsError_t ret = dsHdmiInGetVRRSupport (static_cast(iHdmiPort), vrrSupport); + if (ret != dsERR_NONE) + { + throw Exception(ret); + } + printf ("%s:%d - EDID VRR Support = %d\n", __PRETTY_FUNCTION__, __LINE__, *vrrSupport); +} + +void HdmiInput::getVRRStatus (int iHdmiPort, dsVRRType_t *vrrStatus) { + printf ("HdmiInput::getVRRStatus \r\n"); + dsError_t ret = dsHdmiInGetVRRStatus (static_cast(iHdmiPort), vrrStatus); + if (ret != dsERR_NONE) + { + throw Exception(ret); + } + printf ("%s:%d - VRR Status = %d\n", __FUNCTION__, __LINE__, *vrrStatus); +} + void HdmiInput::getHdmiALLMStatus (int iHdmiPort, bool *allmStatus) { printf ("HdmiInput::getHdmiALLMStatus \r\n"); dsError_t ret = dsGetAllmStatus (static_cast(iHdmiPort), allmStatus); diff --git a/ds/include/hdmiIn.hpp b/ds/include/hdmiIn.hpp index 6f130775..3348e193 100755 --- a/ds/include/hdmiIn.hpp +++ b/ds/include/hdmiIn.hpp @@ -97,6 +97,9 @@ class HdmiInput void getAVLatency(int *audio_latency,int *video_latency); void setEdid2AllmSupport(int iHdmiPort,bool allm_suppport); void getEdid2AllmSupport(int iHdmiPort, bool *allm_support); + void setVRRSupport (int iHdmiPort, bool vrr_suppport); + void getVRRSupport (int iHdmiPort, bool *vrr_suppport); + void getVRRStatus (int iHdmiPort, dsVRRType_t *vrrStatus); void getHdmiVersion (int iHdmiPort, dsHdmiMaxCapabilityVersion_t *capversion); private: HdmiInput (); /* default constructor */ diff --git a/rpc/cli/dsHdmiIn.c b/rpc/cli/dsHdmiIn.c index 49c7946b..a330e2ba 100755 --- a/rpc/cli/dsHdmiIn.c +++ b/rpc/cli/dsHdmiIn.c @@ -463,6 +463,72 @@ dsError_t dsGetEdid2AllmSupport (dsHdmiInPort_t iHdmiPort, bool *allm_support) return dsERR_GENERAL; } +dsError_t dsHdmiInSetVRRSupport (dsHdmiInPort_t iHdmiPort, bool vrr_support) +{ + _DEBUG_ENTER(); + + dsVRRSupportParam_t param; + IARM_Result_t rpcRet = IARM_RESULT_SUCCESS; + param.iHdmiPort = iHdmiPort; + param.vrrSupport = vrr_support; + rpcRet = IARM_Bus_Call (IARM_BUS_DSMGR_NAME, + (char *)IARM_BUS_DSMGR_API_dsSetVRRSupport, + (void *)¶m, + sizeof(param)); + + printf("[cli]: dsSetVRRSupport port :%d, vrrsupport :%d\n",param.iHdmiPort,param.vrrSupport); + if (IARM_RESULT_SUCCESS == rpcRet) + { + printf ("[cli] %s: dsSetVRRSupport eRet: %d \r\n", __FUNCTION__, param.result); + return param.result; + } + printf("%s:%d - dsERR_GENERAL\n", __PRETTY_FUNCTION__,__LINE__); + return dsERR_GENERAL; +} + +dsError_t dsHdmiInGetVRRSupport (dsHdmiInPort_t iHdmiPort, bool *vrr_support) +{ + _DEBUG_ENTER(); + + dsVRRSupportParam_t param; + IARM_Result_t rpcRet = IARM_RESULT_SUCCESS; + param.iHdmiPort = iHdmiPort; + rpcRet = IARM_Bus_Call (IARM_BUS_DSMGR_NAME, + (char *)IARM_BUS_DSMGR_API_dsGetVRRSupport, + (void *)¶m, + sizeof(param)); + + if (IARM_RESULT_SUCCESS == rpcRet) + { + *vrr_support = param.vrrSupport; + printf ("[cli] %s: dsGetVRRSupport: %d \r\n", __FUNCTION__, param.vrrSupport); + return param.result; + } + printf("%s:%d - dsERR_GENERAL\n", __PRETTY_FUNCTION__,__LINE__); + return dsERR_GENERAL; +} + +dsError_t dsHdmiInGetVRRStatus (dsHdmiInPort_t iHdmiPort, dsVRRType_t *vrrStatus) +{ + _DEBUG_ENTER(); + dsVRRStatusParam_t param; + IARM_Result_t rpcRet = IARM_RESULT_SUCCESS; + param.iHdmiPort = iHdmiPort; + rpcRet = IARM_Bus_Call (IARM_BUS_DSMGR_NAME, + (char *)IARM_BUS_DSMGR_API_dsGetVRRStatus, + (void *)¶m, + sizeof(param)); + + if (IARM_RESULT_SUCCESS == rpcRet) + { + *vrrStatus = param.vrrStatus; + printf ("[cli] %s: dsGetVRRStatus VRR Status: %d \r\n", __FUNCTION__, param.vrrStatus); + return param.result; + } + printf("%s:%d - dsERR_GENERAL\n", __FUNCTION__,__LINE__); + return dsERR_GENERAL; +} + dsError_t dsGetHdmiVersion (dsHdmiInPort_t iHdmiPort, dsHdmiMaxCapabilityVersion_t *capversion) { _DEBUG_ENTER(); diff --git a/rpc/include/dsMgr.h b/rpc/include/dsMgr.h index 98ae9fb6..49cf9c2c 100755 --- a/rpc/include/dsMgr.h +++ b/rpc/include/dsMgr.h @@ -57,6 +57,7 @@ typedef enum _DSMgr_EventId_t { IARM_BUS_DSMGR_EVENT_HDMI_IN_STATUS, /*!< HDMI IN status change event */ IARM_BUS_DSMGR_EVENT_HDMI_IN_VIDEO_MODE_UPDATE, /*!< HDMI IN video mode update event */ IARM_BUS_DSMGR_EVENT_HDMI_IN_ALLM_STATUS, /*!< HDMI IN ALLM mode update event */ + IARM_BUS_DSMGR_EVENT_HDMI_IN_VRR_STATUS, /*!< HDMI IN VRR mode update event */ IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_HOTPLUG, /*!< COMPOSITE IN HPD change event */ IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_SIGNAL_STATUS, /*!< COMPOSITE IN signal status change event */ IARM_BUS_DSMGR_EVENT_COMPOSITE_IN_STATUS, /*!< COMPOSITE IN status change event */ @@ -230,6 +231,12 @@ typedef struct _DSMgr_EventData_t { bool allm_mode; }hdmi_in_allm_mode; /*HDMI in ALLM Mode change*/ + struct _HDMI_IN_VRR_MODE_DATA{ + /* Declare HDMI In VRR Mode*/ + dsHdmiInPort_t port; + dsVRRType_t vrr_type; + }hdmi_in_vrr_mode; /*HDMI in VRR Mode change*/ + struct _HDMI_IN_CONTENT_TYPE_DATA{ /* Declare HDMI In ALLM Mode*/ dsHdmiInPort_t port; diff --git a/rpc/include/dsRpc.h b/rpc/include/dsRpc.h index 1c5c31c6..55226e8a 100644 --- a/rpc/include/dsRpc.h +++ b/rpc/include/dsRpc.h @@ -236,6 +236,9 @@ extern "C" { #define IARM_BUS_DSMGR_API_dsSetEdid2AllmSupport "dsSetEdid2AllmSupport" #define IARM_BUS_DSMGR_API_dsGetEdid2AllmSupport "dsGetEdid2AllmSupport" #define IARM_BUS_DSMGR_API_dsGetAllmStatus "dsGetAllmStatus" +#define IARM_BUS_DSMGR_API_dsSetVRRSupport "dsSetVRRSupport" +#define IARM_BUS_DSMGR_API_dsGetVRRSupport "dsGetVRRSupport" +#define IARM_BUS_DSMGR_API_dsGetVRRStatus "dsGetVRRStatus" #define IARM_BUS_DSMGR_API_dsGetSupportedGameFeaturesList "dsGetSupportedGameFeaturesList" #define IARM_BUS_DSMGR_API_dsGetAVLatency "dsGetAVLatency" #define IARM_BUS_DSMGR_API_dsGetHdmiVersion "dsGetHdmiVersion" @@ -1009,6 +1012,20 @@ typedef struct _dsEdidAllmSupportParam_t bool allmSupport; }dsEdidAllmSupportParam_t; +typedef struct _dsVRRSupportParam_t +{ + dsError_t result; + dsHdmiInPort_t iHdmiPort; + bool vrrSupport; +}dsVRRSupportParam_t; + +typedef struct _dsVRRStatusParam_t +{ + dsError_t result; + dsHdmiInPort_t iHdmiPort; + dsVRRType_t vrrStatus; +}dsVRRStatusParam_t; + typedef struct _dsGetHDMIARCPortIdParam_t { dsError_t result; int portId; diff --git a/rpc/srv/dsHdmiIn.c b/rpc/srv/dsHdmiIn.c index 7bf1d948..7ea2ad3c 100755 --- a/rpc/srv/dsHdmiIn.c +++ b/rpc/srv/dsHdmiIn.c @@ -87,6 +87,8 @@ static int m_isPlatInitialized=0; static pthread_mutex_t fpLock = PTHREAD_MUTEX_INITIALIZER; static tv_hdmi_edid_version_t m_edidversion[dsHDMI_IN_PORT_MAX]; static bool m_edidallmsupport[dsHDMI_IN_PORT_MAX]; +static bool m_vrrsupport[dsHDMI_IN_PORT_MAX]; +static bool m_vrrsupportCaps[dsHDMI_IN_PORT_MAX]; IARM_Result_t dsHdmiInMgr_init(); IARM_Result_t dsHdmiInMgr_term(); IARM_Result_t _dsHdmiInInit(void *arg); @@ -110,14 +112,20 @@ IARM_Result_t _dsGetSupportedGameFeaturesList (void *arg); IARM_Result_t _dsGetAVLatency (void *arg); IARM_Result_t _dsSetEdid2AllmSupport (void *arg); IARM_Result_t _dsGetEdid2AllmSupport (void *arg); +IARM_Result_t _dsSetVRRSupport (void *arg); +IARM_Result_t _dsGetVRRSupport (void *arg); +IARM_Result_t _dsGetVRRStatus (void *arg); IARM_Result_t _dsGetHdmiVersion (void *arg); static dsError_t setEdid2AllmSupport (dsHdmiInPort_t iHdmiPort, bool allmSupport); +static dsError_t setVRRSupport (dsHdmiInPort_t iHdmiPort, bool vrrSupport); +static dsError_t getVRRSupport (dsHdmiInPort_t iHdmiPort, bool *vrrSupport); void _dsHdmiInConnectCB(dsHdmiInPort_t port, bool isPortConnected); void _dsHdmiInSignalChangeCB(dsHdmiInPort_t port, dsHdmiInSignalStatus_t sigStatus); void _dsHdmiInStatusChangeCB(dsHdmiInStatus_t inputStatus); void _dsHdmiInVideoModeUpdateCB(dsHdmiInPort_t port, dsVideoPortResolution_t videoResolution); void _dsHdmiInAllmChangeCB(dsHdmiInPort_t port, bool allm_mode); +void _dsHdmiInVRRChangeCB(dsHdmiInPort_t port, dsVRRType_t vrr_type); void _dsHdmiInAviContentTypeChangeCB(dsHdmiInPort_t port, dsAviContentType_t content_type); void _dsHdmiInAVLatencyChangeCB(int audio_latency, int video_latency); @@ -284,11 +292,12 @@ static dsError_t setEdidVersion (dsHdmiInPort_t iHdmiPort, tv_hdmi_edid_version_ INT_DEBUG("Port %s: Persist EDID Version: %d\n", "HDMI2", iEdidVersion); break; } - // Whenever there is a change in edid version to 2.0, ensure the edid allm support is updated with latest value + // Whenever there is a change in edid version to 2.0, ensure the edid allm support and edid vrr support is updated with latest value if(iEdidVersion == HDMI_EDID_VER_20) { - INT_INFO("As the version is changed to 2.0, we are updating the allm bit in edid\n"); + INT_INFO("As the version is changed to 2.0, we are updating the allm bit and the vrr bit in edid\n"); setEdid2AllmSupport(iHdmiPort,m_edidallmsupport[iHdmiPort]); + setVRRSupport(iHdmiPort,m_vrrsupport[iHdmiPort]); } } INT_INFO("[srv] %s: dsSetEdidVersionFunc eRet: %d \r\n", __FUNCTION__, eRet); @@ -577,6 +586,27 @@ IARM_Result_t _dsHdmiInInit(void *arg) if(allmChangeCBFunc) { allmChangeCBFunc(_dsHdmiInAllmChangeCB); } + + typedef dsError_t (*dsHdmiInRegisterVRRChangeCB_t)(dsHdmiInVRRChangeCB_t CBFunc); + static dsHdmiInRegisterVRRChangeCB_t vrrChangeCBFunc = 0; + if (vrrChangeCBFunc == 0) { + void *dllib = dlopen(RDK_DSHAL_NAME, RTLD_LAZY); + if (dllib) { + vrrChangeCBFunc = (dsHdmiInRegisterVRRChangeCB_t) dlsym(dllib, "dsHdmiInRegisterVRRChangeCB"); + if(vrrChangeCBFunc == 0) { + INT_INFO("dsHdmiInRegisterVRRChangeCB(dsHdmiInVRRChangeCB_t) is not defined\r\n"); + } + dlclose(dllib); + } + else { + INT_ERROR("Opening RDK_DSHAL_NAME [%s] failed\r\n", RDK_DSHAL_NAME); + } + } + + if(vrrChangeCBFunc) { + vrrChangeCBFunc(_dsHdmiInVRRChangeCB); + } + typedef dsError_t (*dsHdmiInRegisterAviContentTypeChangeCB_t)(dsHdmiInAviContentTypeChangeCB_t CBFunc); static dsHdmiInRegisterAviContentTypeChangeCB_t contentTypeChangeCBFunc = 0; if (contentTypeChangeCBFunc == 0) { @@ -635,8 +665,14 @@ IARM_Result_t _dsHdmiInInit(void *arg) IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetAVLatency, _dsGetAVLatency); IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsSetEdid2AllmSupport, _dsSetEdid2AllmSupport); IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetEdid2AllmSupport, _dsGetEdid2AllmSupport); + IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsSetVRRSupport, _dsSetVRRSupport); + IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetVRRSupport, _dsGetVRRSupport); + IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetVRRStatus, _dsGetVRRStatus); IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetHdmiVersion, _dsGetHdmiVersion); + m_vrrsupport[dsHDMI_IN_PORT_2] = true; + m_vrrsupport[dsHDMI_IN_PORT_3] = true; + int itr = 0; bool isARCCapable = false; for (itr = 0; itr < dsHDMI_IN_PORT_MAX; itr++) { @@ -688,6 +724,63 @@ IARM_Result_t _dsHdmiInInit(void *arg) INT_INFO("Port %s: Exception in Getting the HDMI2 EDID allm support from persistence storage..... \r\n", "HDMI2"); m_edidallmsupport[dsHDMI_IN_PORT_2] = true; } + + // Getting the edidvrrEnable value from persistence upon bootup + std::string _VRRSupport("TRUE"); + try { + _VRRSupport = device::HostPersistence::getInstance().getProperty("HDMI0.vrrEnable"); + if(_VRRSupport == "TRUE") + m_vrrsupport[dsHDMI_IN_PORT_0] = true; + else + m_vrrsupport[dsHDMI_IN_PORT_0] = false; + + INT_INFO("Port %s: _VRRSupport: %s , m_vrrsupport: %d\n", "HDMI0", _VRRSupport.c_str(), m_vrrsupport[0]); + } + catch(...) { + INT_INFO("Port %s: Exception in Getting the HDMI0 EDID VRR support from persistence storage..... \r\n", "HDMI0"); + m_vrrsupport[dsHDMI_IN_PORT_0] = false; + } + + try { + _VRRSupport = device::HostPersistence::getInstance().getProperty("HDMI1.vrrEnable"); + if(_VRRSupport == "TRUE") + m_vrrsupport[dsHDMI_IN_PORT_1] = true; + else + m_vrrsupport[dsHDMI_IN_PORT_1] = false; + + INT_INFO("Port %s: _VRRSupport: %s , m_edidallmsupport: %d\n", "HDMI1", _VRRSupport.c_str(), m_vrrsupport[1]); + } + catch(...) { + INT_INFO("Port %s: Exception in Getting the HDMI1 EDID VRR support from persistence storage..... \r\n", "HDMI1"); + m_vrrsupport[dsHDMI_IN_PORT_1] = false; + } + + try { + _VRRSupport = device::HostPersistence::getInstance().getProperty("HDMI2.vrrEnable"); + if(_VRRSupport == "TRUE") + m_vrrsupport[dsHDMI_IN_PORT_2] = true; + else + m_vrrsupport[dsHDMI_IN_PORT_2] = false; + + INT_INFO("Port %s: _vrrSupport: %s , m_vrrsupport: %d\n", "HDMI2", _VRRSupport.c_str(), m_vrrsupport[2]); + } + catch(...) { + INT_INFO("Port %s: Exception in Getting the HDMI2 EDID VRR support from persistence storage..... \r\n", "HDMI2"); + m_vrrsupport[dsHDMI_IN_PORT_2] = true; + } + try { + _VRRSupport = device::HostPersistence::getInstance().getProperty("HDMI3.vrrEnable"); + if(_VRRSupport == "TRUE") + m_vrrsupport[dsHDMI_IN_PORT_3] = true; + else + m_vrrsupport[dsHDMI_IN_PORT_3] = false; + + INT_INFO("Port %s: _vrrSupport: %s , m_vrrsupport: %d\n", "HDMI3", _VRRSupport.c_str(), m_vrrsupport[3]); + } + catch(...) { + INT_INFO("Port %s: Exception in Getting the HDMI3 EDID VRR support from persistence storage..... \r\n", "HDMI3"); + m_vrrsupport[dsHDMI_IN_PORT_3] = true; + } std::string _EdidVersion("1"); try { @@ -735,7 +828,13 @@ IARM_Result_t _dsHdmiInInit(void *arg) m_edidversion[dsHDMI_IN_PORT_2] = HDMI_EDID_VER_20; } } - + + for (itr = 0; itr < dsHDMI_IN_PORT_MAX; itr++) { + if (getVRRSupport(static_cast(itr), &m_vrrsupportCaps[itr]) >= 0) { + INT_INFO("Port HDMI%d: VRR capability : %d\n", itr, m_vrrsupportCaps[itr]); + } + } + for (itr = 0; itr < dsHDMI_IN_PORT_MAX; itr++) { if (setEdidVersion (static_cast(itr), m_edidversion[itr]) >= 0) { INT_INFO("Port HDMI%d: Initialized EDID Version : %d\n", itr, m_edidversion[itr]); @@ -990,6 +1089,22 @@ void _dsHdmiInAllmChangeCB(dsHdmiInPort_t port, bool allm_mode) sizeof(hdmi_in_allmMode_eventData)); } + +void _dsHdmiInVRRChangeCB(dsHdmiInPort_t port, dsVRRType_t vrr_type) +{ + IARM_Bus_DSMgr_EventData_t hdmi_in_vrrMode_eventData; + + INT_INFO("%s:%d - HDMI In VRR Mode update!!!!!! Port: %d, VRR TYPE: %d\r\n", __FUNCTION__,__LINE__,port, vrr_type); + hdmi_in_vrrMode_eventData.data.hdmi_in_vrr_mode.port = port; + hdmi_in_vrrMode_eventData.data.hdmi_in_vrr_mode.vrr_type = vrr_type; + + IARM_Bus_BroadcastEvent(IARM_BUS_DSMGR_NAME, + (IARM_EventId_t)IARM_BUS_DSMGR_EVENT_HDMI_IN_VRR_STATUS, + (void *)&hdmi_in_vrrMode_eventData, + sizeof(hdmi_in_vrrMode_eventData)); + +} + void _dsHdmiInAviContentTypeChangeCB(dsHdmiInPort_t port, dsAviContentType_t avi_content_type) { IARM_Bus_DSMgr_EventData_t hdmi_in_contentType_eventData; @@ -1232,6 +1347,179 @@ IARM_Result_t _dsGetEdid2AllmSupport (void *arg) return IARM_RESULT_SUCCESS; } +void updateVRRBitValuesInPersistence(dsHdmiInPort_t iHdmiPort, bool vrrSupport) +{ + INT_INFO("[srv]: Updating values of vrr bit in persistence\n"); + switch(iHdmiPort){ + case dsHDMI_IN_PORT_0: + device::HostPersistence::getInstance().persistHostProperty("HDMI0.vrrEnable", vrrSupport ? "TRUE" : "FALSE"); + INT_INFO("Port %s: Persist EDID VRR Bit: %d\n", "HDMI0", vrrSupport); + break; + case dsHDMI_IN_PORT_1: + device::HostPersistence::getInstance().persistHostProperty("HDMI1.vrrEnable", vrrSupport ? "TRUE" : "FALSE"); + INT_INFO("Port %s: Persist EDID VRR Bit: %d\n", "HDMI1", vrrSupport); + break; + case dsHDMI_IN_PORT_2: + device::HostPersistence::getInstance().persistHostProperty("HDMI2.vrrEnable", vrrSupport ? "TRUE" : "FALSE"); + INT_INFO("Port %s: Persist EDID VRR Bit: %d\n", "HDMI2", vrrSupport); + break; + case dsHDMI_IN_PORT_3: + device::HostPersistence::getInstance().persistHostProperty("HDMI3.vrrEnable", vrrSupport ? "TRUE" : "FALSE"); + INT_INFO("Port %s: Persist EDID VRR Bit: %d\n", "HDMI3", vrrSupport); + break; + } +} + +static dsError_t setVRRSupport (dsHdmiInPort_t iHdmiPort, bool vrrSupport) { + dsError_t eRet = dsERR_GENERAL; + if (!m_vrrsupportCaps[iHdmiPort]) { + return dsERR_OPERATION_NOT_SUPPORTED; + } + typedef dsError_t (*dsHdmiInSetVRRSupport_t)(dsHdmiInPort_t iHdmiPort, bool vrrSupport); + static dsHdmiInSetVRRSupport_t dsHdmiInSetVRRSupportFunc = 0; + + if (dsHdmiInSetVRRSupportFunc == 0) { + void *dllib = dlopen(RDK_DSHAL_NAME, RTLD_LAZY); + if (dllib) { + dsHdmiInSetVRRSupportFunc = (dsHdmiInSetVRRSupport_t) dlsym(dllib, "dsHdmiInSetVRRSupport"); + if(dsHdmiInSetVRRSupportFunc == 0) { + INT_INFO("%s:%d dsHdmiInSetVRRSupport (int,bool) is not defined %s\r\n", __FUNCTION__, __LINE__, dlerror()); + } + else { + INT_DEBUG("%s:%d dsHdmiInSetVRRSupport loaded\r\n", __FUNCTION__, __LINE__); + } + dlclose(dllib); + } + else { + INT_ERROR("%s:%d dsHdmiInSetVRRSupport Opening RDK_DSHAL_NAME [%s] failed %s\r\n", + __FUNCTION__, __LINE__, RDK_DSHAL_NAME, dlerror()); + } + } + INT_INFO("setVRRSupport to ds-hal: EDID VRR Bit: %d\n", vrrSupport); + if (0 != dsHdmiInSetVRRSupportFunc) { + eRet = dsHdmiInSetVRRSupportFunc (iHdmiPort, vrrSupport); + INT_INFO("[srv] %s: dsHdmiInSetVRRSupportFunc eRet: %d \r\n", __FUNCTION__, eRet); + } + else { + INT_INFO("%s: dsHdmiInSetVRRSupportFunc = %p\n", __FUNCTION__, dsHdmiInSetVRRSupportFunc); + } + return eRet; +} + +IARM_Result_t _dsSetVRRSupport (void *arg) +{ + _DEBUG_ENTER(); + + dsVRRSupportParam_t *param = (dsVRRSupportParam_t *) arg; + param->result = dsERR_NONE; + INT_INFO("[srv] : In _dsSetVRRSupport, checking m_ediversion of port %d : %d\n",param->iHdmiPort,m_edidversion[param->iHdmiPort]); + IARM_BUS_Lock(lock); + if(m_edidversion[param->iHdmiPort] == HDMI_EDID_VER_20)//if the edidver is 2.0, then only set the VRR bit in edid + { + param->result = setVRRSupport (param->iHdmiPort, param->vrrSupport); + } + INT_INFO("[srv] %s: dsSetVRRSupport Port: %d vrrSupport: %d eRet: %d\r\n", __FUNCTION__, param->iHdmiPort, param->vrrSupport, param->result); + if(param->result == dsERR_NONE) + { + updateVRRBitValuesInPersistence(param->iHdmiPort,param->vrrSupport); + m_vrrsupport[param->iHdmiPort] = param->vrrSupport; + } + IARM_BUS_Unlock(lock); + return IARM_RESULT_SUCCESS; +} + +static dsError_t getVRRSupport (dsHdmiInPort_t iHdmiPort, bool *vrrSupport) { + dsError_t eRet = dsERR_GENERAL; + typedef dsError_t (*dsHdmiInGetVRRSupport_t)(dsHdmiInPort_t iHdmiPort, bool *vrrSupport); + static dsHdmiInGetVRRSupport_t dsHdmiInGetVRRSupportFunc = 0; + + if (dsHdmiInGetVRRSupportFunc == 0) { + void *dllib = dlopen(RDK_DSHAL_NAME, RTLD_LAZY); + if (dllib) { + dsHdmiInGetVRRSupportFunc = (dsHdmiInGetVRRSupport_t) dlsym(dllib, "dsHdmiInGetVRRSupport"); + if(dsHdmiInGetVRRSupportFunc == 0) { + INT_INFO("%s:%d dsHdmiInGetVRRSupport (int,bool) is not defined %s\r\n", __FUNCTION__, __LINE__, dlerror()); + } + else { + INT_DEBUG("%s:%d dsHdmiInGetVRRSupport loaded\r\n", __FUNCTION__, __LINE__); + } + dlclose(dllib); + } + else { + INT_ERROR("%s:%d dsHdmiInGetVRRSupport Opening RDK_DSHAL_NAME [%s] failed %s\r\n", + __FUNCTION__, __LINE__, RDK_DSHAL_NAME, dlerror()); + } + } + if (0 != dsHdmiInGetVRRSupportFunc) { + eRet = dsHdmiInGetVRRSupportFunc (iHdmiPort, vrrSupport); + INT_INFO("[srv] %s: dsHdmiInGetVRRSupportFunc eRet: %d \r\n", __FUNCTION__, eRet); + } + else { + INT_INFO("%s: dsHdmiInGetVRRSupportFunc = %p\n", __FUNCTION__, dsHdmiInGetVRRSupportFunc); + } + return eRet; +} + +IARM_Result_t _dsGetVRRSupport (void *arg) +{ + _DEBUG_ENTER(); + bool vrrSupport = false; + dsVRRSupportParam_t *param = (dsVRRSupportParam_t *) arg; + IARM_BUS_Lock(lock); + param->result = dsERR_NONE; + // getVRRSupport will return the latest vrr bit value of the specified port(which is written to persistence) + // irrespective of the edid version, the latest value is returned. + param->vrrSupport = m_vrrsupport[param->iHdmiPort]; + INT_INFO("[srv] %s: dsGetVRRSupport : %d for port %d\r\n", __FUNCTION__, param->vrrSupport,param->iHdmiPort); + IARM_BUS_Unlock(lock); + return IARM_RESULT_SUCCESS; +} + +static dsError_t getVRRStatus (dsHdmiInPort_t iHdmiPort, dsVRRType_t *vrrStatus) { + dsError_t eRet = dsERR_GENERAL; + typedef dsError_t (*dsHdmiInGetVRRStatus_t)(dsHdmiInPort_t iHdmiPort, dsVRRType_t *vrrStatus); + static dsHdmiInGetVRRStatus_t dsHdmiInGetVRRStatusFunc = 0; + if (dsHdmiInGetVRRStatusFunc == 0) { + void *dllib = dlopen(RDK_DSHAL_NAME, RTLD_LAZY); + if (dllib) { + dsHdmiInGetVRRStatusFunc = (dsHdmiInGetVRRStatus_t) dlsym(dllib, "dsHdmiInGetVRRStatus"); + if(dsHdmiInGetVRRStatusFunc == 0) { + INT_INFO("%s:%d dsHdmiInGetVRRStatus (int) is not defined %s\r\n", __FUNCTION__, __LINE__, dlerror()); + } + else { + INT_DEBUG("%s:%d dsHdmiInGetVRRStatusFunc loaded\r\n", __FUNCTION__, __LINE__); + } + dlclose(dllib); + } + else { + INT_ERROR("%s:%d dsHdmiInGetVRRStatus Opening RDK_DSHAL_NAME [%s] failed %s\r\n", + __FUNCTION__, __LINE__, RDK_DSHAL_NAME, dlerror()); + } + } + if (0 != dsHdmiInGetVRRStatusFunc) { + eRet = dsHdmiInGetVRRStatusFunc (iHdmiPort, vrrStatus); + INT_INFO("[srv] %s: dsHdmiInGetVRRStatusFunc eRet: %d \r\n", __FUNCTION__, eRet); + } + else { + INT_INFO("%s: dsHdmiInGetVRRStatusFunc = %p\n", __FUNCTION__, dsHdmiInGetVRRStatusFunc); + } + return eRet; +} + +IARM_Result_t _dsGetVRRStatus (void *arg) +{ + dsVRRType_t vrrStatus = dsVRR_NONE; + _DEBUG_ENTER(); + + dsVRRStatusParam_t *param = (dsVRRStatusParam_t *) arg; + IARM_BUS_Lock(lock); + param->result = getVRRStatus (param->iHdmiPort, &vrrStatus); + param->vrrStatus = vrrStatus; + INT_INFO("[srv] %s: dsGetVRRStatus vrrStatus: %d\r\n", __FUNCTION__, param->vrrStatus); + IARM_BUS_Unlock(lock); + return IARM_RESULT_SUCCESS; +} + IARM_Result_t _dsGetHdmiVersion (void *arg) { dsError_t eRet = dsERR_GENERAL; From 49bf73fecb283bc4d5219a7ec2e0d795aa87a730 Mon Sep 17 00:00:00 2001 From: neethuas379 Date: Tue, 29 Apr 2025 09:22:57 +0530 Subject: [PATCH 2/6] Update dsHdmiIn.c --- rpc/srv/dsHdmiIn.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/rpc/srv/dsHdmiIn.c b/rpc/srv/dsHdmiIn.c index 7ea2ad3c..d1d8b363 100755 --- a/rpc/srv/dsHdmiIn.c +++ b/rpc/srv/dsHdmiIn.c @@ -88,7 +88,7 @@ static pthread_mutex_t fpLock = PTHREAD_MUTEX_INITIALIZER; static tv_hdmi_edid_version_t m_edidversion[dsHDMI_IN_PORT_MAX]; static bool m_edidallmsupport[dsHDMI_IN_PORT_MAX]; static bool m_vrrsupport[dsHDMI_IN_PORT_MAX]; -static bool m_vrrsupportCaps[dsHDMI_IN_PORT_MAX]; +static bool m_hdmiPortVrrCaps[dsHDMI_IN_PORT_MAX]; IARM_Result_t dsHdmiInMgr_init(); IARM_Result_t dsHdmiInMgr_term(); IARM_Result_t _dsHdmiInInit(void *arg); @@ -670,9 +670,6 @@ IARM_Result_t _dsHdmiInInit(void *arg) IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetVRRStatus, _dsGetVRRStatus); IARM_Bus_RegisterCall(IARM_BUS_DSMGR_API_dsGetHdmiVersion, _dsGetHdmiVersion); - m_vrrsupport[dsHDMI_IN_PORT_2] = true; - m_vrrsupport[dsHDMI_IN_PORT_3] = true; - int itr = 0; bool isARCCapable = false; for (itr = 0; itr < dsHDMI_IN_PORT_MAX; itr++) { @@ -830,8 +827,8 @@ IARM_Result_t _dsHdmiInInit(void *arg) } for (itr = 0; itr < dsHDMI_IN_PORT_MAX; itr++) { - if (getVRRSupport(static_cast(itr), &m_vrrsupportCaps[itr]) >= 0) { - INT_INFO("Port HDMI%d: VRR capability : %d\n", itr, m_vrrsupportCaps[itr]); + if (getVRRSupport(static_cast(itr), &m_hdmiPortVrrCaps[itr]) >= 0) { + INT_INFO("Port HDMI%d: VRR capability : %d\n", itr, m_hdmiPortVrrCaps[itr]); } } @@ -1372,7 +1369,7 @@ void updateVRRBitValuesInPersistence(dsHdmiInPort_t iHdmiPort, bool vrrSupport) static dsError_t setVRRSupport (dsHdmiInPort_t iHdmiPort, bool vrrSupport) { dsError_t eRet = dsERR_GENERAL; - if (!m_vrrsupportCaps[iHdmiPort]) { + if (!m_hdmiPortVrrCaps[iHdmiPort]) { return dsERR_OPERATION_NOT_SUPPORTED; } typedef dsError_t (*dsHdmiInSetVRRSupport_t)(dsHdmiInPort_t iHdmiPort, bool vrrSupport); From 3b54d9a6c758615908a455f48e1f15b72d8bd112 Mon Sep 17 00:00:00 2001 From: neethuas379 Date: Tue, 29 Apr 2025 09:22:57 +0530 Subject: [PATCH 3/6] Update dsHdmiIn.c --- ds/hdmiIn.cpp | 1 + rpc/cli/dsHdmiIn.c | 3 ++- rpc/include/dsInternal.h | 23 +++++++++++++++++++++++ 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/ds/hdmiIn.cpp b/ds/hdmiIn.cpp index 8c9fe8c2..7309893b 100755 --- a/ds/hdmiIn.cpp +++ b/ds/hdmiIn.cpp @@ -65,6 +65,7 @@ #include "dsHdmiIn.h" #include "dsUtl.h" #include "edid-parser.hpp" +#include "dsInternal.h" namespace device diff --git a/rpc/cli/dsHdmiIn.c b/rpc/cli/dsHdmiIn.c index a330e2ba..1066c3fb 100755 --- a/rpc/cli/dsHdmiIn.c +++ b/rpc/cli/dsHdmiIn.c @@ -53,7 +53,8 @@ #include "iarmUtil.h" #include "libIARM.h" #include "libIBus.h" -#include "safec_lib.h" +#include "safec_lib.h" +#include "dsInternal.h" dsError_t dsHdmiInInit (void) diff --git a/rpc/include/dsInternal.h b/rpc/include/dsInternal.h index 1c7e65ac..50fbd81c 100644 --- a/rpc/include/dsInternal.h +++ b/rpc/include/dsInternal.h @@ -258,6 +258,29 @@ dsError_t dsVideoPortSetPreferredColorDepth(intptr_t handle,dsDisplayColorDepth_ */ dsError_t dsVideoPortGetPreferredColorDepth(intptr_t handle, dsDisplayColorDepth_t *colorDepth, bool persist ); +/** + * @brief Gets the EDID ALLM support + * + * For sink devices, this function gets the EDID ALLM support. + * For source devices, this function returns dsERR_OPERATION_NOT_SUPPORTED always. + * + * @param[in] iHdmiPort - HDMI input port. Please refer ::dsHdmiInPort_t + * @param[in] allmSupport - Allm support. False for disabled, True for enabled + * + * @return dsError_t - Status + * @retval dsERR_NONE - Success + * @retval dsERR_NOT_INITIALIZED - Module is not initialised + * @retval dsERR_INVALID_PARAM - Parameter passed to this function is invalid + * @retval dsERR_OPERATION_NOT_SUPPORTED - The attempted operation is not supported; e.g: source devices + * @retval dsERR_OPERATION_FAILED - The attempted operation has failed + * + * @pre dsHdmiInInit() must be called before calling this API + * + * @warning This API is Not thread safe + * + */ +dsError_t dsGetEdid2AllmSupport (dsHdmiInPort_t iHdmiPort, bool *allmSupport); + /** * @brief Gets the encoding type of an audio port * From d6d98c8f6f49a10f06ab0c1f38b0d3a0c799ab9a Mon Sep 17 00:00:00 2001 From: neethuas379 Date: Fri, 2 May 2025 17:49:03 +0530 Subject: [PATCH 4/6] Update hdmiIn.cpp --- ds/hdmiIn.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/ds/hdmiIn.cpp b/ds/hdmiIn.cpp index 7309893b..aeb9b33e 100755 --- a/ds/hdmiIn.cpp +++ b/ds/hdmiIn.cpp @@ -550,7 +550,6 @@ void HdmiInput::getEdidVersion (int iHdmiPort, int *iEdidVersion) { void HdmiInput::setVRRSupport(int iHdmiPort, bool vrrSupport) { - printf ("HdmiInput::setVRRSupport \r\n"); dsError_t ret = dsHdmiInSetVRRSupport (static_cast(iHdmiPort), vrrSupport); if (ret != dsERR_NONE) { @@ -560,7 +559,6 @@ void HdmiInput::setVRRSupport(int iHdmiPort, bool vrrSupport) } void HdmiInput::getVRRSupport (int iHdmiPort, bool *vrrSupport) { - printf ("HdmiInput::getVRRSupport \r\n"); dsError_t ret = dsHdmiInGetVRRSupport (static_cast(iHdmiPort), vrrSupport); if (ret != dsERR_NONE) { @@ -570,7 +568,6 @@ void HdmiInput::getVRRSupport (int iHdmiPort, bool *vrrSupport) { } void HdmiInput::getVRRStatus (int iHdmiPort, dsVRRType_t *vrrStatus) { - printf ("HdmiInput::getVRRStatus \r\n"); dsError_t ret = dsHdmiInGetVRRStatus (static_cast(iHdmiPort), vrrStatus); if (ret != dsERR_NONE) { From 5455986339e893a568a74ab7db41228bf4346fcd Mon Sep 17 00:00:00 2001 From: neethuas379 Date: Fri, 2 May 2025 17:54:06 +0530 Subject: [PATCH 5/6] Update dsHdmiIn.c --- rpc/cli/dsHdmiIn.c | 1 - 1 file changed, 1 deletion(-) diff --git a/rpc/cli/dsHdmiIn.c b/rpc/cli/dsHdmiIn.c index 1066c3fb..bd095b73 100755 --- a/rpc/cli/dsHdmiIn.c +++ b/rpc/cli/dsHdmiIn.c @@ -477,7 +477,6 @@ dsError_t dsHdmiInSetVRRSupport (dsHdmiInPort_t iHdmiPort, bool vrr_support) (void *)¶m, sizeof(param)); - printf("[cli]: dsSetVRRSupport port :%d, vrrsupport :%d\n",param.iHdmiPort,param.vrrSupport); if (IARM_RESULT_SUCCESS == rpcRet) { printf ("[cli] %s: dsSetVRRSupport eRet: %d \r\n", __FUNCTION__, param.result); From bf0109d70d3a35b7af266a2877e510eea45db930 Mon Sep 17 00:00:00 2001 From: neethuas379 Date: Fri, 2 May 2025 18:07:26 +0530 Subject: [PATCH 6/6] Update dsHdmiIn.c --- rpc/srv/dsHdmiIn.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rpc/srv/dsHdmiIn.c b/rpc/srv/dsHdmiIn.c index d1d8b363..59aa178a 100755 --- a/rpc/srv/dsHdmiIn.c +++ b/rpc/srv/dsHdmiIn.c @@ -745,7 +745,7 @@ IARM_Result_t _dsHdmiInInit(void *arg) else m_vrrsupport[dsHDMI_IN_PORT_1] = false; - INT_INFO("Port %s: _VRRSupport: %s , m_edidallmsupport: %d\n", "HDMI1", _VRRSupport.c_str(), m_vrrsupport[1]); + INT_INFO("Port %s: _VRRSupport: %s , m_vrrsupport: %d\n", "HDMI1", _VRRSupport.c_str(), m_vrrsupport[1]); } catch(...) { INT_INFO("Port %s: Exception in Getting the HDMI1 EDID VRR support from persistence storage..... \r\n", "HDMI1");