diff --git a/gralloc/gr_priv_handle.h b/gralloc/gr_priv_handle.h
index 1eb03b8..964bed0 100644
--- a/gralloc/gr_priv_handle.h
+++ b/gralloc/gr_priv_handle.h
@@ -58,6 +58,7 @@
     PRIV_FLAGS_UBWC_ALIGNED = 0x08000000,
     PRIV_FLAGS_DISP_CONSUMER = 0x10000000,
     PRIV_FLAGS_CLIENT_ALLOCATED = 0x20000000,  // Ion buffer allocated outside of gralloc
+    PRIV_FLAGS_UBWC_ALIGNED_PI = 0x40000000,  // PI format
   };
 
   // file-descriptors dup'd over IPC
diff --git a/gralloc/gralloc_priv.h b/gralloc/gralloc_priv.h
index 5bb3139..45e1240 100644
--- a/gralloc/gralloc_priv.h
+++ b/gralloc/gralloc_priv.h
@@ -49,11 +49,19 @@
  * cannot be used with noncontiguous heaps */
 #define GRALLOC_USAGE_PRIVATE_UNCACHED (UINT32_C(1) << 29)
 
-/* This flag is used to indicate P010 format */
+/* This flag is used to indicate 10 bit format.
+ * When both GRALLOC_USAGE_PRIVATE_ALLOC_UBWC & GRALLOC_USAGE_PRIVATE_10BIT
+ * are set then it will indicate UBWC_TP10 format.
+ * When only GRALLOC_USAGE_PRIVATE_10BIT is set it will indicate linear P010 format.
+ */
 #define GRALLOC_USAGE_PRIVATE_10BIT (UINT32_C(1) << 30)
 
 /* This flag is used for SECURE display usecase */
 #define GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY (UINT32_C(1) << 31)
+
+/* This flag is used to indicate video NV21 format */
+#define GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER 1ULL << 48
+
 /* unused legacy flags */
 #define GRALLOC_USAGE_PRIVATE_MM_HEAP 0
 #define GRALLOC_USAGE_PRIVATE_IOMMU_HEAP 0
@@ -63,8 +71,11 @@
 /* This flag is set for WFD usecase */
 #define GRALLOC_USAGE_PRIVATE_WFD (UINT32_C(1) << 21)
 
-/* This flag is used to indicate 10-bit tight pack format (e.g. TP10) */
-#define GRALLOC_USAGE_PRIVATE_10BIT_TP (UINT32_C(1) << 27)
+/* TODO(user): Remove when clients stop referencing this flag */
+#define GRALLOC_USAGE_PRIVATE_10BIT_TP 0
+
+/* This flag indicates PI format is being used */
+#define GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI 1ULL << 49
 
 /* Legacy gralloc1 definitions */
 /* Some clients may still be using the old flags */
@@ -76,6 +87,7 @@
 #define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT GRALLOC_USAGE_PRIVATE_10BIT
 #define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP GRALLOC_USAGE_PRIVATE_10BIT_TP
 #define GRALLOC1_CONSUMER_USAGE_PRIVATE_10BIT_TP GRALLOC_USAGE_PRIVATE_10BIT_TP
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_VIDEO_NV21_ENCODER GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER
 
 // for PERFORM API :
 #define GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER 1
@@ -93,11 +105,13 @@
 #define GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE 13
 #define GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS 14
 #define GRALLOC1_MODULE_PERFORM_GET_INTERLACE_FLAG 15
+#define GRALLOC_MODULE_PERFORM_GET_GRAPHICS_METADATA 16
 
 // OEM specific HAL formats
 #define HAL_PIXEL_FORMAT_RGBA_5551 6
 #define HAL_PIXEL_FORMAT_RGBA_4444 7
 #define HAL_PIXEL_FORMAT_NV12_ENCODEABLE 0x102
+#define HAL_PIXEL_FORMAT_NV21_ENCODEABLE 0x7FA30C00
 #define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS 0x7FA30C04
 #define HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED 0x7FA30C03
 #define HAL_PIXEL_FORMAT_YCbCr_420_SP 0x109
