diff --git a/config/msmnile.mk b/config/msmnile.mk
index 896a1a8..6e4339d 100644
--- a/config/msmnile.mk
+++ b/config/msmnile.mk
@@ -43,4 +43,5 @@
     vendor.display.enable_null_display=0 \
     vendor.display.disable_excl_rect=0 \
     vendor.display.comp_mask=0 \
-    vendor.display.disable_hw_recovery=1
+    vendor.display.disable_hw_recovery=1 \
+    vendor.display.enable_default_color_mode=1
diff --git a/gralloc/QtiMapper.cpp b/gralloc/QtiMapper.cpp
index 490cf94..3848878 100644
--- a/gralloc/QtiMapper.cpp
+++ b/gralloc/QtiMapper.cpp
@@ -334,6 +334,18 @@
   return Void();
 }
 
+Return<void> QtiMapper::getCustomFormatFlags(int32_t format, uint64_t usage,
+                                             getCustomFormatFlags_cb hidl_cb) {
+  uint64_t priv_flags = 0;
+  auto err = Error::NONE;
+  int32_t custom_format = format;
+  if (gralloc::GetCustomFormatFlags(format, usage, &custom_format, &priv_flags) != 0) {
+    err = Error::UNSUPPORTED;
+  }
+  hidl_cb(err, custom_format, priv_flags);
+  return Void();
+}
+
 Return<void> QtiMapper::getColorSpace(void *buffer, getColorSpace_cb hidl_cb) {
   auto err = Error::BAD_BUFFER;
   auto hnd = static_cast<private_handle_t *>(buffer);
diff --git a/gralloc/QtiMapper.h b/gralloc/QtiMapper.h
index e39ce8b..a7d0c5c 100644
--- a/gralloc/QtiMapper.h
+++ b/gralloc/QtiMapper.h
@@ -94,6 +94,8 @@
   Return<void> calculateBufferAttributes(int32_t width, int32_t height, int32_t format,
                                          uint64_t usage,
                                          calculateBufferAttributes_cb _hidl_cb) override;
+  Return<void> getCustomFormatFlags(int32_t format, uint64_t usage,
+                                    getCustomFormatFlags_cb _hidl_cb) override;
   Return<void> getColorSpace(void *buffer, getColorSpace_cb _hidl_cb) override;
   Return<void> getYuvPlaneInfo(void *buffer, getYuvPlaneInfo_cb _hidl_cb) override;
   Return<Error> setSingleBufferMode(void *buffer, bool enable) override;
diff --git a/gralloc/gr_adreno_info.cpp b/gralloc/gr_adreno_info.cpp
index 1288d92..73f9ce0 100644
--- a/gralloc/gr_adreno_info.cpp
+++ b/gralloc/gr_adreno_info.cpp
@@ -267,4 +267,11 @@
           LINK_adreno_get_aligned_gpu_buffer_size);
 }
 
+bool AdrenoMemInfo::IsPISupportedByGPU(int format, uint64_t usage) {
+  if (LINK_adreno_isPISupportedByGpu) {
+    return LINK_adreno_isPISupportedByGpu(format, usage);
+  }
+  return false;
+}
+
 }  // namespace gralloc
diff --git a/gralloc/gr_adreno_info.h b/gralloc/gr_adreno_info.h
index eec7da4..07c4059 100644
--- a/gralloc/gr_adreno_info.h
+++ b/gralloc/gr_adreno_info.h
@@ -127,6 +127,10 @@
   bool IsUBWCSupportedByGPU(int format);
 
   /*
+  * Function to check if GPU supports PI or not
+  */
+  bool IsPISupportedByGPU(int format, uint64_t usage);
+  /*
    * Function to get the corresponding Adreno format for given HAL format
    */
   ADRENOPIXELFORMAT GetGpuPixelFormat(int hal_format);
@@ -185,6 +189,7 @@
        ADRENOPIXELFORMAT format, int num_samples, surface_tile_mode_t tile_mode,
        uint64_t usage, uint32_t num_planes) = NULL;
   uint32_t (*LINK_adreno_get_aligned_gpu_buffer_size)(void* metadata_blob) = NULL;
