diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index 8b512bf..a0d7d8d 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -315,6 +315,7 @@
             (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
             useFbMem = true;
         } else {
+            usage &= ~GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
             if (property_get("debug.gralloc.enable_fb_ubwc", isUBWC, NULL) > 0){
                 if ((!strncmp(isUBWC, "1", PROPERTY_VALUE_MAX)) ||
                     (!strncasecmp(isUBWC, "true", PROPERTY_VALUE_MAX))) {
diff --git a/libqdutils/display_config.cpp b/libqdutils/display_config.cpp
index 43887e0..e9b30f3 100644
--- a/libqdutils/display_config.cpp
+++ b/libqdutils/display_config.cpp
@@ -280,26 +280,6 @@
     return err;
 }
 
-int minHdcpEncryptionLevelChanged(int dpy) {
-    status_t err = (status_t) FAILED_TRANSACTION;
-    sp<IQService> binder = getBinder();
-    Parcel inParcel, outParcel;
-    inParcel.writeInt32(dpy);
-
-    if(binder != NULL) {
-        err = binder->dispatch(IQService::MIN_HDCP_ENCRYPTION_LEVEL_CHANGED,
-                &inParcel, &outParcel);
-    }
-
-    if(err) {
-        ALOGE("%s: Failed for dpy %d err=%d", __FUNCTION__, dpy, err);
-    } else {
-        err = outParcel.readInt32();
-    }
-
-    return err;
-}
-
 int setPanelBrightness(int level) {
     status_t err = (status_t) FAILED_TRANSACTION;
     sp<IQService> binder = getBinder();
@@ -338,8 +318,28 @@
 }// namespace
 
 // ----------------------------------------------------------------------------
-// Screen refresh for native daemons linking dynamically to libqdutils
+// Functions for linking dynamically to libqdutils
 // ----------------------------------------------------------------------------
+extern "C" int minHdcpEncryptionLevelChanged(int dpy) {
+    status_t err = (status_t) FAILED_TRANSACTION;
+    sp<IQService> binder = getBinder();
+    Parcel inParcel, outParcel;
+    inParcel.writeInt32(dpy);
+
+    if(binder != NULL) {
+        err = binder->dispatch(IQService::MIN_HDCP_ENCRYPTION_LEVEL_CHANGED,
+                &inParcel, &outParcel);
+    }
+
+    if(err) {
+        ALOGE("%s: Failed for dpy %d err=%d", __FUNCTION__, dpy, err);
+    } else {
+        err = outParcel.readInt32();
+    }
+
+    return err;
+}
+
 extern "C" int refreshScreen() {
     int ret = 0;
     ret = screenRefresh();
diff --git a/libqdutils/display_config.h b/libqdutils/display_config.h
index 101e230..9ba60f2 100644
--- a/libqdutils/display_config.h
+++ b/libqdutils/display_config.h
@@ -141,11 +141,6 @@
 // Set the primary display mode to command or video mode
 int setDisplayMode(int mode);
 
-// Notify change in minimum encryption level for HDCP
-// Return -1 on error.
-// Only HDMI display is supported as dpy for now
-int minHdcpEncryptionLevelChanged(int dpy);
-
 // Sets the panel brightness of the primary display
 int setPanelBrightness(int level);
 
diff --git a/sdm/include/core/debug_interface.h b/sdm/include/core/debug_interface.h
index bd2b5dd..67a38be 100644
--- a/sdm/include/core/debug_interface.h
+++ b/sdm/include/core/debug_interface.h
@@ -118,6 +118,15 @@
   */
   virtual DisplayError GetProperty(const char *property_name, int *value) = 0;
 
+  /*! @brief Method to get property value corresponding to give string.
+
+   @param[in] property_name name of the property
+   @param[out] string value corresponding to the property name
+
+   @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetProperty(const char *property_name, char *value) = 0;
+
  protected:
   virtual ~DebugHandler() { }
 };
diff --git a/sdm/include/utils/debug.h b/sdm/include/utils/debug.h
index c8a3a98..b4a286a 100644
--- a/sdm/include/utils/debug.h
+++ b/sdm/include/utils/debug.h
@@ -72,6 +72,7 @@
   static bool IsRotatorSplitDisabled();
   static bool IsScalarDisabled();
   static bool IsUbwcTiledFrameBuffer();
+  static bool GetProperty(const char *property_name, char *value);
 
  private:
   Debug();
@@ -91,6 +92,9 @@
     virtual DisplayError GetProperty(const char */*property_name*/, int */*value*/) {
       return kErrorNotSupported;
     }
+    virtual DisplayError GetProperty(const char */*property_name*/, char */*value*/) {
+      return kErrorNotSupported;
+    }
   };
 
   DefaultDebugHandler default_debug_handler_;
diff --git a/sdm/libs/core/comp_manager.cpp b/sdm/libs/core/comp_manager.cpp
index de4b326..9e1b277 100644
--- a/sdm/libs/core/comp_manager.cpp
+++ b/sdm/libs/core/comp_manager.cpp
@@ -202,7 +202,11 @@
     constraints->safe_mode = true;
   }
 