diff --git a/libqdmetadata/qdMetaData.cpp b/libqdmetadata/qdMetaData.cpp
index e7ab48c..3259ee2 100644
--- a/libqdmetadata/qdMetaData.cpp
+++ b/libqdmetadata/qdMetaData.cpp
@@ -133,6 +133,13 @@
         case SET_VIDEO_PERF_MODE:
             data->isVideoPerfMode = *((uint32_t *)param);
             break;
+        case SET_GRAPHICS_METADATA: {
+             GraphicsMetadata payload = *((GraphicsMetadata*)(param));
+             data->graphics_metadata.size = payload.size;
+             memcpy(data->graphics_metadata.data, payload.data,
+                    sizeof(data->graphics_metadata.data));
+             break;
+        }
         default:
             ALOGE("Unknown paramType %d", paramType);
             break;
@@ -271,6 +278,12 @@
                 ret = 0;
             }
             break;
+        case GET_GRAPHICS_METADATA:
+            if (data->operation & SET_GRAPHICS_METADATA) {
+                memcpy(param, data->graphics_metadata.data, sizeof(data->graphics_metadata.data));
+                ret = 0;
+            }
+            break;
         default:
             ALOGE("Unknown paramType %d", paramType);
             break;
diff --git a/libqdmetadata/qdMetaData.h b/libqdmetadata/qdMetaData.h
index 65ab1b7..195fdd2 100644
--- a/libqdmetadata/qdMetaData.h
+++ b/libqdmetadata/qdMetaData.h
@@ -37,6 +37,7 @@
 #endif
 
 #define MAX_UBWC_STATS_LENGTH 32
+#define GRAPHICS_METADATA_SIZE 4096
 
 enum ColorSpace_t{
     ITU_R_601,
@@ -97,6 +98,11 @@
     uint32_t s3dMode; /* the S3D format of this layer to be accessed by client */
 };
 
+typedef struct GraphicsMetadata {
+    uint32_t size;
+    uint32_t data[GRAPHICS_METADATA_SIZE];
+} GraphicsMetadata;
+
 struct MetaData_t {
     int32_t operation;
     int32_t interlaced;
@@ -137,42 +143,47 @@
     /* Set by camera to indicate that this buffer will be used for a High
      * Performance Video Usecase */
     uint32_t isVideoPerfMode;
+    /* Populated and used by adreno during buffer size calculation.
+     * Set only for RGB formats. */
+    GraphicsMetadata graphics_metadata;
 };
 
 enum DispParamType {
-    SET_VT_TIMESTAMP         = 0x0001,
-    COLOR_METADATA           = 0x0002,
-    PP_PARAM_INTERLACED      = 0x0004,
-    SET_VIDEO_PERF_MODE      = 0x0008,
-    UNUSED3                  = 0x0010,
-    UNUSED4                  = 0x0020,
-    SET_UBWC_CR_STATS_INFO   = 0x0040,
-    UPDATE_BUFFER_GEOMETRY   = 0x0080,
-    UPDATE_REFRESH_RATE      = 0x0100,
-    UPDATE_COLOR_SPACE       = 0x0200,
-    MAP_SECURE_BUFFER        = 0x0400,
-    S3D_FORMAT               = 0x0800,
-    LINEAR_FORMAT            = 0x1000,
-    SET_IGC                  = 0x2000,
-    SET_SINGLE_BUFFER_MODE   = 0x4000,
-    SET_S3D_COMP             = 0x8000,
+    SET_VT_TIMESTAMP           = 0x0001,
+    COLOR_METADATA             = 0x0002,
+    PP_PARAM_INTERLACED        = 0x0004,
+    SET_VIDEO_PERF_MODE        = 0x0008,
+    SET_GRAPHICS_METADATA      = 0x0010,
+    SET_UNUSED                 = 0x0020,
+    SET_UBWC_CR_STATS_INFO     = 0x0040,
+    UPDATE_BUFFER_GEOMETRY     = 0x0080,
+    UPDATE_REFRESH_RATE        = 0x0100,
+    UPDATE_COLOR_SPACE         = 0x0200,
+    MAP_SECURE_BUFFER          = 0x0400,
+    S3D_FORMAT                 = 0x0800,
+    LINEAR_FORMAT              = 0x1000,
+    SET_IGC                    = 0x2000,
+    SET_SINGLE_BUFFER_MODE     = 0x4000,
+    SET_S3D_COMP               = 0x8000,
 };
 
 enum DispFetchParamType {
-    GET_VT_TIMESTAMP         = 0x0001,
-    GET_COLOR_METADATA       = 0x0002,
-    GET_PP_PARAM_INTERLACED  = 0x0004,
-    GET_VIDEO_PERF_MODE      = 0x0008,
-    GET_UBWC_CR_STATS_INFO   = 0x0040,
-    GET_BUFFER_GEOMETRY      = 0x0080,
-    GET_REFRESH_RATE         = 0x0100,
-    GET_COLOR_SPACE          = 0x0200,
-    GET_MAP_SECURE_BUFFER    = 0x0400,
-    GET_S3D_FORMAT           = 0x0800,
-    GET_LINEAR_FORMAT        = 0x1000,
-    GET_IGC                  = 0x2000,
-    GET_SINGLE_BUFFER_MODE   = 0x4000,
-    GET_S3D_COMP             = 0x8000,
+    GET_VT_TIMESTAMP          = 0x0001,
+    GET_COLOR_METADATA        = 0x0002,
+    GET_PP_PARAM_INTERLACED   = 0x0004,
+    GET_VIDEO_PERF_MODE       = 0x0008,
+    GET_GRAPHICS_METADATA     = 0x0010,
+    GET_UNUSED                = 0X0020,
+    GET_UBWC_CR_STATS_INFO    = 0x0040,
+    GET_BUFFER_GEOMETRY       = 0x0080,
+    GET_REFRESH_RATE          = 0x0100,
+    GET_COLOR_SPACE           = 0x0200,
+    GET_MAP_SECURE_BUFFER     = 0x0400,
+    GET_S3D_FORMAT            = 0x0800,
+    GET_LINEAR_FORMAT         = 0x1000,
+    GET_IGC                   = 0x2000,
+    GET_SINGLE_BUFFER_MODE    = 0x4000,
+    GET_S3D_COMP              = 0x8000,
 };
 
 struct private_handle_t;