+  int (*LINK_adreno_isPISupportedByGpu)(int format, uint64_t usage) = NULL;
 
   bool gfx_ubwc_disable_ = false;
   void *libadreno_utils_ = NULL;
diff --git a/gralloc/gr_allocator.cpp b/gralloc/gr_allocator.cpp
index e5ec78c..56b60bd 100644
--- a/gralloc/gr_allocator.cpp
+++ b/gralloc/gr_allocator.cpp
@@ -184,88 +184,6 @@
   return true;
 }
 
-int Allocator::GetImplDefinedFormat(uint64_t usage, int format) {
-  int gr_format = format;
-
-  // If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
-  // the usage bits, gralloc assigns a format.
-  if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
-      format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-    if (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
-      // Use of 10BIT_TP and 10BIT bits is supposed to be mutually exclusive.
-      // Each bit maps to only one format. Here we will check one of the bits
-      // and ignore the other.
-      if (usage & GRALLOC_USAGE_PRIVATE_10BIT_TP) {
-        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
-      } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
-        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
-      } else {
-        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
-      }
-    } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
-      gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS;
-    } else if (usage & BufferUsage::VIDEO_ENCODER) {
-      if (usage & GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER) {
-        gr_format = HAL_PIXEL_FORMAT_NV21_ENCODEABLE;  // NV21
-      } else {
-        gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE;  // NV12
-      }
-    } else if (usage & BufferUsage::CAMERA_INPUT) {
-      if (usage & BufferUsage::CAMERA_OUTPUT) {
-        // Assumed ZSL if both producer and consumer camera flags set
-        gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
-      } else {
-        gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;  // NV21
-      }
-    } else if (usage & BufferUsage::CAMERA_OUTPUT) {
-      if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-        gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
-      } else {
-        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;  // NV12 preview
-      }
-    } else if (usage & BufferUsage::COMPOSER_OVERLAY) {
-      // XXX: If we still haven't set a format, default to RGBA8888
-      gr_format = HAL_PIXEL_FORMAT_RGBA_8888;
-    } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-      // If no other usage flags are detected, default the
-      // flexible YUV format to NV21_ZSL
-      gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;
-    }
-  }
-
-  return gr_format;
-}
-
-/* The default policy is to return cached buffers unless the client explicity
- * sets the PRIVATE_UNCACHED flag or indicates that the buffer will be rarely
- * read or written in software. */
-bool Allocator::UseUncached(int format, uint64_t usage) {
-  if ((usage & GRALLOC_USAGE_PRIVATE_UNCACHED) || (usage & BufferUsage::PROTECTED)) {
-    return true;
-  }
-
-  // CPU read rarely
-  if ((usage & BufferUsage::CPU_READ_MASK) == static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY)) {
-    return true;
-  }
-
-  // CPU  write rarely
-  if ((usage & BufferUsage::CPU_WRITE_MASK) ==
-      static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY)) {
-    return true;
-  }
-
-  if ((usage & BufferUsage::SENSOR_DIRECT_DATA) || (usage & BufferUsage::GPU_DATA_BUFFER)) {
-    return true;
-  }
-
-  if (format && IsUBwcEnabled(format, usage)) {
-    return true;
-  }
-
-  return false;
-}
-
 void Allocator::GetIonHeapInfo(uint64_t usage, unsigned int *ion_heap_id, unsigned int *alloc_type,
                                unsigned int *ion_flags) {
   unsigned int heap_id = 0;
diff --git a/gralloc/gr_allocator.h b/gralloc/gr_allocator.h
index 17fb0cb..36732c6 100644
--- a/gralloc/gr_allocator.h
+++ b/gralloc/gr_allocator.h
@@ -53,9 +53,6 @@
   bool CheckForBufferSharing(uint32_t num_descriptors,
                              const std::vector<std::shared_ptr<BufferDescriptor>> &descriptors,
                              ssize_t *max_index);
-  int GetImplDefinedFormat(uint64_t usage, int format);
-  bool UseUncached(int format, uint64_t usage);
-
  private:
   void GetIonHeapInfo(uint64_t usage, unsigned int *ion_heap_id, unsigned int *alloc_type,
                       unsigned int *ion_flags);
diff --git a/gralloc/gr_buf_mgr.cpp b/gralloc/gr_buf_mgr.cpp
index 12fd13f..7aa4b05 100644
--- a/gralloc/gr_buf_mgr.cpp
+++ b/gralloc/gr_buf_mgr.cpp
@@ -85,7 +85,7 @@
 
 Error BufferManager::ValidateBufferSize(private_handle_t const *hnd, BufferInfo info) {
   unsigned int size, alignedw, alignedh;
-  info.format = allocator_->GetImplDefinedFormat(info.usage, info.format);
+  info.format = GetImplDefinedFormat(info.usage, info.format);
   GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
   auto ion_fd_size = static_cast<unsigned int>(lseek(hnd->fd, 0, SEEK_END));
   if (size != ion_fd_size) {
@@ -254,52 +254,6 @@
   return status;
 }
 
-int BufferManager::GetHandleFlags(int format, uint64_t usage) {
-  int flags = 0;
-  if (usage & BufferUsage::VIDEO_ENCODER) {
-    flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
-  }
-
-  if (usage & BufferUsage::CAMERA_OUTPUT) {
-    flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
-  }
-
-  if (usage & BufferUsage::CAMERA_INPUT) {
-    flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
-  }
-
-  if (usage & BufferUsage::COMPOSER_OVERLAY) {
-    flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
-  }
-
-  if (usage & BufferUsage::GPU_TEXTURE) {
-    flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
-  }
-
-  if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
-    flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
-  }
-
-  if (IsUBwcEnabled(format, usage)) {
-    flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-  }
-
-  if (usage & (BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)) {
-    flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
-  }
-
-  if ((usage & (BufferUsage::VIDEO_ENCODER | BufferUsage::VIDEO_DECODER |
-                BufferUsage::CAMERA_OUTPUT | BufferUsage::GPU_RENDER_TARGET))) {
-    flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
-  }
-
-  if (!allocator_->UseUncached(format, usage)) {
-    flags |= private_handle_t::PRIV_FLAGS_CACHED;
-  }
-
-  return flags;
-}
-
 int BufferManager::GetBufferType(int inputFormat) {
   int buffer_type = BUFFER_TYPE_UI;
   if (IsYuvFormat(inputFormat)) {
@@ -317,7 +271,7 @@
   std::lock_guard<std::mutex> buffer_lock(buffer_lock_);
 
   uint64_t usage = descriptor.GetUsage();
-  int format = allocator_->GetImplDefinedFormat(usage, descriptor.GetFormat());
+  int format = GetImplDefinedFormat(usage, descriptor.GetFormat());
   uint32_t layer_count = descriptor.GetLayerCount();
 
   unsigned int size;
@@ -340,13 +294,13 @@
 
   size = (bufferSize >= size) ? bufferSize : size;
   int err = 0;
-  int flags = 0;
+  uint64_t flags = 0;
   auto page_size = UINT(getpagesize());
   AllocData data;
   data.align = GetDataAlignment(format, usage);
   data.size = size;
   data.handle = (uintptr_t)handle;
-  data.uncached = allocator_->UseUncached(format, usage);
+  data.uncached = UseUncached(format, usage);
 
   // Allocate buffer memory
   err = allocator_->AllocateMem(&data, usage, format);
@@ -372,7 +326,7 @@
 
   // Create handle
   private_handle_t *hnd = new private_handle_t(
-      data.fd, e_data.fd, flags, INT(alignedw), INT(alignedh), descriptor.GetWidth(),
+      data.fd, e_data.fd, INT(flags), INT(alignedw), INT(alignedh), descriptor.GetWidth(),
       descriptor.GetHeight(), format, buffer_type, data.size, usage);
 
   hnd->id = ++next_id_;
diff --git a/gralloc/gr_buf_mgr.h b/gralloc/gr_buf_mgr.h
index 9fcca1b..ca0c1b3 100644
--- a/gralloc/gr_buf_mgr.h
+++ b/gralloc/gr_buf_mgr.h
@@ -54,7 +54,6 @@
   BufferManager();
   Error MapBuffer(private_handle_t const *hnd);
   int GetBufferType(int format);
-  int GetHandleFlags(int format, uint64_t usage);
 
   // Imports the ion fds into the current process. Returns an error for invalid handles
   Error ImportHandleLocked(private_handle_t *hnd);
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/gr_utils.cpp b/gralloc/gr_utils.cpp
index a49f1ea..282bcc2 100644
--- a/gralloc/gr_utils.cpp
+++ b/gralloc/gr_utils.cpp
@@ -543,6 +543,28 @@
   return false;
 }
 
+bool IsUBwcPISupported(int format, uint64_t usage) {
+  if (usage & BufferUsage::COMPOSER_OVERLAY || !(usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI)) {
+    return false;
+  }
+
+  // As of now only two formats
+  switch (format) {
+    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
+    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC: {
+      if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
+        if (AdrenoMemInfo::GetInstance()) {
+          return AdrenoMemInfo::GetInstance()->IsPISupportedByGPU(format, usage);
+        }
+      } else {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 bool IsUBwcEnabled(int format, uint64_t usage) {
   // Allow UBWC, if client is using an explicitly defined UBWC pixel format.
   if (IsUBwcFormat(format)) {
@@ -552,7 +574,8 @@
   // Allow UBWC, if an OpenGL client sets UBWC usage flag and GPU plus MDP
   // support the format. OR if a non-OpenGL client like Rotator, sets UBWC
   // usage flag and MDP supports the format.
-  if ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) && IsUBwcSupported(format)) {
+  if (((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) || (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI))
+        && IsUBwcSupported(format)) {
     bool enable = true;
     // Query GPU for UBWC only if buffer is intended to be used by GPU.
     if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
@@ -983,4 +1006,142 @@
   return false;
 }
 
+bool UseUncached(int format, uint64_t usage) {
+  if ((usage & GRALLOC_USAGE_PRIVATE_UNCACHED) || (usage & BufferUsage::PROTECTED)) {
+    return true;
+  }
+
+  // CPU read rarely
+  if ((usage & BufferUsage::CPU_READ_MASK) == static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY)) {
+    return true;
+  }
+
+  // CPU  write rarely
+  if ((usage & BufferUsage::CPU_WRITE_MASK) ==
+      static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY)) {
+    return true;
+  }
+
+  if ((usage & BufferUsage::SENSOR_DIRECT_DATA) || (usage & BufferUsage::GPU_DATA_BUFFER)) {
+    return true;
+  }
+
+  if (format && IsUBwcEnabled(format, usage)) {
+    return true;
+  }
+
+  return false;
+}
+
+uint64_t GetHandleFlags(int format, uint64_t usage) {
+  uint64_t priv_flags = 0;
+
+  if (usage & BufferUsage::VIDEO_ENCODER) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
+  }
+
+  if (usage & BufferUsage::CAMERA_OUTPUT) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
+  }
+
+  if (usage & BufferUsage::CAMERA_INPUT) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
+  }
+
+  if (usage & BufferUsage::COMPOSER_OVERLAY) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
+  }
+
+  if (usage & BufferUsage::GPU_TEXTURE) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
+  }
+
+  if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
+  }
+
+  if (IsUBwcEnabled(format, usage)) {
+    if (IsUBwcPISupported(format, usage)) {
+      priv_flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED_PI;
+    } else {
+      priv_flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
+    }
+  }
+
+  if (usage & (BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
+  }
+
+  if ((usage & (BufferUsage::VIDEO_ENCODER | BufferUsage::VIDEO_DECODER |
+                BufferUsage::CAMERA_OUTPUT | BufferUsage::GPU_RENDER_TARGET))) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
+  }
+
+  if (!UseUncached(format, usage)) {
+    priv_flags |= private_handle_t::PRIV_FLAGS_CACHED;
+  }
+
+  return priv_flags;
+}
+
+int GetImplDefinedFormat(uint64_t usage, int format) {
+  int gr_format = format;
+
+  // If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
+  // the usage bits, gralloc assigns a format.
+  if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
+      format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
+    if (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC || usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI) {
+      // Use of 10BIT_TP and 10BIT bits is supposed to be mutually exclusive.
+      // Each bit maps to only one format. Here we will check one of the bits
+      // and ignore the other.
+      if (usage & GRALLOC_USAGE_PRIVATE_10BIT_TP) {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
+      } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
+      } else {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
+      }
+    } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
+      gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS;
+    } else if (usage & BufferUsage::VIDEO_ENCODER) {
+      if (usage & GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER) {
+        gr_format = HAL_PIXEL_FORMAT_NV21_ENCODEABLE;  // NV21
+      } else {
+        gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE;  // NV12
+      }
+    } else if (usage & BufferUsage::CAMERA_INPUT) {
+      if (usage & BufferUsage::CAMERA_OUTPUT) {
+        // Assumed ZSL if both producer and consumer camera flags set
+        gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
+      } else {
+        gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;  // NV21
+      }
+    } else if (usage & BufferUsage::CAMERA_OUTPUT) {
+      if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
+        gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
+      } else {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;  // NV12 preview
+      }
+    } else if (usage & BufferUsage::COMPOSER_OVERLAY) {
+      // XXX: If we still haven't set a format, default to RGBA8888
+      gr_format = HAL_PIXEL_FORMAT_RGBA_8888;
+    } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
+      // If no other usage flags are detected, default the
+      // flexible YUV format to NV21_ZSL
+      gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;
+    }
+  }
+
+  return gr_format;
+}
+
+int GetCustomFormatFlags(int format, uint64_t usage,
+                        int *custom_format, uint64_t *priv_flags) {
+  *custom_format = GetImplDefinedFormat(usage, format);
+  *priv_flags = GetHandleFlags(*custom_format, usage);
+
+  return 0;
+}
+
 }  // namespace gralloc