-  if (display_comp_ctx->idle_fallback || display_comp_ctx->fallback_) {
+  // Avoid idle fallback, if there is only one app layer.
+  // TODO(user): App layer count will change for hybrid composition
+  uint32_t app_layer_count = hw_layers->info.stack->layer_count - 1;
+  if ((app_layer_count > 1 && display_comp_ctx->idle_fallback) || display_comp_ctx->fallback_) {
+    // Handle the idle timeout by falling back
     constraints->safe_mode = true;
   }
 
@@ -218,13 +222,6 @@
   display_comp_ctx->strategy->Start(&hw_layers->info, &display_comp_ctx->max_strategies,
                                     display_comp_ctx->partial_update_enable);
   display_comp_ctx->remaining_strategies = display_comp_ctx->max_strategies;
-
-  // Avoid idle fallback, if there is only one app layer.
-  // TODO(user): App layer count will change for hybrid composition
-  uint32_t app_layer_count = hw_layers->info.stack->layer_count - 1;
-  if (!display_comp_ctx->idle_fallback && app_layer_count > 1) {
-    display_comp_ctx->handle_idle_timeout = true;
-  }
 }
 
 DisplayError CompManager::Prepare(Handle display_ctx, HWLayers *hw_layers) {
@@ -351,16 +348,7 @@
     return;
   }
 
-  // 1. handle_idle_timeout flag is set to true on start of every draw call, if the current
-  //    composition is not due to idle fallback.
-  // 2. idle_fallback flag will be set only if handle_idle_timeout flag is true and there is no
-  //    update to the screen for specified amount of time.
-  // 3. handle_idle_timeout flag helps us handle the very first idle timeout event and
-  //    ignore the next idle timeout event on consecutive two idle timeout events.
-  if (display_comp_ctx->handle_idle_timeout) {
-    display_comp_ctx->idle_fallback = true;
-    display_comp_ctx->handle_idle_timeout = false;
-  }
+  display_comp_ctx->idle_fallback = true;
 }
 
 void CompManager::ProcessThermalEvent(Handle display_ctx, int64_t thermal_level) {
@@ -448,5 +436,20 @@
   return supported;
 }
 
+bool CompManager::CanSetIdleTimeout(Handle display_ctx) {
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+
+  if (!display_comp_ctx) {
+    return false;
+  }
+
+  if (!display_comp_ctx->idle_fallback) {
+    return true;
+  }
+
+  return false;
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/comp_manager.h b/sdm/libs/core/comp_manager.h
index 8db045a..a6b1432 100644
--- a/sdm/libs/core/comp_manager.h
+++ b/sdm/libs/core/comp_manager.h
@@ -59,6 +59,7 @@
   DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst, bool rotate90);
   DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y);
   bool SupportLayerAsCursor(Handle display_ctx, HWLayers *hw_layers);
