diff --git a/displayengine/include/core/display_interface.h b/displayengine/include/core/display_interface.h
old mode 100755
new mode 100644
index ff99cb8..1e99d1a
--- a/displayengine/include/core/display_interface.h
+++ b/displayengine/include/core/display_interface.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -298,6 +298,14 @@
   */
   virtual DisplayError SetVSyncState(bool enable) = 0;
 
+  /*! @brief Method to set idle timeout value. Idle fallback is disabled with timeout value 0.
+
+    @param[in] timeout value in milliseconds.
+
+    @return \link void \endlink
+  */
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms) = 0;
+
  protected:
   virtual ~DisplayInterface() { }
 };
diff --git a/displayengine/include/utils/debug.h b/displayengine/include/utils/debug.h
old mode 100755
new mode 100644
index 99d3968..7983c84
--- a/displayengine/include/utils/debug.h
+++ b/displayengine/include/utils/debug.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -50,6 +50,7 @@
   static inline bool IsVirtualDriver() { return debug_.virtual_driver_; }
   static uint32_t GetSimulationFlag();
   static uint32_t GetHDMIResolution();
+  static uint32_t GetIdleTimeoutMs();
 
  private:
   Debug();
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 40191e5..c35a4db 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -161,6 +161,10 @@
   if (display_comp_ctx->remaining_strategies != display_comp_ctx->max_strategies) {
     constraints->safe_mode = true;
   }
+
+  if (display_comp_ctx->idle_fallback) {
+    constraints->safe_mode = true;
+  }
 }
 
 void CompManager::PrePrepare(Handle display_ctx, HWLayers *hw_layers) {
@@ -170,6 +174,13 @@
   display_comp_ctx->strategy_intf->Start(&hw_layers->info,
                                          &display_comp_ctx->max_strategies);
   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) {
@@ -230,6 +241,8 @@
   }
 
   res_mgr_.PostCommit(display_comp_ctx->display_resource_ctx, hw_layers);
+
+  display_comp_ctx->idle_fallback = false;
 }
 
 void CompManager::Purge(Handle display_ctx) {
@@ -241,6 +254,32 @@
   res_mgr_.Purge(display_comp_ctx->display_resource_ctx);
 }
 
+bool CompManager::ProcessIdleTimeout(Handle display_ctx) {
+  SCOPE_LOCK(locker_);
+
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+
+  if (!display_comp_ctx) {
+    return false;
+  }
+
+  // 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;
+
+    return true;
+  }
+
+  return false;
+}
+
 void CompManager::AppendDump(char *buffer, uint32_t length) {
   SCOPE_LOCK(locker_);
 }
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index aed357b..674f0d0 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -46,6 +46,7 @@
   void PostPrepare(Handle display_ctx, HWLayers *hw_layers);
   void PostCommit(Handle display_ctx, HWLayers *hw_layers);
   void Purge(Handle display_ctx);
+  bool ProcessIdleTimeout(Handle display_ctx);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
@@ -60,6 +61,12 @@
     DisplayType display_type;
     uint32_t max_strategies;
     uint32_t remaining_strategies;
+    bool idle_fallback;
+    bool handle_idle_timeout;
+
+    DisplayCompositionContext()
+      : display_resource_ctx(NULL), display_type(kPrimary), max_strategies(0),
+        remaining_strategies(0), idle_fallback(false), handle_idle_timeout(true) { }
   };
 
   Locker locker_;
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index 4d8f5aa..95e15d5 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -49,6 +49,9 @@
     return error;
   }
 
+  // Set the idle timeout value to driver through sysfs node
+  hw_intf_->SetIdleTimeoutMs(hw_device_, Debug::GetIdleTimeoutMs());
+
   error = hw_intf_->GetNumDisplayAttributes(hw_device_, &num_modes_);
   if (error != kErrorNone) {
     goto CleanupOnError;
@@ -331,6 +334,10 @@
   return error;
 }
 
