Merge "libdrm-meson: Expand libdrm-meson API Function List [1/1]"
diff --git a/meson/libdrm_meson_connector.h b/meson/libdrm_meson_connector.h
index 538d35f..ab339e3 100644
--- a/meson/libdrm_meson_connector.h
+++ b/meson/libdrm_meson_connector.h
@@ -6,13 +6,11 @@
*
* Description:
*/
-
#ifndef LIBDRM_MESON_CONNECTOR_H_
#define LIBDRM_MESON_CONNECTOR_H_
#if defined(__cplusplus)
extern "C" {
#endif
-
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
@@ -34,6 +32,9 @@
#define DRM_CONNECTOR_PROP_DV_ENABLE "dv_enable"
#define DRM_CONNECTOR_PROP_COLOR_SPACE "color_space"
#define DRM_CONNECTOR_PROP_COLOR_DEPTH "color_depth"
+#define DRM_CONNECTOR_PROP_Content_Type "content type"
+#define DRM_CONNECTOR_PROP_ACTIVE "ACTIVE"
+#define DRM_CONNECTOR_VRR_ENABLED "VRR_ENABLED"
struct mesonConnector;
struct mesonConnector *mesonConnectorCreate(int drmFd, int type);
diff --git a/meson/meson_drm_settings.c b/meson/meson_drm_settings.c
index cfb3d97..08b54a7 100644
--- a/meson/meson_drm_settings.c
+++ b/meson/meson_drm_settings.c
@@ -18,7 +18,6 @@
#include "libdrm_meson_property.h"
#include "meson_drm_settings.h"
-
#define DEFAULT_CARD "/dev/dri/card0"
#define PROP_NAME_MAX_LEN 50
static int meson_drm_get_crtc_prop_value( int drmFd, MESON_CONNECTOR_TYPE connType,
@@ -135,6 +134,7 @@
if (drmFd >= 0)
close(drmFd);
}
+
static int meson_drm_set_property(int drmFd, drmModeAtomicReq *req, uint32_t objId,
uint32_t objType, char* name, uint64_t value)
{
@@ -155,6 +155,77 @@
return rc;
}
+int meson_drm_getPreferredMode( DisplayMode* mode) {
+ int ret = -1;
+ int i = 0;
+ int count = 0;
+ drmModeModeInfo* modes = NULL;
+ int drmFd = -1;
+ struct mesonConnector* conn = NULL;
+ drmFd = meson_open_drm();
+ conn = mesonConnectorCreate(drmFd, DRM_MODE_CONNECTOR_HDMIA);
+ if (conn == NULL || drmFd < 0)
+ {
+ printf("\n%s %d connector create fail\n",__FUNCTION__,__LINE__);
+ }
+ if (0 != mesonConnectorGetModes(conn, drmFd, &modes, &count))
+ goto out;
+ for (i = 0; i < count; i++)
+ {
+ if (modes[i].type & DRM_MODE_TYPE_PREFERRED)
+ {
+ mode->w = modes[i].hdisplay;
+ mode->h = modes[i].vdisplay;
+ mode->interlace = (modes[i].flags & DRM_MODE_FLAG_INTERLACE) ? true : false;
+ strcpy(mode->name, modes[i].name );
+ break;
+ }
+ }
+ ret = 0;
+out:
+ if (conn)
+ mesonConnectorDestroy(drmFd,conn);
+ if (drmFd >= 0 )
+ close(drmFd);
+ return ret;
+}
+
+int meson_drm_getsupportedModesList(int drmFd, DisplayMode** modeInfo, int* modeCount )
+{
+ int ret = -1;
+ struct mesonConnector* conn = NULL;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n %s %d invalid parameter return\n",__FUNCTION__,__LINE__);
+ return ret;
+ }
+ conn = mesonConnectorCreate(drmFd, DRM_MODE_CONNECTOR_HDMIA);
+ if (conn == NULL || drmFd < 0)
+ {
+ printf("\n%s %d connector create fail\n",__FUNCTION__,__LINE__);
+ }
+ drmModeModeInfo* modeall = NULL;
+ int count = 0;
+ int i = 0;
+ if (0 != mesonConnectorGetModes(conn, drmFd, &modeall, &count))
+ goto out;
+ DisplayMode* modestemp = (DisplayMode*)calloc(count, sizeof(DisplayMode));
+ for (i = 0; i < count; i++)
+ {
+ modestemp[i].w = modeall[i].hdisplay;
+ modestemp[i].h = modeall[i].vdisplay;
+ modestemp[i].vrefresh = modeall[i].vrefresh;
+ modestemp[i].interlace = (modeall[i].flags & DRM_MODE_FLAG_INTERLACE) ? true : false;
+ strcpy(modestemp[i].name, modeall[i].name );
+ }
+ *modeCount = count;
+ *modeInfo = modestemp;
+ ret = 0;
+out:
+ if (conn)
+ mesonConnectorDestroy(drmFd,conn);
+ return ret;
+}
+
int meson_drm_getModeInfo(int drmFd, MESON_CONNECTOR_TYPE connType, DisplayMode* modeInfo)
{
int ret = -1;
@@ -538,6 +609,23 @@
ret = 0;
return ret;
}
+
+int meson_drm_getAVMute( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", MESON_DRM_HDMITX_PROP_AVMUTE);
+ uint32_t value = 0;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_conn_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ fprintf(stderr, "\n AVMute control, 1 means set avmute, 0 means not avmute\n");
+ return value;
+}
+
ENUM_MESON_HDCPAUTH_STATUS meson_drm_getHdcpAuthStatus( int drmFd, MESON_CONNECTOR_TYPE connType )
{
char propName[PROP_NAME_MAX_LEN] = {'\0'};
@@ -579,5 +667,241 @@
return ret;
}
+int meson_drm_setHDCPContentType(int drmFd, drmModeAtomicReq *req,
+ ENUM_MESON_HDCP_Content_Type HDCPType, MESON_CONNECTOR_TYPE connType)
+{
+ int ret = -1;
+ int rc = -1;
+ struct mesonConnector* conn = NULL;
+ uint32_t connId = 0;
+ if ( drmFd < 0 || req == NULL) {
+ fprintf(stderr, "\n %s %d invalid parameter return\n",__FUNCTION__,__LINE__);
+ return ret;
+ }
+ conn = get_current_connector(drmFd, connType);
+ if (conn) {
+ connId = mesonConnectorGetId(conn);
+ rc = meson_drm_set_property(drmFd, req, connId, DRM_MODE_OBJECT_CONNECTOR,
+ DRM_CONNECTOR_PROP_CONTENT_TYPE, (uint64_t)HDCPType);
+ mesonConnectorDestroy(drmFd,conn);
+ }
+ if (rc >= 0)
+ ret = 0;
+ return ret;
+}
+
+ENUM_MESON_HDCP_Content_Type meson_drm_getHDCPContentType( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_CONTENT_TYPE);
+ uint32_t value = 0;
+ ENUM_MESON_HDCP_Content_Type ContentType = MESON_HDCP_Type_RESERVED;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return ContentType;
+ }
+ if ( 0 == meson_drm_get_conn_prop_value( drmFd, connType, propName, &value )) {
+ switch (value)
+ {
+ case 0:
+ ContentType = MESON_HDCP_Type0;
+ break;
+ case 1:
+ ContentType = MESON_HDCP_Type1;
+ break;
+ default:
+ ContentType = MESON_HDCP_Type_RESERVED;
+ break;
+ }
+ } else {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ return ContentType;
+}
+
+MESON_CONTENT_TYPE meson_drm_getContentType(int drmFd, MESON_CONNECTOR_TYPE connType ) {
+
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_Content_Type);
+ uint32_t value = 0;
+ MESON_CONTENT_TYPE ContentType = MESON_CONTENT_TYPE_RESERVED;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return ContentType;
+ }
+ if ( 0 == meson_drm_get_conn_prop_value(drmFd, connType, propName, &value )) {
+ switch (value)
+ {
+ case 0:
+ ContentType = MESON_CONTENT_TYPE_Data;
+ break;
+ case 1:
+ ContentType = MESON_CONTENT_TYPE_Graphics;
+ break;
+ case 2:
+ ContentType = MESON_CONTENT_TYPE_Photo;
+ break;
+ case 3:
+ ContentType = MESON_CONTENT_TYPE_Cinema;
+ break;
+ case 4:
+ ContentType = MESON_CONTENT_TYPE_Game;
+ break;
+ default:
+ ContentType = MESON_CONTENT_TYPE_RESERVED;
+ break;
+ }
+ } else {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ return ContentType;
+}
+
+int meson_drm_setDvEnable(int drmFd, drmModeAtomicReq *req,
+ uint32_t dvEnable, MESON_CONNECTOR_TYPE connType)
+{
+ int ret = -1;
+ int rc = -1;
+ struct mesonConnector* conn = NULL;
+ uint32_t crtcId = 0;
+ conn = get_current_connector(drmFd, connType);
+ if ( drmFd < 0 || req == NULL) {
+ fprintf(stderr, "\n %s %d invalid parameter return\n",__FUNCTION__,__LINE__);
+ return ret;
+ }
+ if (conn) {
+ crtcId = mesonConnectorGetCRTCId(conn);
+ rc = meson_drm_set_property(drmFd, req, crtcId, DRM_MODE_OBJECT_CRTC,
+ DRM_CONNECTOR_PROP_DV_ENABLE, (uint64_t)dvEnable);
+ mesonConnectorDestroy(drmFd,conn);
+ }
+ if (rc >= 0)
+ ret = 0;
+ return ret;
+}
+
+int meson_drm_getDvEnable( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_DV_ENABLE);
+ uint32_t value = -1;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_crtc_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ return value;
+}
+
+int meson_drm_setActive(int drmFd, drmModeAtomicReq *req,
+ uint32_t active, MESON_CONNECTOR_TYPE connType)
+{
+ int ret = -1;
+ int rc = -1;
+ struct mesonConnector* conn = NULL;
+ uint32_t crtcId = 0;
+ conn = get_current_connector(drmFd, connType);
+ if ( drmFd < 0 || req == NULL) {
+ fprintf(stderr, "\n %s %d invalid parameter return\n",__FUNCTION__,__LINE__);
+ return ret;
+ }
+ if (conn) {
+ crtcId = mesonConnectorGetCRTCId(conn);
+ rc = meson_drm_set_property(drmFd, req, crtcId, DRM_MODE_OBJECT_CRTC,
+ DRM_CONNECTOR_PROP_ACTIVE, (uint64_t)active);
+ mesonConnectorDestroy(drmFd,conn);
+ }
+ if (rc >= 0)
+ ret = 0;
+ return ret;
+}
+
+int meson_drm_getActive( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_ACTIVE);
+ uint32_t value = 0;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_crtc_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ return value;
+}
+
+int meson_drm_setVrrEnabled(int drmFd, drmModeAtomicReq *req,
+ uint32_t VrrEnable, MESON_CONNECTOR_TYPE connType)
+{
+ int ret = -1;
+ int rc = -1;
+ struct mesonConnector* conn = NULL;
+ uint32_t crtcId = 0;
+ conn = get_current_connector(drmFd, connType);
+ if ( drmFd < 0 || req == NULL) {
+ fprintf(stderr, "\n %s %d invalid parameter return\n",__FUNCTION__,__LINE__);
+ return ret;
+ }
+ if (conn) {
+ crtcId = mesonConnectorGetCRTCId(conn);
+ rc = meson_drm_set_property(drmFd, req, crtcId, DRM_MODE_OBJECT_CRTC,
+ DRM_CONNECTOR_VRR_ENABLED, (uint64_t)VrrEnable);
+ mesonConnectorDestroy(drmFd,conn);
+ }
+ if (rc >= 0)
+ ret = 0;
+ return ret;
+}
+
+int meson_drm_getVrrEnabled( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_VRR_ENABLED);
+ uint32_t value = 0;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_crtc_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ return value;
+}
+
+int meson_drm_getHdrCap( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_RX_HDR_CAP);
+ uint32_t value = 0;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_conn_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ fprintf(stderr, "hdr_cap：presents the RX HDR capability [r]\n");
+ return value;
+}
+
+int meson_drm_getDvCap( int drmFd, MESON_CONNECTOR_TYPE connType )
+{
+ char propName[PROP_NAME_MAX_LEN] = {'\0'};
+ sprintf( propName, "%s", DRM_CONNECTOR_PROP_RX_DV_CAP);
+ uint32_t value = 0;
+ if ( drmFd < 0) {
+ fprintf(stderr, "\n%s %d drmFd < 0\n",__FUNCTION__,__LINE__);
+ return value;
+ }
+ if ( 0 != meson_drm_get_conn_prop_value( drmFd, connType, propName, &value )) {
+ fprintf(stderr, "\n%s %d fail\n",__FUNCTION__,__LINE__);
+ }
+ fprintf(stderr, "dv_cap：presents the RX dolbyvision capability, [r] such as std or ll mode \n");
+ return value;
+}
+
diff --git a/meson/meson_drm_settings.h b/meson/meson_drm_settings.h
index b7c4258..e776b54 100644
--- a/meson/meson_drm_settings.h
+++ b/meson/meson_drm_settings.h
@@ -6,7 +6,6 @@
*
* Description:
*/
-
#ifndef MESON_DRM_SETTINGS_H_
#define MESON_DRM_SETTINGS_H_
#include <stdio.h>
@@ -20,6 +19,22 @@
#endif
#define DRM_DISPLAY_MODE_LEN 32
+typedef enum _MESON_CONTENT_TYPE {
+ MESON_CONTENT_TYPE_Data = 0,
+ MESON_CONTENT_TYPE_Graphics,
+ MESON_CONTENT_TYPE_Photo,
+ MESON_CONTENT_TYPE_Cinema,
+ MESON_CONTENT_TYPE_Game,
+ MESON_CONTENT_TYPE_RESERVED
+} MESON_CONTENT_TYPE;
+
+/*HDCP transmission time divided into Type0&Type1 content*/
+typedef enum _ENUM_MESON_HDCP_Content_Type{
+ MESON_HDCP_Type0 = 0, //Type0 represents support for both 1.4 and 2.2
+ MESON_HDCP_Type1, //Type1 represents only support for 2.2
+ MESON_HDCP_Type_RESERVED
+} ENUM_MESON_HDCP_Content_Type;
+
typedef enum {
MESON_DISCONNECTED = 0,
MESON_CONNECTED = 1,
@@ -27,10 +42,10 @@
} ENUM_MESON_CONN_CONNECTION;
typedef struct _DisplayMode {
- uint16_t w;
- uint16_t h;
- uint32_t vrefresh;
- bool interlace;
+ uint16_t w; //<--Number of horizontal pixels in the effective display area-->//
+ uint16_t h; //<--Number of vertical pixels in the effective display area-->//
+ uint32_t vrefresh; //<--Display refresh rate--->//
+ bool interlace; //<--Indicates which scanning form to choose, P represents progressive scanning, and i represents interlaced scanning; The default interlace value is 0 for P 1 for i-->//
char name[DRM_DISPLAY_MODE_LEN];
} DisplayMode;
@@ -76,6 +91,26 @@
MESON_AUTH_STATUS_SUCCESS
} ENUM_MESON_HDCPAUTH_STATUS;
+int meson_drm_setContentType(int drmFd, drmModeAtomicReq *req,
+ MESON_CONTENT_TYPE contentType, MESON_CONNECTOR_TYPE connType);
+
+int meson_drm_setVrrEnabled(int drmFd, drmModeAtomicReq *req,
+ uint32_t VrrEnable, MESON_CONNECTOR_TYPE connType);
+int meson_drm_getVrrEnabled( int drmFd, MESON_CONNECTOR_TYPE connType );
+
+
+int meson_drm_getActive( int drmFd, MESON_CONNECTOR_TYPE connType );
+
+int meson_drm_setActive(int drmFd, drmModeAtomicReq *req,
+ uint32_t active, MESON_CONNECTOR_TYPE connType);
+
+int meson_drm_getDvEnable( int drmFd, MESON_CONNECTOR_TYPE connType );
+int meson_drm_setDvEnable(int drmFd, drmModeAtomicReq *req,
+ uint32_t dvEnable, MESON_CONNECTOR_TYPE connType);
+
+MESON_CONTENT_TYPE meson_drm_getContentType(int drmFd, MESON_CONNECTOR_TYPE connType );
+
+
int meson_drm_changeMode(int drmFd, drmModeAtomicReq *req,
DisplayMode* modeInfo, MESON_CONNECTOR_TYPE connType);
int meson_drm_getModeInfo(int drmFd, MESON_CONNECTOR_TYPE connType, DisplayMode* mode );
@@ -99,10 +134,24 @@
void meson_drm_getEDIDData(int drmFd, MESON_CONNECTOR_TYPE connType, int * data_Len, char **data );
int meson_drm_setAVMute(int drmFd, drmModeAtomicReq *req,
bool mute, MESON_CONNECTOR_TYPE connType);
+int meson_drm_getAVMute( int drmFd, MESON_CONNECTOR_TYPE connType );
+
ENUM_MESON_HDCPAUTH_STATUS meson_drm_getHdcpAuthStatus( int drmFd, MESON_CONNECTOR_TYPE connType );
int meson_drm_setHDCPEnable(int drmFd, drmModeAtomicReq *req,
bool enable, MESON_CONNECTOR_TYPE connType);
+int meson_drm_getsupportedModesList(int drmFd, DisplayMode** modeInfo, int* modeCount );
+int meson_drm_getPreferredMode( DisplayMode* mode);
+
+int meson_drm_setHDCPContentType(int drmFd, drmModeAtomicReq *req,
+ ENUM_MESON_HDCP_Content_Type HDCPType, MESON_CONNECTOR_TYPE connType);
+ENUM_MESON_HDCP_Content_Type meson_drm_getHDCPContentType( int drmFd, MESON_CONNECTOR_TYPE connType );
+
+int meson_drm_getHdcpVer( int drmFd, MESON_CONNECTOR_TYPE connType );
+
+int meson_drm_getHdrCap( int drmFd, MESON_CONNECTOR_TYPE connType );
+int meson_drm_getDvCap( int drmFd, MESON_CONNECTOR_TYPE connType );
+
int meson_open_drm();
void meson_close_drm(int drmFd);
diff --git a/meson/meson_drm_settings_test.c b/meson/meson_drm_settings_test.c
index 3b1fc08..18834ab 100644
--- a/meson/meson_drm_settings_test.c
+++ b/meson/meson_drm_settings_test.c
@@ -29,7 +29,9 @@
select_len = scanf("%d",&select_s_g);
if (select_s_g == 1 && select_len == 1) {
printf("get value: 1.HDCP version 2.HDMI connected 3.color space 4. color depth"
- "5. hdr mode 6. mode 7. hdr policy 8. EDID 9. hdcp auth status\n");
+ "5. hdr mode 6. mode 7. hdr policy 8. EDID 9. hdcp auth status 10.supportedModesList"
+ " 11.prefer mode 12.HDCP Content Type 13.Content Type 14.Dv Enable 15.active "
+ " 16.vrr Enable 17.AVMute 18.Hdrcap 19.DvCap\n");
int get = 0;
int drmFd = meson_open_drm();
int len = scanf("%d", &get);
@@ -91,10 +93,70 @@
value = meson_drm_getHdcpAuthStatus( drmFd, MESON_CONNECTOR_HDMIA );
printf("\n MESON_AUTH_STATUS_FAIL = 0 \n"
" MESON_AUTH_STATUS_SUCCESS = 1 \n value:%d\n", value);
+ } else if (get == 10 && len == 1) {
+ DisplayMode* modes = NULL;
+ int count = 0;
+ if (0 == meson_drm_getsupportedModesList(drmFd, &modes, &count )) {
+ printf("\n mode count:%d\n",count);
+ int i = 0;
+ for (int i=0; i<count; i++) {
+ printf(" (%s %d %d %d %d)\n", modes[i].name, modes[i].w, modes[i].h, modes[i].interlace,modes[i].vrefresh);
+ }
+ if (modes)
+ free(modes);
+ } else {
+ printf("\n %s fail\n",__FUNCTION__);
+ }
+ } else if (get == 11 && len == 1) {
+ DisplayMode mode;
+ if (0 == meson_drm_getPreferredMode(&mode)) {
+ printf(" (%s %d %d %d)\n", mode.name, mode.w, mode.h, mode.interlace);
+ } else {
+ printf("\n %s fail\n",__FUNCTION__);
+ }
+ } else if (get == 12 && len == 1) {
+ ENUM_MESON_HDCP_Content_Type value = MESON_HDCP_Type_RESERVED;
+ value = meson_drm_getHDCPContentType(drmFd, MESON_CONNECTOR_HDMIA);
+ printf("\n MESON_HDCP_Type0 = 0 \n"
+ " MESON_HDCP_Type1 = 1 \n value:%d\n", value);
+ } else if (get == 13 && len == 1) {
+ ENUM_MESON_COLOR_SPACE value = meson_drm_getContentType( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n MESON_Content_Type_Data = 0 \n"
+ "MESON_Content_Type_Graphics = 1 \n"
+ "MESON_Content_Type_Photo = 2 \n"
+ "MESON_Content_Type_Cinema = 3 \n"
+ "MESON_Content_Type_Game = 4 \n value:%d\n"
+ , value);
+ } else if (get == 14 && len == 1) {
+ int value = meson_drm_getDvEnable( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n Dv_Enable:%d\n",value);
+ if (value == 1) {
+ printf("Support Dolbyvision\n");
+ } else {
+ printf("Dolbyvision not supported\n");
+ }
+ } else if (get == 15 && len == 1) {
+ int value = meson_drm_getActive( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n Active:%d\n",value);
+ } else if (get == 16 && len == 1) {
+ int value = meson_drm_getVrrEnabled( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n Vrr_Enabled:%d\n",value);
+ } else if (get == 17 && len == 1) {
+ int value = meson_drm_getAVMute( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n AVMute:%d\n",value);
+ } else if (get == 18 && len == 1) {
+ // presents the RX HDR capability
+ int value = meson_drm_getHdrCap( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n HdrCap:%d\n",value);
+ } else if (get == 19 && len == 1) {
+ // presents the RX dolbyvision capability, [r] such as std or ll mode
+ int value = meson_drm_getDvCap( drmFd, MESON_CONNECTOR_HDMIA );
+ printf("\n DvCap:%d\n",value);
}
meson_close_drm(drmFd);
} else if (select_s_g == 0 && select_len == 1) {
- printf("set value:1.av mute 2.HDMI HDCP enable \n");
+ printf("set value:1.av mute 2.HDMI HDCP enable 3.HDCP Content Type "
+ " 4.DvEnable 5.active 6.vrr Enable\n");
int set = 0;
int ret = -1;
drmModeAtomicReq * req;
@@ -126,7 +188,47 @@
len = scanf("%d", &hdcpEnable);
if (len == 1) {
if (meson_drm_setHDCPEnable( drmFd, req, hdcpEnable, MESON_CONNECTOR_HDMIA))
- printf("\n meson_drm_setAVMute fail:\n");
+ printf("\n meson_drm_setHDCPEnable fail:\n");
+ } else {
+ printf("\n scanf fail\n");
+ }
+ } else if (set == 3 && len == 1) {
+ printf("\n HDCP Content Type:\n");
+ int HDCPContentType = 0;
+ len = scanf("%d", &HDCPContentType);
+ if (len == 1) {
+ if (meson_drm_setHDCPContentType( drmFd, req, HDCPContentType, MESON_CONNECTOR_HDMIA))
+ printf("\n meson_drm_setHDCPContentType fail:\n");
+ } else {
+ printf("\n scanf fail\n");
+ }
+ } else if (set == 4 && len == 1) {
+ printf("\n DvEnable:\n");
+ int dvEnable = 0;
+ len = scanf("%d", &dvEnable);
+ if (len == 1) {
+ if (meson_drm_setDvEnable( drmFd, req, dvEnable, MESON_CONNECTOR_HDMIA))
+ printf("\n meson_drm_setDv_Enable fail:\n");
+ } else {
+ printf("\n scanf fail\n");
+ }
+ } else if (set == 5 && len == 1) {
+ printf("\n Active:\n");
+ int active = 0;
+ len = scanf("%d", &active);
+ if (len == 1) {
+ if (meson_drm_setActive( drmFd, req, active, MESON_CONNECTOR_HDMIA))
+ printf("\n meson_drm_setActive fail:\n");
+ } else {
+ printf("\n scanf fail\n");
+ }
+ } else if (set == 6 && len == 1) {
+ printf("\n vrr Enable:\n");
+ int vrrEnable = 0;
+ len = scanf("%d", &vrrEnable);
+ if (len == 1) {
+ if (meson_drm_setVrrEnabled( drmFd, req, vrrEnable, MESON_CONNECTOR_HDMIA))
+ printf("\n meson_drm_setVrr_Enabled fail:\n");
} else {
printf("\n scanf fail\n");
}