+  bool CanSetIdleTimeout(Handle display_ctx);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
@@ -69,21 +70,15 @@
   void PrepareStrategyConstraints(Handle display_ctx, HWLayers *hw_layers);
 
   struct DisplayCompositionContext {
-    Strategy *strategy;
+    Strategy *strategy = NULL;
     StrategyConstraints constraints;
-    Handle display_resource_ctx;
-    DisplayType display_type;
-    uint32_t max_strategies;
-    uint32_t remaining_strategies;
-    bool idle_fallback;
-    bool handle_idle_timeout;
-    bool fallback_;
-    uint32_t partial_update_enable;
-
-    DisplayCompositionContext()
-      : display_resource_ctx(NULL), display_type(kPrimary), max_strategies(0),
-        remaining_strategies(0), idle_fallback(false), handle_idle_timeout(true),
-        fallback_(false), partial_update_enable(true) { }
+    Handle display_resource_ctx = NULL;
+    DisplayType display_type = kPrimary;
+    uint32_t max_strategies = 0;
+    uint32_t remaining_strategies = 0;
+    bool idle_fallback = false;
+    bool fallback_ = false;
+    uint32_t partial_update_enable = true;
   };
 
   Locker locker_;
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
old mode 100755
new mode 100644
index 06bbccb..63fe6b2
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -57,10 +57,7 @@
     return error;
   }
 
-  // Idle fallback feature is supported only for video mode panel.
-  if (hw_panel_info_.mode == kModeVideo) {
-    hw_intf_->SetIdleTimeoutMs(Debug::GetIdleTimeoutMs());
-  }
+  idle_timeout_ms_ = Debug::GetIdleTimeoutMs();
 
   if (hw_panel_info_.mode == kModeCommand && Debug::IsVideoModeEnabled()) {
     error = hw_intf_->SetDisplayMode(kModeVideo);
@@ -94,6 +91,8 @@
   HWDisplayAttributes display_attributes;
   uint32_t active_index = 0;
 
+  bool set_idle_timeout = comp_manager_->CanSetIdleTimeout(display_comp_ctx_);
+
   error = DisplayBase::Commit(layer_stack);
   if (error != kErrorNone) {
     return error;
@@ -108,6 +107,10 @@
     hw_panel_info_ = panel_info;
   }
 
+  if (set_idle_timeout && hw_panel_info_.mode != kModeCommand) {
+    hw_intf_->SetIdleTimeoutMs(idle_timeout_ms_);
+  }
+
   return error;
 }
 
@@ -187,10 +190,12 @@
 
 void DisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
   SCOPE_LOCK(locker_);
+
   // Idle fallback feature is supported only for video mode panel.
   if (hw_panel_info_.mode == kModeVideo) {
     hw_intf_->SetIdleTimeoutMs(timeout_ms);
   }
+  idle_timeout_ms_ = timeout_ms;
 }
 
 DisplayError DisplayPrimary::SetMaxMixerStages(uint32_t max_mixer_stages) {
@@ -241,7 +246,7 @@
   }
 
   if (hw_display_mode == kModeVideo) {
-    hw_intf_->SetIdleTimeoutMs(Debug::GetIdleTimeoutMs());
+    hw_intf_->SetIdleTimeoutMs(idle_timeout_ms_);
   } else if (hw_display_mode == kModeCommand) {
     hw_intf_->SetIdleTimeoutMs(0);
   }
@@ -278,12 +283,15 @@
 DisplayError DisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
   SCOPE_LOCK(locker_);
 