diff --git a/gralloc/gr_utils.h b/gralloc/gr_utils.h
index fa62871..68f826f 100644
--- a/gralloc/gr_utils.h
+++ b/gralloc/gr_utils.h
@@ -86,6 +86,7 @@
 int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data);
 bool IsUBwcFormat(int format);
 bool IsUBwcSupported(int format);
+bool IsUBwcPISupported(int format, uint64_t usage);
 bool IsUBwcEnabled(int format, uint64_t usage);
 void GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
                               unsigned int *aligned_h);
@@ -102,11 +103,14 @@
 int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4],
                     uint32_t *num_planes);
 uint32_t GetDataAlignment(int format, uint64_t usage);
-
 void GetGpuResourceSizeAndDimensions(const BufferInfo &info, unsigned int *size,
                                      unsigned int *alignedw, unsigned int *alignedh,
                                      GraphicsMetadata *graphics_metadata);
 bool GetAdrenoSizeAPIStatus();
+bool UseUncached(int format, uint64_t usage);
+uint64_t GetHandleFlags(int format, uint64_t usage);
+int GetImplDefinedFormat(uint64_t usage, int format);
+int GetCustomFormatFlags(int format, uint64_t usage, int *custom_format, uint64_t *priv_flags);
 }  // namespace gralloc
 
 #endif  // __GR_UTILS_H__