+void DisplayBase::SetIdleTimeoutMs(uint32_t timeout_ms) {
+  hw_intf_->SetIdleTimeoutMs(hw_device_, timeout_ms);
+}
+
 DisplayError DisplayBase::VSync(int64_t timestamp) {
   if (vsync_enable_) {
     DisplayEventVSync vsync;
@@ -345,6 +352,13 @@
   return kErrorNone;
 }
 
+void DisplayBase::IdleTimeout() {
+  bool need_refresh = comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
+  if (need_refresh) {
+    event_handler_->Refresh();
+  }
+}
+
 void DisplayBase::AppendDump(char *buffer, uint32_t length) {
   SCOPE_LOCK(locker_);
 
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 187ab8d..5ff219b 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -53,10 +53,12 @@
   virtual DisplayError SetDisplayState(DisplayState state);
   virtual DisplayError SetActiveConfig(uint32_t index);
   virtual DisplayError SetVSyncState(bool enable);
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
 
   // Implement the HWEventHandlers
   virtual DisplayError VSync(int64_t timestamp);
   virtual DisplayError Blank(bool blank);
+  virtual void IdleTimeout();
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
diff --git a/displayengine/libs/core/hw_framebuffer.cpp b/displayengine/libs/core/hw_framebuffer.cpp
index 45d9b60..57a2b69 100644
--- a/displayengine/libs/core/hw_framebuffer.cpp
+++ b/displayengine/libs/core/hw_framebuffer.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -50,11 +50,10 @@
 extern int virtual_close(int fd);
 extern int virtual_poll(struct pollfd *fds,  nfds_t num, int timeout);
 extern ssize_t virtual_pread(int fd, void *data, size_t count, off_t offset);
+extern ssize_t virtual_pwrite(int fd, const void *data, size_t count, off_t offset);
 extern FILE* virtual_fopen(const char *fname, const char *mode);
 extern int virtual_fclose(FILE* fileptr);
 extern ssize_t virtual_getline(char **lineptr, size_t *linelen, FILE *stream);
-extern ssize_t virtual_read(int fd, void *buf, size_t count);
-extern ssize_t virtual_write(int fd, const void *buf, size_t count);
 
 #endif
 
@@ -69,11 +68,10 @@
   close_ = ::close;
   poll_ = ::poll;
   pread_ = ::pread;
+  pwrite_ = ::pwrite;
   fopen_ = ::fopen;
   fclose_ = ::fclose;
   getline_ = ::getline;
-  read_ = ::read;
-  write_ = ::write;
 
 #ifdef DISPLAY_CORE_VIRTUAL_DRIVER
   // If debug property to use virtual driver is set, point to virtual driver interfaces.
@@ -83,11 +81,10 @@
     close_ = virtual_close;
     poll_ = virtual_poll;
     pread_ = virtual_pread;
+    pwrite_ = virtual_pwrite;
     fopen_ = virtual_fopen;
     fclose_ = virtual_fclose;
     getline_ = virtual_getline;
-    read_ = virtual_read;
-    write_ = virtual_write;
   }
 #endif
   for (int i = 0; i < kDeviceMax; i++) {
@@ -99,7 +96,7 @@
   DisplayError error = kErrorNone;
   char node_path[kMaxStringLength] = {0};
   char data[kMaxStringLength] = {0};
-  const char* event_name[kNumDisplayEvents] = {"vsync_event", "show_blank_event"};
+  const char* event_name[kNumDisplayEvents] = {"vsync_event", "show_blank_event", "idle_notify"};
 
   // Read the fb node index
   PopulateFBNodeIndex();
@@ -129,6 +126,11 @@
       for (int event = 0; event < kNumDisplayEvents; event++) {
         pollfd &poll_fd = poll_fds_[display][event];
 
+        if ((primary_panel_info_.type == kCommandModePanel) && (display == kDevicePrimary) &&
+            (!strncmp(event_name[event], "idle_notify", strlen("idle_notify")))) {
+          continue;
+        }
+
         snprintf(node_path, sizeof(node_path), "%s%d/%s", fb_path_, fb_node_index_[display],
                  event_name[event]);
 
@@ -606,7 +608,6 @@
     }
   }
 
-  mdp_commit.flags |= MDP_COMMIT_RETIRE_FENCE;
   mdp_commit.flags &= ~MDP_VALIDATE_LAYER;
   if (ioctl_(hw_context->device_fd, MSMFB_ATOMIC_COMMIT, &hw_context->mdp_commit) == -1) {
     IOCTL_LOGE(MSMFB_ATOMIC_COMMIT, hw_context->type);
@@ -719,7 +720,8 @@
 
   typedef void (HWFrameBuffer::*EventHandler)(int, char *);
   EventHandler event_handler[kNumDisplayEvents] = { &HWFrameBuffer::HandleVSync,
-                                                    &HWFrameBuffer::HandleBlank };
+                                                    &HWFrameBuffer::HandleBlank,
+                                                    &HWFrameBuffer::HandleIdleTimeout };
 
   while (!exit_threads_) {
     int error = poll_(poll_fds_[0], kNumPhysicalDisplays * kNumDisplayEvents, -1);
@@ -764,6 +766,10 @@
   // TODO(user): Need to send blank Event
 }
 
+void HWFrameBuffer::HandleIdleTimeout(int display_id, char *data) {
+  event_handler_[display_id]->IdleTimeout();
+}
+
 void HWFrameBuffer::PopulateFBNodeIndex() {
   char stringbuffer[kMaxStringLength];
   DisplayError error = kErrorNone;
@@ -1008,7 +1014,7 @@
     return kErrorHardware;
   }
   char value = enable ? '1' : '0';
-  ssize_t length = write_(hpdfd, &value, 1);
+  ssize_t length = pwrite_(hpdfd, &value, 1, 0);
   if (length <= 0) {
     DLOGE("Write failed 'hpd' = %d", enable);
     ret_value = false;
@@ -1029,7 +1035,7 @@
     return -1;
   }
 
-  length = read_(edid_file, edid_str, sizeof(edid_str)-1);
+  length = pread_(edid_file, edid_str, sizeof(edid_str)-1, 0);
   if (length <= 0) {
     DLOGE("%s: edid_modes file empty");
     edid_str[0] = '\0';
@@ -1081,5 +1087,46 @@
   return true;
 }
 
+void HWFrameBuffer::SetIdleTimeoutMs(Handle device, uint32_t timeout_ms) {
+  char node_path[kMaxStringLength] = {0};
+  HWContext *hw_context = reinterpret_cast<HWContext *>(device);
+
+  DLOGI("idle timeout = %d ms", timeout_ms);
+
+  switch (hw_context->type) {
+  case kDevicePrimary:
+    {
+      // Idle fallback feature is supported only for video mode panel.
+      if (primary_panel_info_.type == kCommandModePanel) {
+        return;
+      }
+
+      snprintf(node_path, sizeof(node_path), "%s%d/idle_time", fb_path_,
+               fb_node_index_[hw_context->type]);
+
+      // Open a sysfs node to send the timeout value to driver.
+      int fd = open_(node_path, O_WRONLY);
+      if (fd < 0) {
+        DLOGE("Unable to open %s, node %s", node_path, strerror(errno));
+        return;
+      }
+
+      char timeout_string[64];
+      snprintf(timeout_string, sizeof(timeout_string), "%d", timeout_ms);
+
+      // Notify driver about the timeout value
+      ssize_t length = pwrite_(fd, timeout_string, strlen(timeout_string), 0);
+      if (length < -1) {
+        DLOGE("Unable to write into %s, node %s", node_path, strerror(errno));
+      }
+
+      close_(fd);
+    }
+    break;
+  default:
+    break;
+  }
+}
+
 }  // namespace sde
 