diff --git a/libqdmetadata/qd_utils.cpp b/libqdmetadata/qd_utils.cpp
index 108514b..e1afd7c 100644
--- a/libqdmetadata/qd_utils.cpp
+++ b/libqdmetadata/qd_utils.cpp
@@ -34,6 +34,24 @@
 static const int kFBNodeMax = 4;
 namespace qdutils {
 
+static int parseLine(char *input, char *tokens[], const uint32_t maxToken, uint32_t *count) {
+    char *tmpToken = NULL;
+    char *tmpPtr;
+    uint32_t index = 0;
+    const char *delim = ", =\n";
+    if (!input) {
+      return -1;
+    }
+    tmpToken = strtok_r(input, delim, &tmpPtr);
+    while (tmpToken && index < maxToken) {
+      tokens[index++] = tmpToken;
+      tmpToken = strtok_r(NULL, delim, &tmpPtr);
+    }
+    *count = index;
+
+    return 0;
+}
+
 static int getExternalNode(const char *type) {
     FILE *displayDeviceFP = NULL;
     char fbType[MAX_FRAME_BUFFER_NAME_SIZE];
@@ -66,6 +84,92 @@
     return -1;
 }
 
+static int querySDEInfoDRM(HWQueryType type, int *value) {
+    char property[PROPERTY_VALUE_MAX] = {0};
+
+    // TODO(user): If future targets don't support WB UBWC, add separate
+    // properties in target specific system.prop and have clients like WFD
+    // directly rely on those.
+    switch(type) {
+    case HAS_UBWC:
+    case HAS_WB_UBWC:  // WFD stack still uses this
+        *value = 1;
+        property_get(DISABLE_UBWC_PROP, property, "0");
+        if(!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
+                !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
+            *value = 0;
+        }
+        break;
+    default:
+        ALOGE("Invalid query type %d", type);
+        return -EINVAL;
+    }
+
+    return 0;
+}
+
+static int querySDEInfoFB(HWQueryType type, int *value) {
+    FILE *fileptr = NULL;
+    const char *featureName;
+    char stringBuffer[MAX_STRING_LENGTH];
+    uint32_t tokenCount = 0;
+    const uint32_t maxCount = 10;
+    char *tokens[maxCount] = { NULL };
+
+    switch(type) {
+    case HAS_UBWC:
+        featureName = "ubwc";
+        break;
+    case HAS_WB_UBWC:
+        featureName = "wb_ubwc";
+        break;
+    default:
+        ALOGE("Invalid query type %d", type);
+        return -EINVAL;
+    }
+
+    fileptr = fopen("/sys/devices/virtual/graphics/fb0/mdp/caps", "rb");
+    if (!fileptr) {
+        ALOGE("File '%s' not found", stringBuffer);
+        return -EINVAL;
+    }
+
+    size_t len = MAX_STRING_LENGTH;
+    ssize_t read;
+    char *line = stringBuffer;
+    while ((read = getline(&line, &len, fileptr)) != -1) {
+        // parse the line and update information accordingly
+        if (parseLine(line, tokens, maxCount, &tokenCount)) {
+            continue;
+        }
+
+        if (strncmp(tokens[0], "features", strlen("features"))) {
+            continue;
+        }
+
+        for (uint32_t i = 0; i < tokenCount; i++) {
+            if (!strncmp(tokens[i], featureName, strlen(featureName))) {
+              *value = 1;
+            }
+        }
+    }
+    fclose(fileptr);
+
+    return 0;
+}
+
+int querySDEInfo(HWQueryType type, int *value) {
+    if (!value) {
+        return -EINVAL;
+    }
+
+    if (getDriverType() ==  DriverType::DRM) {
+        return querySDEInfoDRM(type, value);
+    }
+
+    return querySDEInfoFB(type, value);
+}
+
 int getHDMINode(void) {
     return getExternalNode("dtv panel");
 }
@@ -97,4 +201,165 @@
     return size;
 }
 