diff --git a/gralloc/gralloc_priv.h b/gralloc/gralloc_priv.h
index f184787..8f8c0c4 100644
--- a/gralloc/gralloc_priv.h
+++ b/gralloc/gralloc_priv.h
@@ -69,6 +69,8 @@
 /* This flag is used to indicate 10-bit tight pack format (e.g. TP10) */
 #define GRALLOC_USAGE_PRIVATE_10BIT_TP (UINT32_C(1) << 27)
 
+/* 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 */
 #define GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP GRALLOC_USAGE_PRIVATE_ADSP_HEAP
diff --git a/include/display_properties.h b/include/display_properties.h
index 96dc686..a07bca8 100644
--- a/include/display_properties.h
+++ b/include/display_properties.h
@@ -96,11 +96,13 @@
 
 #define DISABLE_HDR_LUT_GEN                  DISPLAY_PROP("disable_hdr_lut_gen")
 #define ENABLE_DEFAULT_COLOR_MODE            DISPLAY_PROP("enable_default_color_mode")
-#define DISABLE_HDR                          DISPLAY_PROP("disable_hdr")
+#define DISABLE_HDR                          DISPLAY_PROP("hwc_disable_hdr")
 
 #define HDR_CONFIG_PROP                      RO_DISPLAY_PROP("hdr.config")
 #define QDCM_PCC_TRANS_PROP                  DISPLAY_PROP("qdcm.pcc_for_trans")
 #define QDCM_DIAGONAL_MATRIXMODE_PROP        DISPLAY_PROP("qdcm.diagonal_matrix_mode")
 #define QDCM_DISABLE_TIMEOUT_PROP            PERSIST_DISPLAY_PROP("qdcm.disable_timeout")
 