diff --git a/displayengine/libs/core/hw_framebuffer.h b/displayengine/libs/core/hw_framebuffer.h
index d9c3a47..54f44a1 100644
--- a/displayengine/libs/core/hw_framebuffer.h
+++ b/displayengine/libs/core/hw_framebuffer.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -59,6 +59,7 @@
   virtual DisplayError Validate(Handle device, HWLayers *hw_layers);
   virtual DisplayError Commit(Handle device, HWLayers *hw_layers);
   virtual DisplayError Flush(Handle device);
+  virtual void SetIdleTimeoutMs(Handle device, uint32_t timeout_ms);
 
  private:
   struct HWContext {
@@ -116,7 +117,7 @@
 
   static const int kMaxStringLength = 1024;
   static const int kNumPhysicalDisplays = 2;
-  static const int kNumDisplayEvents = 2;
+  static const int kNumDisplayEvents = 3;
   static const int kHWMdssVersion5 = 500;  // MDSS_V5
 
   inline DisplayError SetFormat(const LayerBufferFormat &source, uint32_t *target);
@@ -129,6 +130,7 @@
 
   void HandleVSync(int display_id, char *data);
   void HandleBlank(int display_id, char *data);
+  void HandleIdleTimeout(int display_id, char *data);
 
   // Populates HW FrameBuffer Node Index
   void PopulateFBNodeIndex();
@@ -149,12 +151,10 @@
   int (*close_)(int);
   int (*poll_)(struct pollfd *, nfds_t, int);
   ssize_t (*pread_)(int, void *, size_t, off_t);
+  ssize_t (*pwrite_)(int, const void *, size_t, off_t);
   FILE* (*fopen_)( const char *fname, const char *mode);
   int (*fclose_)(FILE* fileptr);
   ssize_t (*getline_)(char **lineptr, size_t *linelen, FILE *stream);
-  ssize_t (*read_)(int fd, void *buf, size_t count);
-  ssize_t (*write_)(int fd, const void *buf, size_t count);
-
 
   // Store the Device EventHandlers - used for callback
   HWEventHandler *event_handler_[kNumPhysicalDisplays];
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index 29a1905..6e87edd 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -145,7 +145,8 @@
 class HWEventHandler {
  public:
   virtual DisplayError VSync(int64_t timestamp) = 0;
-  virtual DisplayError Blank(bool blank)= 0;
+  virtual DisplayError Blank(bool blank) = 0;
+  virtual void IdleTimeout() = 0;
  protected:
   virtual ~HWEventHandler() {}
 };
@@ -170,6 +171,7 @@
   virtual DisplayError Validate(Handle device, HWLayers *hw_layers) = 0;
   virtual DisplayError Commit(Handle device, HWLayers *hw_layers) = 0;
   virtual DisplayError Flush(Handle device) = 0;
+  virtual void SetIdleTimeoutMs(Handle device, uint32_t timeout_ms) = 0;
 
  protected:
   virtual ~HWInterface() { }
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index cf0a55f..1f65c50 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -177,7 +177,7 @@
          { return (UINT32(rotation) == 90 || UINT32(rotation) == 270); }
   void LogRectVerbose(const char *prefix, const LayerRect &roi);
   void RotationConfig(const LayerTransform &transform, const float &scale_x,
-                      const float &scale_y,LayerRect *src_rect,
+                      const float &scale_y, LayerRect *src_rect,
                       struct HWLayerConfig *layer_config, uint32_t *rotate_count);
   DisplayError AcquireRotator(DisplayResourceContext *display_resource_ctx,
                               const uint32_t roate_cnt);
diff --git a/displayengine/libs/hwc/hwc_display.cpp b/displayengine/libs/hwc/hwc_display.cpp
index acddd59..5294faa 100644
--- a/displayengine/libs/hwc/hwc_display.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -559,5 +559,11 @@
   return 0;
 }
 