-  if (!hw_panel_info_.dynamic_fps || refresh_rate < hw_panel_info_.min_fps ||
-       refresh_rate > hw_panel_info_.max_fps) {
-    DLOGW("Invalid Request");
+  if (state_ != kStateOn || !hw_panel_info_.dynamic_fps) {
     return kErrorNotSupported;
   }
 
+  if (refresh_rate < hw_panel_info_.min_fps || refresh_rate > hw_panel_info_.max_fps) {
+    DLOGE("Invalid Fps = %d request", refresh_rate);
+    return kErrorParameters;
+  }
+
   DisplayError error = hw_intf_->SetRefreshRate(refresh_rate);
   if (error != kErrorNone) {
     return error;
@@ -332,9 +340,9 @@
 }
 
 void DisplayPrimary::IdleTimeout() {
-  if (event_handler_->Refresh() == kErrorNone) {
-    comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
-  }
+  event_handler_->Refresh();
+  comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
+  hw_intf_->SetIdleTimeoutMs(0);
 }
 
 void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
diff --git a/sdm/libs/core/display_primary.h b/sdm/libs/core/display_primary.h
index 900939d..b0f2934 100644
--- a/sdm/libs/core/display_primary.h
+++ b/sdm/libs/core/display_primary.h
@@ -71,6 +71,7 @@
 
  private:
   Locker locker_;
+  uint32_t idle_timeout_ms_ = 0;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/core/fb/hw_device.cpp b/sdm/libs/core/fb/hw_device.cpp
index 50e686a..590c23c 100644
--- a/sdm/libs/core/fb/hw_device.cpp
+++ b/sdm/libs/core/fb/hw_device.cpp
@@ -852,7 +852,6 @@
 }
 
 bool HWDevice::EnableHotPlugDetection(int enable) {
-  bool ret_value = true;
   char hpdpath[kMaxStringLength];
   int hdmi_node_index = GetFBNodeIndex(kDeviceHDMI);
   if (hdmi_node_index < 0) {
@@ -860,22 +859,14 @@
   }
 
   snprintf(hpdpath , sizeof(hpdpath), "%s%d/hpd", fb_path_, hdmi_node_index);
-  int hpdfd = Sys::open_(hpdpath, O_RDWR, 0);
-  if (hpdfd < 0) {
-    DLOGW("Open failed = %s", hpdpath);
+
+  char value = enable ? '1' : '0';
+  ssize_t length = SysFsWrite(hpdpath, &value, sizeof(value));
+  if (length <= 0) {
     return false;
   }
 
-  char value = enable ? '1' : '0';
-  ssize_t length = Sys::pwrite_(hpdfd, &value, 1, 0);
-  if (length <= 0) {
-    DLOGE("Write failed 'hpd' = %d", enable);
-    ret_value = false;
-  }
-
-  Sys::close_(hpdfd);
-
-  return ret_value;
+  return true;
 }
 
 void HWDevice::ResetDisplayParams() {
@@ -1012,5 +1003,20 @@
   return kErrorNotSupported;
 }
 
+ssize_t HWDevice::SysFsWrite(char* file_node, char* value, ssize_t length) {
+  int fd = Sys::open_(file_node, O_RDWR, 0);
+  if (fd < 0) {
+    DLOGW("Open failed = %s", file_node);
+    return -1;
+  }
+  ssize_t len = Sys::pwrite_(fd, value, length, 0);
+  if (length <= 0) {
+    DLOGE("Write failed for path %s with value %s", file_node, value);
+  }
+  Sys::close_(fd);
+
+  return len;
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/fb/hw_device.h b/sdm/libs/core/fb/hw_device.h
index cde3efa..138dbda 100644
--- a/sdm/libs/core/fb/hw_device.h
+++ b/sdm/libs/core/fb/hw_device.h
@@ -111,6 +111,7 @@
   void SetColorSpace(LayerColorSpace source, mdp_color_space *color_space);
 
   bool EnableHotPlugDetection(int enable);
+  ssize_t SysFsWrite(char* file_node, char* value, ssize_t length);
 
   // Store the Device EventHandler - used for callback
   HWEventHandler *event_handler_;
diff --git a/sdm/libs/core/fb/hw_hdmi.cpp b/sdm/libs/core/fb/hw_hdmi.cpp
index c47a0bd..a5fff54 100644
--- a/sdm/libs/core/fb/hw_hdmi.cpp
+++ b/sdm/libs/core/fb/hw_hdmi.cpp
@@ -107,6 +107,9 @@
 DisplayError HWHDMI::Init(HWEventHandler *eventhandler) {
   DisplayError error = kErrorNone;
 
+  SetSourceProductInformation("vendor_name", "ro.product.manufacturer");
+  SetSourceProductInformation("product_description", "ro.product.name");
+
   error = HWDevice::Init(eventhandler);
   if (error != kErrorNone) {
     return error;
@@ -530,5 +533,26 @@
   return is_file_present;
 }
 
+void HWHDMI::SetSourceProductInformation(const char *node, const char *name) {
+  char property_value[kMaxStringLength];
+  char sys_fs_path[kMaxStringLength];
+  int hdmi_node_index = GetFBNodeIndex(kDeviceHDMI);
+  if (hdmi_node_index < 0) {
+    return;
+  }
+
+  ssize_t length = 0;
+  bool prop_read_success = Debug::GetProperty(name, property_value);
+  if (!prop_read_success) {
+    return;
+  }
+
+  snprintf(sys_fs_path , sizeof(sys_fs_path), "%s%d/%s", fb_path_, hdmi_node_index, node);
+  length = HWDevice::SysFsWrite(sys_fs_path, property_value, strlen(property_value));
+  if (length <= 0) {
+    DLOGW("Failed to write %s = %s", node, property_value);
+  }
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/fb/hw_hdmi.h b/sdm/libs/core/fb/hw_hdmi.h
index 3f18b28..c216b8f 100644
--- a/sdm/libs/core/fb/hw_hdmi.h
+++ b/sdm/libs/core/fb/hw_hdmi.h
@@ -62,6 +62,7 @@
   DisplayError ReadTimingInfo();
   bool ReadResolutionFile(char *config_buffer);
   bool IsResolutionFilePresent();
+  void SetSourceProductInformation(const char *node, const char *name);
 
   uint32_t hdmi_mode_count_;
   uint32_t hdmi_modes_[256];
diff --git a/sdm/libs/core/fb/hw_primary.cpp b/sdm/libs/core/fb/hw_primary.cpp
index c548a26..884f87c 100644
--- a/sdm/libs/core/fb/hw_primary.cpp
+++ b/sdm/libs/core/fb/hw_primary.cpp
@@ -382,6 +382,7 @@
 
   char refresh_rate_string[kMaxStringLength];
   snprintf(refresh_rate_string, sizeof(refresh_rate_string), "%d", refresh_rate);
+  DLOGI_IF(kTagDriverConfig, "Setting refresh rate = %d", refresh_rate);
   ssize_t len = Sys::pwrite_(fd, refresh_rate_string, strlen(refresh_rate_string), 0);
   if (len < 0) {
     DLOGE("Failed to write %d with error %s", refresh_rate, strerror(errno));
@@ -546,7 +547,7 @@
 void HWPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
   char node_path[kMaxStringLength] = {0};
 
-  DLOGI("Setting idle timeout to = %d ms", timeout_ms);
+  DLOGI_IF(kTagDriverConfig, "Setting idle timeout to = %d ms", timeout_ms);
 
   snprintf(node_path, sizeof(node_path), "%s%d/idle_time", fb_path_, fb_node_index_);
 
diff --git a/sdm/libs/hwc/hwc_display.cpp b/sdm/libs/hwc/hwc_display.cpp
index 7fe8984..099a507 100644
--- a/sdm/libs/hwc/hwc_display.cpp
+++ b/sdm/libs/hwc/hwc_display.cpp
@@ -381,9 +381,10 @@
 
   if (pvt_handle) {
     layer_buffer->format = GetSDMFormat(pvt_handle->format, pvt_handle->flags);
+    layer_buffer->width = pvt_handle->width;
+    layer_buffer->height = pvt_handle->height;
 
-    const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
-    if (meta_data && (SetMetaData(*meta_data, layer) != kErrorNone)) {
+    if (SetMetaData(pvt_handle, layer) != kErrorNone) {
       return -EINVAL;
     }
 
@@ -391,8 +392,6 @@
       return -EINVAL;
     }
 
-    layer_buffer->width = pvt_handle->width;
-    layer_buffer->height = pvt_handle->height;
     if (pvt_handle->bufferType == BUFFER_TYPE_VIDEO) {
       layer_stack_.flags.video_present = true;
       layer_buffer->flags.video = true;
@@ -463,7 +462,7 @@
   layer_buffer->acquire_fence_fd = hwc_layer->acquireFenceFd;
 }
 
-int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::PrePrepareLayerStack(hwc_display_contents_1_t *content_list) {
   if (shutdown_pending_) {
     return 0;
   }
@@ -591,6 +590,15 @@
   // Configure layer stack
   layer_stack_.flags.geometry_changed = ((content_list->flags & HWC_GEOMETRY_CHANGED) > 0);
 
+  return 0;
+}
+
+int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
+  if (shutdown_pending_) {
+    return 0;
+  }
+  size_t num_hw_layers = content_list->numHwLayers;
+
   if (!skip_prepare_) {
     DisplayError error = display_intf_->Prepare(&layer_stack_);
     if (error != kErrorNone) {
@@ -871,9 +879,7 @@
 }
 
 void HWCDisplay::SetIdleTimeoutMs(uint32_t timeout_ms) {
-  if (display_intf_) {
-    display_intf_->SetIdleTimeoutMs(timeout_ms);
-  }
+  return;
 }
 
 DisplayError HWCDisplay::SetMaxMixerStages(uint32_t max_mixer_stages) {
@@ -1260,25 +1266,40 @@
   return kErrorNone;
 }
 
-DisplayError HWCDisplay::SetMetaData(const MetaData_t &meta_data, Layer *layer) {
-  if (meta_data.operation & UPDATE_REFRESH_RATE) {
-    layer->frame_rate = RoundToStandardFPS(meta_data.refreshrate);
+DisplayError HWCDisplay::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
+  const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
+  LayerBuffer *layer_buffer = layer->input_buffer;
+
+  if (!meta_data) {
+    return kErrorNone;
   }
 
-  if ((meta_data.operation & PP_PARAM_INTERLACED) && meta_data.interlaced) {
-    layer->input_buffer->flags.interlace = true;
-  }
-
-  if (meta_data.operation & LINEAR_FORMAT) {
-    layer->input_buffer->format = GetSDMFormat(meta_data.linearFormat, 0);
-  }
-
-  if (meta_data.operation & UPDATE_COLOR_SPACE) {
-    if (SetColorSpace(meta_data.colorSpace, &layer->color_space) != kErrorNone) {
+  if (meta_data->operation & UPDATE_COLOR_SPACE) {
+    if (SetColorSpace(meta_data->colorSpace, &layer->color_space) != kErrorNone) {
       return kErrorNotSupported;
     }
   }
 
+  if (meta_data->operation & UPDATE_REFRESH_RATE) {
+    layer->frame_rate = RoundToStandardFPS(meta_data->refreshrate);
+  }
+
+  if ((meta_data->operation & PP_PARAM_INTERLACED) && meta_data->interlaced) {
+    layer_buffer->flags.interlace = true;
+  }
+
+  if (meta_data->operation & LINEAR_FORMAT) {
+    layer_buffer->format = GetSDMFormat(meta_data->linearFormat, 0);
+  }
+
+  if (meta_data->operation & UPDATE_BUFFER_GEOMETRY) {
+    int actual_width = pvt_handle->width;
+    int actual_height = pvt_handle->height;
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, actual_width, actual_height);
+    layer_buffer->width = actual_width;
+    layer_buffer->height = actual_height;
+  }
+
   return kErrorNone;
 }
 
diff --git a/sdm/libs/hwc/hwc_display.h b/sdm/libs/hwc/hwc_display.h
index ce624a3..9154225 100644
--- a/sdm/libs/hwc/hwc_display.h
+++ b/sdm/libs/hwc/hwc_display.h
@@ -126,6 +126,7 @@
   virtual DisplayError Refresh();
 
   virtual int AllocateLayerStack(hwc_display_contents_1_t *content_list);
+  virtual int PrePrepareLayerStack(hwc_display_contents_1_t *content_list);
   virtual int PrepareLayerStack(hwc_display_contents_1_t *content_list);
   virtual int CommitLayerStack(hwc_display_contents_1_t *content_list);
   virtual int PostCommitLayerStack(hwc_display_contents_1_t *content_list);
@@ -144,7 +145,7 @@
   uint32_t RoundToStandardFPS(uint32_t fps);
   virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
   DisplayError SetColorSpace(const ColorSpace_t source, LayerColorSpace *target);
-  DisplayError SetMetaData(const MetaData_t &meta_data, Layer *layer);
+  DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
   bool NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list);
   void CacheLayerStackInfo(hwc_display_contents_1_t *content_list);
   bool IsLayerUpdating(const hwc_layer_1_t &hwc_layer, const LayerCache &layer_cache);
@@ -181,7 +182,6 @@
   uint32_t force_refresh_rate_ = 0;
   bool boot_animation_completed_ = false;
   bool shutdown_pending_ = false;
-  bool handle_refresh_ = true;
   bool use_blit_comp_ = false;
   bool secure_display_active_ = false;
   bool skip_prepare_ = false;
diff --git a/sdm/libs/hwc/hwc_display_external.cpp b/sdm/libs/hwc/hwc_display_external.cpp
index a02be81..99c903c 100644
--- a/sdm/libs/hwc/hwc_display_external.cpp
+++ b/sdm/libs/hwc/hwc_display_external.cpp
@@ -98,6 +98,11 @@
     return 0;
   }
 
+  status = PrePrepareLayerStack(content_list);
+  if (status) {
+    return status;
+  }
+
   status = PrepareLayerStack(content_list);
   if (status) {
     return status;
diff --git a/sdm/libs/hwc/hwc_display_primary.cpp b/sdm/libs/hwc/hwc_display_primary.cpp
index 9842b61..416e390 100644
--- a/sdm/libs/hwc/hwc_display_primary.cpp
+++ b/sdm/libs/hwc/hwc_display_primary.cpp
@@ -133,31 +133,28 @@
     return 0;
   }
 
-  status = PrepareLayerStack(content_list);
+  status = PrePrepareLayerStack(content_list);
   if (status) {
     return status;
   }
 
-  // Drop invalidate trigger to SurfaceFlinger
-  // if all layers in previous draw cycle were composed using GPU
-  // OR
-  // if all layers were composed using GPU sometime in past and the cached content
-  // is being used currently.
-  handle_refresh_ = false;
-  int app_layer_count = content_list->numHwLayers - 1;
-  if (app_layer_count > 1) {
-    int fb_layer_count = 0;
-    for (int i = 0; i < app_layer_count; i++) {
-      if (content_list->hwLayers[i].compositionType == HWC_FRAMEBUFFER) {
-        fb_layer_count++;
-      }
-    }
+  bool one_updating_layer = SingleLayerUpdating(content_list->numHwLayers - 1);
+  ToggleCPUHint(one_updating_layer);
 
-    if ((fb_layer_count == 0) && !layer_stack_cache_.in_use) {
-      handle_refresh_ = true;
-    } else if (fb_layer_count > 0 && fb_layer_count < app_layer_count) {
-      handle_refresh_ = true;
-    }
+  uint32_t refresh_rate = GetOptimalRefreshRate(one_updating_layer);
+  DisplayError error = display_intf_->SetRefreshRate(refresh_rate);
+  if (error == kErrorNone) {
+    // On success, set current refresh rate to new refresh rate
+    current_refresh_rate_ = refresh_rate;
+  }
+
+  if (handle_idle_timeout_) {
+    handle_idle_timeout_ = false;
+  }
+
+  status = PrepareLayerStack(content_list);
+  if (status) {
+    return status;
   }
 
   return 0;
@@ -192,24 +189,9 @@
     return status;
   }
 
-  bool one_updating_layer = SingleLayerUpdating(content_list->numHwLayers - 1);
-
-  SetMetadataRefreshRate(one_updating_layer);
-  ToggleCPUHint(one_updating_layer);
-
   return 0;
 }
 
-int HWCDisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
-  DisplayError error = kErrorNone;
-
-  if (display_intf_) {
-    error = display_intf_->SetRefreshRate(refresh_rate);
-  }
-
-  return (error ? -1 : 0);
-}
-
 int HWCDisplayPrimary::Perform(uint32_t operation, ...) {
   va_list args;
   va_start(args, operation);
@@ -287,52 +269,33 @@
   return;
 }
 
-void HWCDisplayPrimary::SetMetadataRefreshRate(bool one_updating_layer) {
-  // return if force_refresh_rate_ is set or metadata_refresh_rate is not enabled
-  if (force_refresh_rate_) {
-    return;
-  }
-
-  uint32_t refresh_rate = max_refresh_rate_;
-  if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
-    refresh_rate = metadata_refresh_rate_;
-  }
-
-  int status = SetRefreshRate(refresh_rate);
-  if (status == 0) {
-    // Set current refresh rate to metadata refresh rate
-    current_refresh_rate_ = refresh_rate;
-  } else {
-    // Failed - Restore to max refresh rate
-    current_refresh_rate_ = max_refresh_rate_;
-  }
-}
-
 void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) {
-  if (refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) {
-    // Cannot honor force refresh rate, as its beyond the range
+  if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
+       force_refresh_rate_ == refresh_rate) {
+    // Cannot honor force refresh rate, as its beyond the range or new request is same
     return;
   }
 
-  uint32_t rate = refresh_rate;
+  const hwc_procs_t *hwc_procs = *hwc_procs_;
   force_refresh_rate_ = refresh_rate;
-  if (refresh_rate == 0) {
-    // refresh rate request of 0 means the client is resetting the forced request rate
-    rate = max_refresh_rate_;
-  }
 
-  int status = SetRefreshRate(rate);
-  if (status) {
-    // failed Reset force_refresh_rate to 0, and restore max refresh rate
-    force_refresh_rate_ = 0;
-    rate = max_refresh_rate_;
-    DLOGE("Setting Refresh Rate = %d Failed", refresh_rate);
-  }
-  current_refresh_rate_ = rate;
+  hwc_procs->invalidate(hwc_procs);
 
   return;
 }
 
+uint32_t HWCDisplayPrimary::GetOptimalRefreshRate(bool one_updating_layer) {
+  if (force_refresh_rate_) {
+    return force_refresh_rate_;
+  } else if (handle_idle_timeout_) {
+    return min_refresh_rate_;
+  } else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
+    return metadata_refresh_rate_;
+  }
+
+  return max_refresh_rate_;
+}
+
 DisplayError HWCDisplayPrimary::Refresh() {
   const hwc_procs_t *hwc_procs = *hwc_procs_;
   DisplayError error = kErrorNone;
@@ -341,25 +304,15 @@
     return kErrorParameters;
   }
 
-  if (!handle_refresh_) {
-    error = kErrorNotSupported;
-  }
-
-  if (error == kErrorNone) {
-    hwc_procs->invalidate(hwc_procs);
-  }
-
-  uint32_t refresh_rate = force_refresh_rate_ ? force_refresh_rate_ : min_refresh_rate_;
-
-  int status = SetRefreshRate(refresh_rate);
-  if (status) {
-    DLOGE("Setting Refresh Rate = %d Failed", refresh_rate);
-  } else {
-    current_refresh_rate_ = refresh_rate;
-  }
+  hwc_procs->invalidate(hwc_procs);
+  handle_idle_timeout_ = true;
 
   return error;
 }
 
+void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
+  display_intf_->SetIdleTimeoutMs(timeout_ms);
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/hwc/hwc_display_primary.h b/sdm/libs/hwc/hwc_display_primary.h
index 230d2d5..e30d200 100644
--- a/sdm/libs/hwc/hwc_display_primary.h
+++ b/sdm/libs/hwc/hwc_display_primary.h
@@ -46,10 +46,10 @@
   virtual int Init();
   virtual int Prepare(hwc_display_contents_1_t *content_list);
   virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual int SetRefreshRate(uint32_t refresh_rate);
   virtual int Perform(uint32_t operation, ...);
   virtual void SetSecureDisplay(bool secure_display_active);
   virtual DisplayError Refresh();
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
 
  private:
   HWCDisplayPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
@@ -58,10 +58,11 @@
   void ProcessBootAnimCompleted();
   void SetQDCMSolidFillInfo(bool enable, uint32_t color);
   void ToggleCPUHint(bool set);
-  void SetMetadataRefreshRate(bool one_updating_layer);
   void ForceRefreshRate(uint32_t refresh_rate);
+  uint32_t GetOptimalRefreshRate(bool one_updating_layer);
 
   CPUHint *cpu_hint_;
+  bool handle_idle_timeout_ = false;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_display_virtual.cpp b/sdm/libs/hwc/hwc_display_virtual.cpp
index 219a81b..f292656 100644
--- a/sdm/libs/hwc/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc/hwc_display_virtual.cpp
@@ -147,6 +147,11 @@
     return status;
   }
 
+  status = PrePrepareLayerStack(content_list);
+  if (status) {
+    return status;
+  }
+
   status = PrepareLayerStack(content_list);
   if (status) {
     return status;
diff --git a/sdm/libs/utils/debug.cpp b/sdm/libs/utils/debug.cpp
index 33f94b9..003be5a 100644
--- a/sdm/libs/utils/debug.cpp
+++ b/sdm/libs/utils/debug.cpp
@@ -133,5 +133,13 @@
   return (ubwc_framebuffer == 1);
 }
 
+bool Debug::GetProperty(const char* property_name, char* value) {
+  if (debug_.debug_handler_->GetProperty(property_name, value) != kErrorNone) {
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace sdm