+#define ZERO_SWAP_INTERVAL                   "vendor.debug.egl.swapinterval"
+
 #endif  // __DISPLAY_PROPERTIES_H__
diff --git a/sdm/libs/core/drm/hw_device_drm.cpp b/sdm/libs/core/drm/hw_device_drm.cpp
index 7e48371..9d2fc6a 100644
--- a/sdm/libs/core/drm/hw_device_drm.cpp
+++ b/sdm/libs/core/drm/hw_device_drm.cpp
@@ -1585,22 +1585,25 @@
 }
 
 DisplayError HWDeviceDRM::DumpDebugData() {
-#if USER_DEBUG
+  string dir_path = "/data/vendor/display/hw_recovery/";
   string device_str = device_name_;
-  stringstream date_str;
-  stringstream time_str;
-  time_t t = time(0);
-  struct tm t_now;
-  localtime_r(&t, &t_now);
-  date_str << (t_now.tm_mon + 1) << '-'
-          << (t_now.tm_mday) << '-'
-          << (t_now.tm_year + 1900) << '_';
-  time_str << (t_now.tm_hour) << '-'
-          << (t_now.tm_min) << '-'
-          << (t_now.tm_sec) << ".log";
 
-  ofstream dst("data/vendor/display/"+device_str+"_"+date_str.str()+time_str.str());
+  // Attempt to make hw_recovery dir, it may exist
+  if (mkdir(dir_path.c_str(), 0777) != 0 && errno != EEXIST) {
+    DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path.c_str(), errno,
+          strerror(errno));
+    return kErrorPermission;
+  }
+  // If it does exist, ensure permissions are fine
+  if (errno == EEXIST && chmod(dir_path.c_str(), 0777) != 0) {
+    DLOGW("Failed to change permissions on %s directory", dir_path.c_str());
+    return kErrorPermission;
+  }
+
+  string filename = dir_path+device_str+"_HWR_"+to_string(debug_dump_count_);
+  ofstream dst(filename);
   ifstream src;