+void HWCDisplay::SetIdleTimeoutMs(uint32_t timeout_ms) {
+  if (display_intf_) {
+    display_intf_->SetIdleTimeoutMs(timeout_ms);
+  }
+}
+
 }  // namespace sde
 
diff --git a/displayengine/libs/hwc/hwc_display.h b/displayengine/libs/hwc/hwc_display.h
index b396328..262c719 100644
--- a/displayengine/libs/hwc/hwc_display.h
+++ b/displayengine/libs/hwc/hwc_display.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -42,6 +42,7 @@
   virtual int GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values);
   virtual int GetActiveConfig();
   virtual int SetActiveConfig(int index);
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
 
  protected:
   // Maximum number of layers supported by display engine.
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 3f99a23..8fd72b8 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -444,6 +444,12 @@
     hwc_procs_->invalidate(hwc_procs_);
     break;
 
+  case qService::IQService::SET_IDLE_TIMEOUT:
+    if (display_primary_) {
+      uint32_t timeout = (uint32_t)input_parcel->readInt32();
+      display_primary_->SetIdleTimeoutMs(timeout);
+    }
+    break;
   default:
     DLOGW("QService command = %d is not supported", command);
     return -EINVAL;
diff --git a/displayengine/libs/utils/debug_android.cpp b/displayengine/libs/utils/debug_android.cpp
old mode 100755
new mode 100644
index 31bd40b..447a88d
--- a/displayengine/libs/utils/debug_android.cpp
+++ b/displayengine/libs/utils/debug_android.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
@@ -56,5 +56,14 @@
   return 0;
 }
 
+uint32_t Debug::GetIdleTimeoutMs() {
+  char property[PROPERTY_VALUE_MAX];
+  if (property_get("debug.mdpcomp.idletime", property, NULL) > 0) {
+    return atoi(property);
+  }
+
+  return 0;
+}
+
 }  // namespace sde
 
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index a7c4a9a..fd98154 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -37,6 +37,7 @@
 #include "gr.h"
 #include "comptype.h"
 #include "mdp_version.h"
+#include <qdMetaData.h>
 
 #ifdef VENUS_COLOR_FORMAT
 #include <media/msm_media_info.h>
@@ -623,9 +624,19 @@
 int getYUVPlaneInfo(private_handle_t* hnd, struct android_ycbcr* ycbcr)
 {
     int err = 0;
+    int width = hnd->width;
+    int height = hnd->height;
     unsigned int ystride, cstride;
+
     memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
 
+    // Check metadata if the geometry has been updated.
+    MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
+    if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
+        AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(metadata->bufferDim.sliceWidth,
+                   metadata->bufferDim.sliceHeight, hnd->format, 0, width, height);
+    }
+
     // Get the chroma offsets from the handle width/height. We take advantage
     // of the fact the width _is_ the stride
     switch (hnd->format) {
@@ -634,10 +645,10 @@
         case HAL_PIXEL_FORMAT_YCbCr_422_SP:
         case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
         case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: //Same as YCbCr_420_SP_VENUS
-            ystride = cstride = hnd->width;
+            ystride = cstride = width;
             ycbcr->y  = (void*)hnd->base;
-            ycbcr->cb = (void*)(hnd->base + ystride * hnd->height);
-            ycbcr->cr = (void*)(hnd->base + ystride * hnd->height + 1);
+            ycbcr->cb = (void*)(hnd->base + ystride * height);
+            ycbcr->cr = (void*)(hnd->base + ystride * height + 1);
             ycbcr->ystride = ystride;
             ycbcr->cstride = cstride;
             ycbcr->chroma_step = 2;
@@ -648,10 +659,10 @@
         case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
         case HAL_PIXEL_FORMAT_NV21_ZSL:
         case HAL_PIXEL_FORMAT_RAW_SENSOR:
-            ystride = cstride = hnd->width;
+            ystride = cstride = width;
             ycbcr->y  = (void*)hnd->base;
-            ycbcr->cr = (void*)(hnd->base + ystride * hnd->height);
-            ycbcr->cb = (void*)(hnd->base + ystride * hnd->height + 1);
+            ycbcr->cr = (void*)(hnd->base + ystride * height);
+            ycbcr->cb = (void*)(hnd->base + ystride * height + 1);
             ycbcr->ystride = ystride;
             ycbcr->cstride = cstride;
             ycbcr->chroma_step = 2;
@@ -659,16 +670,15 @@
 
         //Planar
         case HAL_PIXEL_FORMAT_YV12:
-            ystride = hnd->width;
-            cstride = ALIGN(hnd->width/2, 16);
+            ystride = width;
+            cstride = ALIGN(width/2, 16);
             ycbcr->y  = (void*)hnd->base;
-            ycbcr->cr = (void*)(hnd->base + ystride * hnd->height);
-            ycbcr->cb = (void*)(hnd->base + ystride * hnd->height +
-                    cstride * hnd->height/2);
+            ycbcr->cr = (void*)(hnd->base + ystride * height);
+            ycbcr->cb = (void*)(hnd->base + ystride * height +
+                    cstride * height/2);
             ycbcr->ystride = ystride;
             ycbcr->cstride = cstride;
             ycbcr->chroma_step = 1;
-
         break;
         //Unsupported formats
         case HAL_PIXEL_FORMAT_YCbCr_422_I:
@@ -764,12 +774,15 @@
 
 bool isUBwcEnabled(int format, int usage)
 {
-    if (isUBwcFormat(format) ||
-        ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) && isUBwcSupported(format)))
-    {
-        // Allow UBWC, only if GPU supports it and CPU usage flags are not set
-        if (AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format) &&
-            !(usage & (GRALLOC_USAGE_SW_READ_MASK |
+    // Allow UBWC, if client is using an explicitly defined UBWC pixel format.
+    if (isUBwcFormat(format))
+        return true;
+
+    // Allow UBWC, if client sets UBWC gralloc usage flag & GPU supports format.
+    if ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) && isUBwcSupported(format) &&
+        AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format)) {
+        // Allow UBWC, only if CPU usage flags are not set
+        if (!(usage & (GRALLOC_USAGE_SW_READ_MASK |
                       GRALLOC_USAGE_SW_WRITE_MASK))) {
             return true;
         }
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index 9ab9d09..48da09e 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -149,7 +149,8 @@
             flags |= private_handle_t::PRIV_FLAGS_TILE_RENDERED;
         }
 