+bool isDPConnected() {
+    char connectPath[MAX_FRAME_BUFFER_NAME_SIZE];
+    FILE *connectFile = NULL;
+    size_t len = MAX_STRING_LENGTH;
+    char stringBuffer[MAX_STRING_LENGTH];
+    char *line = stringBuffer;
+
+    int nodeId = getExternalNode("dp panel");
+    if (nodeId < 0) {
+        ALOGE("%s no DP node found", __func__);
+        return false;
+    }
+
+    snprintf(connectPath, sizeof(connectPath),
+             "/sys/devices/virtual/graphics/fb%d/connected", nodeId);
+
+    connectFile = fopen(connectPath, "rb");
+    if (!connectFile) {
+        ALOGW("Failed to open connect node for device node %s", connectPath);
+        return false;
+    }
+
+    if (getline(&line, &len, connectFile) < 0) {
+        fclose(connectFile);
+        return false;
+    }
+
+    fclose(connectFile);
+
+    return atoi(line);
+}
+
+int getDPTestConfig(uint32_t *panelBpp, uint32_t *patternType) {
+    if (!panelBpp || !patternType) {
+        return -1;
+    }
+
+    char configPath[MAX_FRAME_BUFFER_NAME_SIZE];
+    FILE *configFile = NULL;
+    uint32_t tokenCount = 0;
+    const uint32_t maxCount = 10;
+    char *tokens[maxCount] = { NULL };
+    size_t len = MAX_STRING_LENGTH;
+    char stringBuffer[MAX_STRING_LENGTH];
+    char *line = stringBuffer;
+
+    int nodeId = getExternalNode("dp panel");
+    if (nodeId < 0) {
+        ALOGE("%s no DP node found", __func__);
+        return -EINVAL;
+    }
+
+    snprintf(configPath, sizeof(configPath),
+             "/sys/devices/virtual/graphics/fb%d/config", nodeId);
+
+    configFile = fopen(configPath, "rb");
+    if (!configFile) {
+        ALOGW("Failed to open config node for device node %s", configPath);
+        return -EINVAL;
+    }
+
+    while (getline(&line, &len, configFile) != -1) {
+        if (!parseLine(line, tokens, maxCount, &tokenCount)) {
+            if (tokens[0] != NULL) {
+              if (!strncmp(tokens[0], "bpp", strlen("bpp"))) {
+                *panelBpp = static_cast<uint32_t>(atoi(tokens[1]));
+              } else  if (!strncmp(tokens[0], "pattern", strlen("pattern"))) {
+                *patternType = static_cast<uint32_t>(atoi(tokens[1]));
+              }
+            }
+        }
+    }
+
+    fclose(configFile);
+
+    return 0;
+}
+
+DriverType getDriverType() {
+    const char *fb_caps = "/sys/devices/virtual/graphics/fb0/mdp/caps";
+    // 0 - File exists
+    return access(fb_caps, F_OK) ? DriverType::DRM : DriverType::FB;
+}
+
+const char *GetHALPixelFormatString(int format) {
+  switch (format) {
+  case HAL_PIXEL_FORMAT_RGBA_8888:
+    return "RGBA_8888";
+  case HAL_PIXEL_FORMAT_RGBX_8888:
+    return "RGBX_8888";
+  case HAL_PIXEL_FORMAT_RGB_888:
+    return "RGB_888";
+  case HAL_PIXEL_FORMAT_RGB_565:
+    return "RGB_565";
+  case HAL_PIXEL_FORMAT_BGR_565:
+    return "BGR_565";
+  case HAL_PIXEL_FORMAT_BGRA_8888:
+    return "BGRA_8888";
+  case HAL_PIXEL_FORMAT_RGBA_5551:
+    return "RGBA_5551";
+  case HAL_PIXEL_FORMAT_RGBA_4444:
+    return "RGBA_4444";
+  case HAL_PIXEL_FORMAT_YV12:
+    return "YV12";
+  case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+    return "YCbCr_422_SP_NV16";
+  case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+    return "YCrCb_420_SP_NV21";
+  case HAL_PIXEL_FORMAT_YCbCr_422_I:
+    return "YCbCr_422_I_YUY2";
+  case HAL_PIXEL_FORMAT_YCrCb_422_I:
+    return "YCrCb_422_I_YVYU";
+  case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
+    return "NV12_ENCODEABLE";
+  case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
+    return "YCbCr_420_SP_TILED_TILE_4x2";
+  case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+    return "YCbCr_420_SP";
+  case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+    return "YCrCb_420_SP_ADRENO";
+  case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+    return "YCrCb_422_SP";
+  case HAL_PIXEL_FORMAT_R_8:
+    return "R_8";
+  case HAL_PIXEL_FORMAT_RG_88:
+    return "RG_88";
+  case HAL_PIXEL_FORMAT_INTERLACE:
+    return "INTERLACE";
+  case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+    return "YCbCr_420_SP_VENUS";
+  case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+    return "YCrCb_420_SP_VENUS";
+  case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
+    return "YCbCr_420_SP_VENUS_UBWC";
+  case HAL_PIXEL_FORMAT_RGBA_1010102:
+    return "RGBA_1010102";
+  case HAL_PIXEL_FORMAT_ARGB_2101010:
+    return "ARGB_2101010";
+  case HAL_PIXEL_FORMAT_RGBX_1010102:
+    return "RGBX_1010102";
+  case HAL_PIXEL_FORMAT_XRGB_2101010:
+    return "XRGB_2101010";
+  case HAL_PIXEL_FORMAT_BGRA_1010102:
+    return "BGRA_1010102";
+  case HAL_PIXEL_FORMAT_ABGR_2101010:
+    return "ABGR_2101010";
+  case HAL_PIXEL_FORMAT_BGRX_1010102:
+    return "BGRX_1010102";
+  case HAL_PIXEL_FORMAT_XBGR_2101010:
+    return "XBGR_2101010";
+  case HAL_PIXEL_FORMAT_YCbCr_420_P010:
+    return "YCbCr_420_P010";
+  case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
+    return "YCbCr_420_TP10_UBWC";
+  case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
+    return "YCbCr_420_P010_VENUS";
+  default:
+    return "Unknown_format";
+  }
+}
+
 }; //namespace qdutils