+  debug_dump_count_++;
 
   src.open("/sys/kernel/debug/dri/0/debug/dump");
   dst << "---- Event Logs ----" << std::endl;
@@ -1623,7 +1626,8 @@
   src.close();
 
   dst.close();
-#endif
+
+  DLOGI("Wrote hw_recovery file %s", filename.c_str());
 
   return kErrorNone;
 }
diff --git a/sdm/libs/core/drm/hw_device_drm.h b/sdm/libs/core/drm/hw_device_drm.h
index 8141210..5139c66 100644
--- a/sdm/libs/core/drm/hw_device_drm.h
+++ b/sdm/libs/core/drm/hw_device_drm.h
@@ -202,6 +202,7 @@
   HWMixerAttributes mixer_attributes_ = {};
   std::vector<sde_drm::DRMSolidfillStage> solid_fills_ {};
   bool secure_display_active_ = false;
+  uint64_t debug_dump_count_ = 0;
 
  private:
   bool synchronous_commit_ = false;
diff --git a/sdm/libs/core/drm/hw_peripheral_drm.cpp b/sdm/libs/core/drm/hw_peripheral_drm.cpp
index 6420c13..340dc05 100644
--- a/sdm/libs/core/drm/hw_peripheral_drm.cpp
+++ b/sdm/libs/core/drm/hw_peripheral_drm.cpp
@@ -94,7 +94,7 @@
 }
 
 void HWPeripheralDRM::SetDestScalarData(HWLayersInfo hw_layer_info) {
-  if (!hw_resource_.hw_dest_scalar_info.count) {
+  if (!hw_scale_ || !hw_resource_.hw_dest_scalar_info.count) {
     return;
   }
 
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index 8f45c6d..deba46b 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -375,7 +375,7 @@
   }
 
   int property_swap_interval = 1;
-  HWCDebugHandler::Get()->GetProperty("debug.egl.swapinterval", &property_swap_interval);
+  HWCDebugHandler::Get()->GetProperty(ZERO_SWAP_INTERVAL, &property_swap_interval);
   if (property_swap_interval == 0) {
     swap_interval_zero_ = true;
   }
@@ -763,6 +763,7 @@
                                                int32_t dataspace) {
   ColorMetaData color_metadata = {};
   if (dataspace != HAL_DATASPACE_UNKNOWN) {
+    dataspace = TranslateFromLegacyDataspace(dataspace);
     GetColorPrimary(dataspace, &(color_metadata.colorPrimaries));
     GetTransfer(dataspace, &(color_metadata.transfer));
     GetRange(dataspace, &(color_metadata.range));
@@ -936,7 +937,8 @@
     client_target_->SetLayerDataspace(dataspace);
     Layer *sdm_layer = client_target_->GetSDMLayer();
     // Data space would be validated at GetClientTargetSupport, so just use here.
-    sdm::GetSDMColorSpace(dataspace, &sdm_layer->input_buffer.color_metadata);
+    sdm::GetSDMColorSpace(client_target_->GetLayerDataspace(),
+                          &sdm_layer->input_buffer.color_metadata);
   }
 
   return HWC2::Error::None;
@@ -1848,6 +1850,10 @@
 }
 
 int HWCDisplay::GetActiveDisplayConfig(uint32_t *config) {
+  if (config_pending_) {
+    *config = display_config_;
+    return 0;
+  }
   return display_intf_->GetActiveConfig(config) == kErrorNone ? 0 : -1;
 }
 