-        if (isUBwcEnabled(format, usage)) {
+        if (AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format) &&
+            isUBwcEnabled(format, usage)) {
             flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
         }
 
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 32e8474..b84daad 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -752,7 +752,7 @@
     bool isVirtualDisplay = (disp == HWC_DISPLAY_VIRTUAL);
     // If hotpluggable or virtual displays are inactive return error
     if ((hotPluggable || isVirtualDisplay) && !ctx->dpyAttr[disp].connected) {
-        ALOGE("%s display (%d) is inactive", __FUNCTION__, disp);
+        ALOGW("%s display (%d) is not connected anymore", __FUNCTION__, disp);
         return -EINVAL;
     }
 
diff --git a/libhwcomposer/hwc_copybit.cpp b/libhwcomposer/hwc_copybit.cpp
index 38c0810..546a67b 100644
--- a/libhwcomposer/hwc_copybit.cpp
+++ b/libhwcomposer/hwc_copybit.cpp
@@ -216,8 +216,13 @@
         return false;
     }
 
-    if (mEngine == NULL || !(validateParams(ctx, list))) {
-        ALOGE("%s: Invalid Params", __FUNCTION__);
+    if (mEngine == NULL) {
+        ALOGW("%s: Copybit HAL not enabled", __FUNCTION__);
+        return false;
+    }
+
+    if (!(validateParams(ctx, list))) {
+        ALOGE("%s: validateParams() failed", __FUNCTION__);
         return false;
     }
     PtorInfo* ptorInfo = &(ctx->mPtorInfo);
diff --git a/libhwcomposer/hwc_dump_layers.cpp b/libhwcomposer/hwc_dump_layers.cpp
index 6a8feb2..aad984d 100644
--- a/libhwcomposer/hwc_dump_layers.cpp
+++ b/libhwcomposer/hwc_dump_layers.cpp
@@ -130,7 +130,7 @@
         mDumpCntLimPng = (mDumpCntLimPng < 0) ? 0: mDumpCntLimPng;
         if (mDumpCntLimPng) {
             snprintf(mDumpDirPng, sizeof(mDumpDirPng),
-                    "/data/sfdump.png.%04d.%02d.%02d.%02d.%02d.%02d",
+                    "/data/misc/display/sfdump.png.%04d.%02d.%02d.%02d.%02d.%02d",
                     dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
                     dumpTime.tm_mday, dumpTime.tm_hour,
                     dumpTime.tm_min, dumpTime.tm_sec);
@@ -160,7 +160,7 @@
         mDumpCntLimRaw = (mDumpCntLimRaw < 0) ? 0: mDumpCntLimRaw;
         if (mDumpCntLimRaw) {
             snprintf(mDumpDirRaw, sizeof(mDumpDirRaw),
-                    "/data/sfdump.raw.%04d.%02d.%02d.%02d.%02d.%02d",
+                    "/data/misc/display/sfdump.raw.%04d.%02d.%02d.%02d.%02d.%02d",
                     dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
                     dumpTime.tm_mday, dumpTime.tm_hour,
                     dumpTime.tm_min, dumpTime.tm_sec);
diff --git a/libhwcomposer/hwc_fbupdate.cpp b/libhwcomposer/hwc_fbupdate.cpp
index b63fb3a..8660740 100644
--- a/libhwcomposer/hwc_fbupdate.cpp
+++ b/libhwcomposer/hwc_fbupdate.cpp
@@ -541,7 +541,7 @@
             return false;
         }
 
-        if(ctx->mOverlay->comparePipePriority(destL, destR) == -1) {
+        if(ctx->mOverlay->needsPrioritySwap(destL, destR)) {
             qhwc::swap(destL, destR);
         }
 
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index cdb5396..23cea5a 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -217,6 +217,9 @@
     mCurrentFrame.reset(numLayers);
     ctx->mOverlay->clear(mDpy);
     ctx->mLayerRotMap[mDpy]->clear();
+    resetROI(ctx, mDpy);
+    memset(&mCurrentFrame.drop, 0, sizeof(mCurrentFrame.drop));
+    mCurrentFrame.dropCount = 0;
 }
 
 void MDPComp::reset() {
@@ -593,7 +596,8 @@
             hwc_rect_t updatingRect = dst;
 
 #ifdef QCOM_BSP
-            if(!needsScaling(layer) && !layer->transform)
+            if(!needsScaling(layer) && !layer->transform &&
+                   (!isYuvBuffer((private_handle_t *)layer->handle)))
             {
                 hwc_rect_t src = integerizeSourceCrop(layer->sourceCropf);
                 int x_off = dst.left - src.left;
@@ -2663,12 +2667,8 @@
             return false;
         }
 
-        // Return values
-        // 1  Left pipe is higher priority, do nothing.
-        // 0  Pipes of same priority.
-        //-1  Right pipe is of higher priority, needs swap.
-        if(ctx->mOverlay->comparePipePriority(pipe_info.lIndex,
-                pipe_info.rIndex) == -1) {
+        if(ctx->mOverlay->needsPrioritySwap(pipe_info.lIndex,
+                    pipe_info.rIndex)) {
             qhwc::swap(pipe_info.lIndex, pipe_info.rIndex);
         }
     }
diff --git a/libhwcomposer/hwc_uevents.cpp b/libhwcomposer/hwc_uevents.cpp
index d1c68a5..c6179e4 100644
--- a/libhwcomposer/hwc_uevents.cpp
+++ b/libhwcomposer/hwc_uevents.cpp
@@ -121,10 +121,19 @@
             /* We need to send hotplug to SF only when we are disconnecting
              * HDMI as an external display. */
             if(dpy == HWC_DISPLAY_EXTERNAL) {
-                ALOGE_IF(UEVENT_DEBUG,"%s:Sending EXTERNAL OFFLINE hotplug"
-                        "event", __FUNCTION__);
+                ALOGI("%s: Sending EXTERNAL OFFLINE event", __FUNCTION__);
                 ctx->proc->hotplug(ctx->proc, dpy, EXTERNAL_OFFLINE);
             }
+
+            //On 8994, 8992 due to hardware limitations, we disable bwc
+            //when HDMI intf is active
+            if((qdutils::MDPVersion::getInstance().is8994() or
+                qdutils::MDPVersion::getInstance().is8092()) and
+                    qdutils::MDPVersion::getInstance().supportsBWC()) {
+                Locker::Autolock _l(ctx->mDrawLock);
+                ctx->mBWCEnabled = true;
+            }
+
             break;
         }
     case EXTERNAL_ONLINE:
@@ -136,6 +145,15 @@
                 break;
             }
 
+            //On 8994, 8992 due to hardware limitations, we disable bwc
+            //when HDMI intf is active
+            if((qdutils::MDPVersion::getInstance().is8994() or
+                qdutils::MDPVersion::getInstance().is8092()) and
+                    qdutils::MDPVersion::getInstance().supportsBWC()) {
+                Locker::Autolock _l(ctx->mDrawLock);
+                ctx->mBWCEnabled = false;
+            }
+
             if (ctx->mHDMIDisplay->isHDMIPrimaryDisplay()) {
                 ctx->mDrawLock.lock();
                 handle_online(ctx, dpy);
@@ -193,14 +211,13 @@
             ctx->mDrawLock.unlock();
 
             /* External display is HDMI */
-            ALOGE_IF(UEVENT_DEBUG, "%s: Sending EXTERNAL ONLINE"
-                    "hotplug event", __FUNCTION__);
+            ALOGI("%s: Sending EXTERNAL ONLINE event", __FUNCTION__);
             ctx->proc->hotplug(ctx->proc, dpy, EXTERNAL_ONLINE);
             break;
         }
     default:
         {
-            ALOGE("%s: Invalid state to swtich:%d", __FUNCTION__, switch_state);
+            ALOGE("%s: Invalid state to switch:%d", __FUNCTION__, switch_state);
             break;
         }
     }
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index 8139013..f53e8c4 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -2352,10 +2352,9 @@
 
 bool isDisplaySplit(hwc_context_t* ctx, int dpy) {
     qdutils::MDPVersion& mdpHw = qdutils::MDPVersion::getInstance();
-    if(ctx->dpyAttr[dpy].xres > mdpHw.getMaxPipeWidth()) {
+    if(ctx->dpyAttr[dpy].xres > mdpHw.getMaxMixerWidth()) {
         return true;
     }
-    //For testing we could split primary via device tree values
     if(dpy == HWC_DISPLAY_PRIMARY && mdpHw.getRightSplit()) {
         return true;
     }
@@ -2725,12 +2724,6 @@
 // Handles online events when HDMI is the primary display. In particular,
 // online events for hdmi connected before AND after boot up and HWC init.
 void handle_online(hwc_context_t* ctx, int dpy) {
-    //On 8994 due to hardware limitations, we disable bwc completely when HDMI
-    //intf is active
-    if(qdutils::MDPVersion::getInstance().is8994() and
-            qdutils::MDPVersion::getInstance().supportsBWC()) {
-        ctx->mBWCEnabled = false;
-    }
     // Close the current fd if it was opened earlier on when HWC
     // was initialized.
     if (ctx->dpyAttr[dpy].fd >= 0) {
@@ -2761,12 +2754,6 @@
     resetDisplayInfo(ctx, dpy);
     ctx->dpyAttr[dpy].connected = false;
     ctx->dpyAttr[dpy].isActive = false;
-    //On 8994 due to hardware limitations, we enable bwc only when HDMI
-    //intf is inactive
-    if(qdutils::MDPVersion::getInstance().is8994() and
-            qdutils::MDPVersion::getInstance().supportsBWC()) {
-        ctx->mBWCEnabled = true;
-    }
 }
 
 };//namespace qhwc
diff --git a/libhwcomposer/hwc_virtual.cpp b/libhwcomposer/hwc_virtual.cpp
index 06418bf..a294a75 100644
--- a/libhwcomposer/hwc_virtual.cpp
+++ b/libhwcomposer/hwc_virtual.cpp
@@ -223,13 +223,15 @@
         private_handle_t* ohnd, int dpy) {
     bool scalingMode = false;
     int fbWidth = ctx->dpyAttr[dpy].xres;
-    int fbHeight =  ctx->dpyAttr[dpy].yres;
-    if((getWidth(ohnd) != fbWidth) || (getHeight(ohnd) != fbHeight)) {
+    int fbHeight = ctx->dpyAttr[dpy].yres;
+    int alW = 0, alH = 0;
+    getBufferSizeAndDimensions(fbWidth, fbHeight, ohnd->format, alW, alH);
+    if((getWidth(ohnd) != alW) || (getHeight(ohnd) != alH)) {
         scalingMode = true;
     }
     ctx->dpyAttr[dpy].mMDPScalingMode = scalingMode;
 
     ALOGD_IF(HWCVIRTUAL_LOG, "%s fb(%dx%d) outputBuffer(%dx%d) scalingMode=%d",
-            __FUNCTION__, fbWidth, fbHeight,
+            __FUNCTION__, alW, alH,
             getWidth(ohnd), getHeight(ohnd), scalingMode);
 }
diff --git a/liboverlay/overlay.cpp b/liboverlay/overlay.cpp
index c250919..ca599ed 100644
--- a/liboverlay/overlay.cpp
+++ b/liboverlay/overlay.cpp
@@ -282,38 +282,58 @@
     return false;
 }
 
-int Overlay::comparePipePriority(utils::eDest pipe1Index,
+bool Overlay::needsPrioritySwap(utils::eDest pipe1Index,
         utils::eDest pipe2Index) {
     validate((int)pipe1Index);
     validate((int)pipe2Index);
+
     uint8_t pipe1Prio = mPipeBook[(int)pipe1Index].mPipe->getPriority();
     uint8_t pipe2Prio = mPipeBook[(int)pipe2Index].mPipe->getPriority();
-    if(pipe1Prio > pipe2Prio)
-        return -1;
-    else if(pipe1Prio < pipe2Prio)
-        return 1;
-    else {
+
+    int pipe1Id = mPipeBook[(int)pipe1Index].mPipe->getPipeId();
+    int pipe2Id = mPipeBook[(int)pipe2Index].mPipe->getPipeId();
+
+    utils::eMdpPipeType leftType = PipeBook::getPipeType(pipe1Index);
+    utils::eMdpPipeType rightType = PipeBook::getPipeType(pipe2Index);
+
+    if(pipe1Id >=0 && pipe2Id >=0) {
+        // LEFT priority should be higher then RIGHT
+        return (pipe1Prio > pipe2Prio);
+    } else if(pipe1Id < 0 && pipe2Id < 0) {
         // If we are here, Source Split is enabled and both pipes are
         // new requests. In this case left type should be of higher prio
         // than right type
-        utils::eMdpPipeType leftType = PipeBook::getPipeType(pipe1Index);
-        utils::eMdpPipeType rightType = PipeBook::getPipeType(pipe2Index);
-
         if(leftType == rightType) {
             //Safe. Onus on driver to assign correct pipes within same type
-            return 1;
+            return false;
         } else if(leftType == OV_MDP_PIPE_DMA or rightType == OV_MDP_PIPE_VG) {
             //If we are here, right is definitely a higher prio type.
             //This check takes advantage of having only 3 types and avoids 3
             //different failure combination checks.
-            return -1;
+            return true;
         } else {
             //Types are correct priority-wise
-            return 1;
+            return false;
+        }
+    } else if(pipe1Id < 0) {
+        //LEFT needs new allocation.
+        if(leftType == rightType) {
+            // If RIGHT has highest priority(lowest id), swap it.
+            return (pipe2Id == PipeBook::pipeMinID[leftType]);
+        } else {
+            // Swap if needs lowest priority type pipe.
+            return (leftType == OV_MDP_PIPE_DMA);
+        }
+    } else { /* if (pipe2Id < 0) */
+        // RIGHT needs new allocation.
+        if(leftType == rightType) {
+            // If LEFT has lowest priority(highest id), swap it.
+            return (pipe1Id == PipeBook::pipeMaxID[leftType]);
+        } else {
+            // Swap if needs highest  priority type pipe.
+            return (rightType == OV_MDP_PIPE_VG);
         }
     }
-
-    return 0;
 }
 
 bool Overlay::commit(utils::eDest dest) {
@@ -413,6 +433,13 @@
         }
     }
 
+    PipeBook::pipeMinID[OV_MDP_PIPE_RGB] = 8;
+    PipeBook::pipeMaxID[OV_MDP_PIPE_RGB] = (numPipesXType[OV_MDP_PIPE_RGB] == 3)? 32 : 512;
+    PipeBook::pipeMinID[OV_MDP_PIPE_VG] = 1;
+    PipeBook::pipeMaxID[OV_MDP_PIPE_VG] = (numPipesXType[OV_MDP_PIPE_VG] == 3)? 4 : 256;
+    PipeBook::pipeMinID[OV_MDP_PIPE_DMA] = 64;
+    PipeBook::pipeMaxID[OV_MDP_PIPE_DMA] = 128;
+
     FILE *displayDeviceFP = NULL;
     char fbType[MAX_FRAME_BUFFER_NAME_SIZE];
     char msmFbTypePath[MAX_FRAME_BUFFER_NAME_SIZE];
@@ -578,6 +605,8 @@
 int Overlay::PipeBook::sAllocatedBitmap = 0;
 utils::eMdpPipeType Overlay::PipeBook::pipeTypeLUT[utils::OV_MAX] =
     {utils::OV_MDP_PIPE_ANY};
+int Overlay::PipeBook::pipeMinID[utils::OV_MDP_PIPE_ANY] = {0};
+int Overlay::PipeBook::pipeMaxID[utils::OV_MDP_PIPE_ANY] = {0};
 void *Overlay::sLibScaleHandle = NULL;
 int (*Overlay::sFnProgramScale)(struct mdp_overlay_list *) = NULL;
 /* Dynamically link ABL library */
diff --git a/liboverlay/overlay.h b/liboverlay/overlay.h
index 984b439..45b5e57 100644
--- a/liboverlay/overlay.h
+++ b/liboverlay/overlay.h
@@ -123,11 +123,10 @@
      */
     bool isPipeTypeAttached(utils::eMdpPipeType type);
     /* Compare pipe priorities and return
-     * 1 if 1st pipe has a higher priority
-     * 0 if both have the same priority
-     *-1 if 2nd pipe has a higher priority
+     * true - A swap is needed to fix the priority.
+     * false - Good, priority wise.
      */
-    int comparePipePriority(utils::eDest pipe1Index, utils::eDest pipe2Index);
+    bool needsPrioritySwap(utils::eDest pipe1Index, utils::eDest pipe2Index);
     /* Returns pipe dump. Expects a NULL terminated buffer of big enough size
      * to populate.
      */
@@ -229,6 +228,9 @@
 
         static int NUM_PIPES;
         static utils::eMdpPipeType pipeTypeLUT[utils::OV_MAX];
+        static int pipeMinID[utils::OV_MDP_PIPE_ANY];
+        static int pipeMaxID[utils::OV_MDP_PIPE_ANY];
+
         /* Session for reserved pipes */
         enum Session {
             NONE,
diff --git a/liboverlay/overlayMdp.cpp b/liboverlay/overlayMdp.cpp
index 3932c4c..1290f32 100644
--- a/liboverlay/overlayMdp.cpp
+++ b/liboverlay/overlayMdp.cpp
@@ -374,8 +374,21 @@
     if(errVal) {
         /* No dump for failure due to insufficient resource */
         if(errVal != E2BIG) {
-            mdp_wrapper::dump("Bad ov dump: ",
-                *list.overlay_list[list.processed_overlays]);
+            //ENODEV is returned when the driver cannot satisfy a pipe request.
+            //This could happen if previous round's UNSET hasn't been commited
+            //yet, either because of a missed vsync or because of difference in
+            //vsyncs of primary and external. This is expected during
+            //transition scenarios, but should be considered fatal if seen
+            //continuously.
+            if(errVal == ENODEV) {
+                ALOGW("%s: Pipe unavailable. Likely previous UNSET pending. "
+                    "Fatal if seen continuously.", __FUNCTION__);
+            } else {
+                ALOGE("%s failed, error %d: %s", __FUNCTION__, errVal,
+                        strerror(errVal));
+                mdp_wrapper::dump("Bad ov dump: ",
+                        *list.overlay_list[list.processed_overlays]);
+            }
         }
         return false;
     }