diff --git a/sdm/libs/hwc2/hwc_layers.cpp b/sdm/libs/hwc2/hwc_layers.cpp
index 6a1c82c..322259a 100644
--- a/sdm/libs/hwc2/hwc_layers.cpp
+++ b/sdm/libs/hwc2/hwc_layers.cpp
@@ -86,7 +86,7 @@
       *color_primary = ColorPrimaries_BT2020;
       break;
     default:
-      DLOGV_IF(kTagClient, "Unsupported Standard Request = %d", standard);
+      DLOGW_IF(kTagClient, "Unsupported Standard Request = %d", standard);
       supported_csc = false;
   }
   return supported_csc;
@@ -118,7 +118,7 @@
       *gamma_transfer = Transfer_Gamma2_8;
       break;
     default:
-      DLOGV_IF(kTagClient, "Unsupported Transfer Request = %d", transfer);
+      DLOGW_IF(kTagClient, "Unsupported Transfer Request = %d", transfer);
       supported_transfer = false;
   }
   return supported_transfer;
@@ -137,7 +137,7 @@
       *color_range = Range_Extended;
       break;
     default:
-      DLOGV_IF(kTagClient, "Unsupported Range Request = %d", range);
+      DLOGW_IF(kTagClient, "Unsupported Range Request = %d", range);
       return false;
   }
   return true;
@@ -153,6 +153,38 @@
   }
 }
 
+int32_t TranslateFromLegacyDataspace(const int32_t &legacy_ds) {
+  int32_t dataspace = legacy_ds;
+
+  if (dataspace & 0xffff) {
+    switch (dataspace & 0xffff) {
+      case HAL_DATASPACE_SRGB:
+        dataspace = HAL_DATASPACE_V0_SRGB;
+        break;
+      case HAL_DATASPACE_JFIF:
+        dataspace = HAL_DATASPACE_V0_JFIF;
+        break;
+      case HAL_DATASPACE_SRGB_LINEAR:
+        dataspace = HAL_DATASPACE_V0_SRGB_LINEAR;
+        break;
+      case HAL_DATASPACE_BT601_625:
+        dataspace = HAL_DATASPACE_V0_BT601_625;
+        break;
+      case HAL_DATASPACE_BT601_525:
+        dataspace = HAL_DATASPACE_V0_BT601_525;
+        break;
+      case HAL_DATASPACE_BT709:
+        dataspace = HAL_DATASPACE_V0_BT709;
+        break;
+      default:
+        // unknown legacy dataspace
+        DLOGW_IF(kTagClient, "Unsupported dataspace type %d", dataspace);
+    }
+  }
+
+  return dataspace;
+}
+
 // Retrieve ColorMetaData from android_data_space_t (STANDARD|TRANSFER|RANGE)
 bool GetSDMColorSpace(const int32_t &dataspace, ColorMetaData *color_metadata) {
   bool valid = false;
@@ -355,33 +387,8 @@
 }
 
 HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) {
-  // Map deprecated dataspace values to appropriate
-  // new enums
-  if (dataspace & 0xffff) {
-    switch (dataspace & 0xffff) {
-      case HAL_DATASPACE_SRGB:
-        dataspace = HAL_DATASPACE_V0_SRGB;
-        break;
-      case HAL_DATASPACE_JFIF:
-        dataspace = HAL_DATASPACE_V0_JFIF;
-        break;
-      case HAL_DATASPACE_SRGB_LINEAR:
-        dataspace = HAL_DATASPACE_V0_SRGB_LINEAR;
-        break;
-      case HAL_DATASPACE_BT601_625:
-        dataspace = HAL_DATASPACE_V0_BT601_625;
-        break;
-      case HAL_DATASPACE_BT601_525:
-        dataspace = HAL_DATASPACE_V0_BT601_525;
-        break;
-      case HAL_DATASPACE_BT709:
-        dataspace = HAL_DATASPACE_V0_BT709;
-        break;
-      default:
-        // unknown legacy dataspace
-        DLOGW_IF(kTagClient, "Unsupported dataspace type %d", dataspace);
-    }
-  }
+  // Map deprecated dataspace values to appropriate new enums
+  dataspace = TranslateFromLegacyDataspace(dataspace);
 
   // cache the dataspace, to be used later to update SDM ColorMetaData
   if (dataspace_ != dataspace) {
diff --git a/sdm/libs/hwc2/hwc_layers.h b/sdm/libs/hwc2/hwc_layers.h
index 7d978c8..eec038a 100644
--- a/sdm/libs/hwc2/hwc_layers.h
+++ b/sdm/libs/hwc2/hwc_layers.h
@@ -45,6 +45,8 @@
 bool GetRange(const int32_t &dataspace, ColorRange *color_range);
 bool GetSDMColorSpace(const int32_t &dataspace, ColorMetaData *color_metadata);
 bool IsBT2020(const ColorPrimaries &color_primary);
+int32_t TranslateFromLegacyDataspace(const int32_t &legacy_ds);
+
 enum GeometryChanges {
   kNone         = 0x000,
   kBlendMode    = 0x001,