diff --git a/common.mk b/common.mk
index 464f296..183ee99 100644
--- a/common.mk
+++ b/common.mk
@@ -29,6 +29,10 @@
     common_flags += -DVENUS_COLOR_FORMAT
 endif
 
+ifeq ($(call is-board-platform-in-list, $(MASTER_SIDE_CP_TARGET_LIST)), true)
+    common_flags += -DMASTER_SIDE_CP
+endif
+
 common_deps  :=
 kernel_includes :=
 
diff --git a/displayengine/include/core/buffer_allocator.h b/displayengine/include/core/buffer_allocator.h
index 4081c54..d81c414 100644
--- a/displayengine/include/core/buffer_allocator.h
+++ b/displayengine/include/core/buffer_allocator.h
@@ -90,8 +90,7 @@
   implemented by the client. Buffer manager in display engine will use these methods to
   allocate/deallocate buffers for display engine.
 
-  @sa CompManager::Init
-  @sa ResManager::Init
+  @sa CoreInterface::CreateCore
 */
 class BufferAllocator {
  public:
@@ -102,8 +101,6 @@
     @param[in] buffer_info \link BufferInfo \endlink
 
     @return \link DisplayError \endlink
-
-    @sa BufferManager
   */
   virtual DisplayError AllocateBuffer(BufferInfo *buffer_info) = 0;
 
@@ -115,8 +112,6 @@
     @param[in] buffer_info \link BufferInfo \endlink
 
     @return \link DisplayError \endlink
-
-    @sa BufferManager
   */
   virtual DisplayError FreeBuffer(BufferInfo *buffer_info) = 0;
 
diff --git a/displayengine/include/core/buffer_sync_handler.h b/displayengine/include/core/buffer_sync_handler.h
index d0d062e..699d1a1 100644
--- a/displayengine/include/core/buffer_sync_handler.h
+++ b/displayengine/include/core/buffer_sync_handler.h
@@ -45,9 +45,7 @@
   implemented by the client. Buffer manager and HWFramebuffer in display engine will use these
   methods to wait for buffer sync fd to be signaled/merge two buffer sync fds into one.
 
-  @sa CompManager::Init
-  @sa ResManager::Init
-  @sa HWInterface::Create
+  @sa CoreInterface::CreateCore
 */
 class BufferSyncHandler {
  public:
@@ -58,8 +56,6 @@
     @param[in] fd
 
     @return \link DisplayError \endlink
-
-    @sa BufferManager::GetNextBuffer
   */
 
   virtual DisplayError SyncWait(int fd) = 0;
@@ -74,8 +70,6 @@
     @param[out] merged_fd
 
     @return \link DisplayError \endlink
-
-    @sa HWFrameBuffer::RotatorCommit
  */
 
   virtual DisplayError SyncMerge(int fd1, int fd2, int *merged_fd) = 0;
diff --git a/displayengine/include/core/debug_interface.h b/displayengine/include/core/debug_interface.h
index ff72321..9e83e46 100644
--- a/displayengine/include/core/debug_interface.h
+++ b/displayengine/include/core/debug_interface.h
@@ -46,8 +46,7 @@
   kTagStrategy,         //!< Debug log is tagged for strategy decisions.
   kTagCompManager,      //!< Debug log is tagged for composition manager.
   kTagDriverConfig,     //!< Debug log is tagged for driver config.
-  kTagBufferManager,    //!< Debug log is tagged for buffer manager state transitions.
-  kTagOfflineCtrl,      //!< Debug log is tagged for offline controller.
+  kTagRotator,          //!< Debug log is tagged for rotator.
   kTagScalar,           //!< Debug log is tagged for Scalar Helper.
 };
 
diff --git a/displayengine/include/core/display_interface.h b/displayengine/include/core/display_interface.h
index f4c4415..c041e1a 100644
--- a/displayengine/include/core/display_interface.h
+++ b/displayengine/include/core/display_interface.h
@@ -63,8 +63,11 @@
 
   kStateOn,         //!< Display is ON. Contents are rendered in this state.
 
-  kStateDoze,       //!< Display is ON but not updating contents. Client shall not push any contents
-                    //!< in this state.
+  kStateDoze,       //!< Display is ON and it is configured in a low power state.
+
+  kStateDozeSuspend,
+                    //!< Display is ON in a low power state and continue showing its current
+                    //!< contents indefinitely until the mode changes.
 
   kStateStandby,    //!< Display is OFF. Client will continue to receive VSync events in this state
                     //!< if VSync is enabled. Contents are not rendered in this state.
@@ -95,9 +98,10 @@
   float fps;                  //!< Frame rate per second.
   uint32_t vsync_period_ns;   //!< VSync period in nanoseconds.
   uint32_t v_total;           //!< Total lines in Y-direction (vActive + vFP + vBP + vPulseWidth).
+  uint32_t h_total;           //!< Total width of panel (hActive + hFP + hBP + hPulseWidth).
 
   DisplayConfigVariableInfo() : x_pixels(0), y_pixels(0), x_dpi(0.0f), y_dpi(0.0f),
-                               fps(0.0f), vsync_period_ns(0) { }
+                               fps(0.0f), vsync_period_ns(0), v_total(0), h_total(0) { }
 };
 
 /*! @brief Event data associated with VSync event.
diff --git a/displayengine/include/core/layer_buffer.h b/displayengine/include/core/layer_buffer.h
index e4a73c3..2493c13 100644
--- a/displayengine/include/core/layer_buffer.h
+++ b/displayengine/include/core/layer_buffer.h
@@ -54,6 +54,9 @@
   kFormatRGB888,        //!< 8-bits Red, Green, Blue interleaved in RGB order. No Alpha.
   kFormatBGR888,        //!< 8-bits Blue, Green, Red interleaved in BGR order. No Alpha.
   kFormatRGB565,        //!< 5-bit Red, 6-bit Green, 5-bit Blue interleaved in RGB order. No Alpha.
+  kFormatRGBA8888Ubwc,  //!< UBWC aligned RGBA8888 format
+  kFormatRGBX8888Ubwc,  //!< UBWC aligned RGBX8888 format
+  kFormatRGB565Ubwc,    //!< UBWC aligned RGB565 format
 
   /* All YUV-Planar formats, Any new format will be added towards end of this group to maintain
      backward compatibility.
@@ -99,6 +102,8 @@
                                       //!< horizontally subsampled interleaved VU-plane:
                                       //!<    v(0), u(1), v(2), u(3) ... v(n-1), u(n)
 
+  kFormatYCbCr420SPVenusUbwc,         //!< UBWC aligned YCbCr420SemiPlanarVenus format
+
   /* All YUV-Packed formats, Any new format will be added towards end of this group to maintain
      backward compatibility.
   */
@@ -107,15 +112,6 @@
                                       //!<    y(0), u(0), y(1), v(0), y(2), u(2), y(3), v(2)
                                       //!<    y(n-1), u(n-1), y(n), v(n-1)
 
-  /* All UBWC aligned formats. Any new format will be added towards end of this group to maintain
-     backward compatibility.
-  */
-  kFormatRGBA8888Ubwc = 0x400,        //!< UBWC aligned RGBA8888 format
-
-  kFormatRGB565Ubwc,                  //!< UBWC aligned RGB565 format
-
-  kFormatYCbCr420SPVenusUbwc,         //!< UBWC aligned Venus NV12 format
-
   kFormatInvalid = 0xFFFFFFFF,
 };
 
@@ -138,14 +134,30 @@
   @sa LayerBuffer
 */
 struct LayerBufferFlags {
-  uint64_t secure : 1;      //!< This flag shall be set by client to indicate that the buffer need
-                            //!< to be handled securely.
-  uint64_t video  : 1;      //!< This flag shall be set by client to indicate that the buffer is
-                            //!< video/ui buffer
-  uint64_t macro_tile : 1;  //!< This flag shall be set by client to indicate that the buffer format
-                            //!< is macro tiled.
+  union {
+    struct {
+      uint32_t secure : 1;          //!< This flag shall be set by client to indicate that the
+                                    //!< buffer need to be handled securely.
 
-  LayerBufferFlags() : secure(0), video(0), macro_tile(0) { }
+      uint32_t video  : 1;          //!< This flag shall be set by client to indicate that the
+                                    //!< buffer is video/ui buffer.
+
+      uint32_t macro_tile : 1;      //!< This flag shall be set by client to indicate that the
+                                    //!< buffer format is macro tiled.
+
+      uint32_t interlace : 1;       //!< This flag shall be set by the client to indicate that
+                                    //!< the buffer has interlaced content.
+
+      uint32_t secure_display : 1;
+                                    //!< This flag shall be set by the client to indicate that the
+                                    //!< secure display session is in progress. Secure display
+                                    //!< session can not coexist with non-secure session.
+      };
+
+      uint32_t flags;   //!< For initialization purpose only. Client shall not refer it directly.
+  };
+
+  LayerBufferFlags() : flags(0) { }
 };
 
 /*! @brief This structure defines a layer buffer handle which contains raw buffer and its associated
diff --git a/displayengine/include/core/layer_stack.h b/displayengine/include/core/layer_stack.h
index 96ec20f..66f60e7 100644
--- a/displayengine/include/core/layer_stack.h
+++ b/displayengine/include/core/layer_stack.h
@@ -44,8 +44,6 @@
   @sa Layer
 */
 enum LayerBlending {
-  kBlendingNone,            //!< Blend operation is not specified.
-
   kBlendingOpaque,          //!< Pixel color is expressed using straight alpha in color tuples. It
                             //!< is constant blend operation. The layer would appear opaque if plane
                             //!< alpha is 0xFF.
@@ -94,15 +92,22 @@
   @sa LayerBuffer
 */
 struct LayerFlags {
-  uint64_t skip : 1;      //!< This flag shall be set by client to indicate that this layer will be
-                          //!< handled by GPU. Display Device will not consider it for composition.
+  union {
+    struct {
+      uint32_t skip : 1;      //!< This flag shall be set by client to indicate that this layer
+                              //!< will be handled by GPU. Display Device will not consider it
+                              //!< for composition.
 
-  uint64_t updating : 1;  //!< This flag shall be set by client to indicate that this is updating/
-                          //!< non-updating. so strategy manager will mark them for SDE/GPU
-                          //!< composition respectively when the layer stack qualifies for cache
-                          //!< based composition.
+      uint32_t updating : 1;  //!< This flag shall be set by client to indicate that this is
+                              //!< updating non-updating. so strategy manager will mark them for
+                              //!< SDE/GPU composition respectively when the layer stack qualifies
+                              //!< for cache based composition.
+    };
 
-  LayerFlags() : skip(0), updating(0) { }
+    uint32_t flags;   //!< For initialization purpose only. Client shall not refer it directly.
+  };
+
+  LayerFlags() : flags(0) { }
 };
 
 /*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to
@@ -111,24 +116,29 @@
   @sa LayerBuffer
 */
 struct LayerStackFlags {
-  uint64_t geometry_changed : 1;  //!< This flag shall be set by client to indicate that the layer
-                                  //!< set passed to Prepare() has changed by more than just the
-                                  //!< buffer handles and acquire fences.
+  union {
+    struct {
+      uint32_t geometry_changed : 1;  //!< This flag shall be set by client to indicate that the
+                                      //!< layer set passed to Prepare() has changed by more than
+                                      //!< just the buffer handles and acquire fences.
 
-  uint64_t skip_present : 1;      //!< This flag will be set to true, if the current layer stack
-                                  //!< contains skip layers.
+      uint32_t skip_present : 1;      //!< This flag will be set to true, if the current layer
+                                      //!< stack contains skip layers.
 
-  uint64_t video_present : 1;     //!< This flag will be set to true, if current layer stack
-                                  //!< contains video.
+      uint32_t video_present : 1;     //!< This flag will be set to true, if current layer stack
+                                      //!< contains video.
 
-  uint64_t secure_present : 1;    //!< This flag will be set to true, if the current layer stack
-                                  //!< contains secure layers.
+      uint32_t secure_present : 1;    //!< This flag will be set to true, if the current layer
+                                      //!< stack contains secure layers.
 
-  uint64_t animating : 1;         //!< This flag shall be set by client to indicate that the current
-                                  //!< frame is animating.
+      uint32_t animating : 1;         //!< This flag shall be set by client to indicate that the
+                                      //!<  current frame is animating.
+      };
 
-  LayerStackFlags()
-    : geometry_changed(0), skip_present(0), video_present(0), secure_present(0), animating(0) { }
+      uint32_t flags;   //!< For initialization purpose only. Client shall not refer it directly.
+  };
+
+  LayerStackFlags() : flags(0) { }
 };
 
 /*! @brief This structure defines a rectanglular area inside a display layer.
@@ -203,7 +213,7 @@
 
   uint32_t frame_rate;              //!< Rate at which frames are being updated for this layer.
 
-  Layer() : input_buffer(NULL), composition(kCompositionGPU), blending(kBlendingNone),
+  Layer() : input_buffer(NULL), composition(kCompositionGPU), blending(kBlendingOpaque),
             plane_alpha(0), frame_rate(0) { }
 };
 
diff --git a/displayengine/include/private/hw_info_types.h b/displayengine/include/private/hw_info_types.h
index c6c2a0a..1740615 100644
--- a/displayengine/include/private/hw_info_types.h
+++ b/displayengine/include/private/hw_info_types.h
@@ -65,10 +65,12 @@
   uint64_t max_bandwidth_low;
   uint64_t max_bandwidth_high;
   uint32_t max_mixer_width;
+  uint32_t max_pipe_width;
   uint32_t max_pipe_bw;
   uint32_t max_sde_clk;
   float clk_fudge_factor;
   bool has_bwc;
+  bool has_ubwc;
   bool has_decimation;
   bool has_macrotile;
   bool has_rotator_downscale;
@@ -80,8 +82,8 @@
       num_cursor_pipe(0), num_blending_stages(0), num_rotator(0), num_control(0),
       num_mixer_to_disp(0), smp_total(0), smp_size(0), num_smp_per_pipe(0), max_scale_up(1),
       max_scale_down(1), max_bandwidth_low(0), max_bandwidth_high(0), max_mixer_width(2048),
-      max_pipe_bw(0), max_sde_clk(0), clk_fudge_factor(1.0f), has_bwc(false),
-      has_decimation(false), has_macrotile(false), has_rotator_downscale(false),
+      max_pipe_width(2048), max_pipe_bw(0), max_sde_clk(0), clk_fudge_factor(1.0f), has_bwc(false),
+      has_ubwc(false), has_decimation(false), has_macrotile(false), has_rotator_downscale(false),
       has_non_scalar_rgb(false), is_src_split(false) { }
 
   void Reset() { *this = HWResourceInfo(); }
diff --git a/displayengine/include/private/strategy_interface.h b/displayengine/include/private/strategy_interface.h
index eac88cc..df01c7f 100644
--- a/displayengine/include/private/strategy_interface.h
+++ b/displayengine/include/private/strategy_interface.h
@@ -31,6 +31,7 @@
 
 #include <core/sde_types.h>
 #include <core/display_interface.h>
+#include "hw_info_types.h"
 
 namespace sde {
 
@@ -88,11 +89,14 @@
 
   @param[in] version \link STRATEGY_VERSION_TAG \endlink
   @param[in] type \link DisplayType \endlink
+  @param[in] hw_resource_info \link HWResourceInfo \endlink
+  @param[in] hw_panel_info \link HWPanelInfo \endlink
   @param[out] interface \link StrategyInterface \endlink
 
   @return \link DisplayError \endlink
 */
 typedef DisplayError (*CreateStrategyInterface)(uint16_t version, DisplayType type,
+                      const HWResourceInfo *hw_resource_info, const HWPanelInfo *hw_panel_info,
                       StrategyInterface **interface);
 
 /*! @brief Function to destroy composer strategy interface.
@@ -139,6 +143,13 @@
 
   uint32_t count;           //!< Total number of layers which need to be set on hardware.
 
+  LayerRect left_partial_update;
+                            //!< Left ROI.
+
+  LayerRect right_partial_update;
+                            //!< Right ROI.
+
+
   HWLayersInfo() : stack(NULL), count(0) { }
 };
 
diff --git a/displayengine/include/utils/debug.h b/displayengine/include/utils/debug.h
index 5f65834..2cef5d7 100644
--- a/displayengine/include/utils/debug.h
+++ b/displayengine/include/utils/debug.h
@@ -65,6 +65,7 @@
   static uint32_t GetIdleTimeoutMs();
   static bool IsRotatorDownScaleDisabled();
   static bool IsDecimationDisabled();
+  static bool IsPartialUpdate();
 
  private:
   Debug();
diff --git a/displayengine/include/utils/rect.h b/displayengine/include/utils/rect.h
index 0730529..dd60672 100644
--- a/displayengine/include/utils/rect.h
+++ b/displayengine/include/utils/rect.h
@@ -37,11 +37,14 @@
 
 namespace sde {
 
-  bool IsValidRect(const LayerRect &rect);
-  LayerRect GetIntersection(const LayerRect &rect1, const LayerRect &rect2);
-  void LogRect(DebugTag debug_tag, const char *prefix, const LayerRect &roi);
-  void NormalizeRect(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect);
-
+  bool IsValid(const LayerRect &rect);
+  bool IsCongruent(const LayerRect &rect1, const LayerRect &rect2);
+  void Log(DebugTag debug_tag, const char *prefix, const LayerRect &roi);
+  void Normalize(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect);
+  LayerRect Union(const LayerRect &rect1, const LayerRect &rect2);
+  LayerRect Intersection(const LayerRect &rect1, const LayerRect &rect2);
+  LayerRect Subtract(const LayerRect &rect1, const LayerRect &rect2);
+  LayerRect Reposition(const LayerRect &rect1, const int &x_offset, const int &y_offset);
 }  // namespace sde
 
 #endif  // __RECT_H__
diff --git a/displayengine/libs/core/Android.mk b/displayengine/libs/core/Android.mk
index 5623283..b1948fd 100644
--- a/displayengine/libs/core/Android.mk
+++ b/displayengine/libs/core/Android.mk
@@ -25,9 +25,9 @@
                                  strategy_default.cpp \
                                  res_manager.cpp \
                                  res_config.cpp \
-                                 offline_ctrl.cpp \
+                                 rotator_ctrl.cpp \
                                  dump_impl.cpp \
-                                 buffer_manager.cpp \
+                                 session_manager.cpp \
                                  scalar_helper.cpp \
                                  $(LOCAL_HW_INTF_PATH)/hw_info.cpp \
                                  $(LOCAL_HW_INTF_PATH)/hw_device.cpp \
diff --git a/displayengine/libs/core/buffer_manager.cpp b/displayengine/libs/core/buffer_manager.cpp
deleted file mode 100644
index 95c310a..0000000
--- a/displayengine/libs/core/buffer_manager.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
-* Copyright (c) 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:
-*  * Redistributions of source code must retain the above copyright
-*    notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*    copyright notice, this list of conditions and the following
-*    disclaimer in the documentation and/or other materials provided
-*    with the distribution.
-*  * Neither the name of The Linux Foundation nor the names of its
-*    contributors may be used to endorse or promote products derived
-*    from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
-* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <utils/debug.h>
-#include <utils/constants.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-
-#include "buffer_manager.h"
-
-#define __CLASS__ "BufferManager"
-
-namespace sde {
-
-// --------------------------------- BufferSlot Implementation -------------------------------------
-
-DisplayError BufferManager::BufferSlot::Init() {
-  uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
-  size_t buffer_size = hw_buffer_info.alloc_buffer_info.size;
-
-  release_fd = new int[buffer_count];
-  if (release_fd == NULL) {
-    return kErrorMemory;
-  }
-
-  offset = new uint32_t[buffer_count];
-  if (offset == NULL) {
-    delete[] release_fd;
-    release_fd = NULL;
-    return kErrorMemory;
-  }
-
-  for (uint32_t idx = 0; idx < buffer_count; idx++) {
-    release_fd[idx] = -1;
-    offset[idx] = UINT32((buffer_size / buffer_count) * idx);
-  }
-  curr_index = 0;
-
-  return kErrorNone;
-}
-
-DisplayError BufferManager::BufferSlot::Deinit() {
-  uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
-
-  for (uint32_t idx = 0; idx < buffer_count; idx++) {
-    if (release_fd[idx] >= 0) {
-      close(release_fd[idx]);
-      release_fd[idx] = -1;
-    }
-  }
-
-  if (offset) {
-    delete[] offset;
-    offset = NULL;
-  }
-
-  if (release_fd) {
-    delete[] release_fd;
-    release_fd = NULL;
-  }
-
-  state = kBufferSlotFree;
-  hw_buffer_info = HWBufferInfo();
-
-  return kErrorNone;
-}
-
-// BufferManager State Transition
-// *******************************************************
-// Current State *             Next State
-//               *****************************************
-//               *   FREE       READY        ACQUIRED
-// *******************************************************
-//  FREE         *    NA         NA        GetNextBuffer()
-//  READY        *   Stop()      NA        GetNextBuffer()
-//  ACQUIRED     *    NA       Start()          NA
-//********************************************************
-
-// ------------------------------- BufferManager Implementation ------------------------------------
-
-BufferManager::BufferManager(BufferAllocator *buffer_allocator,
-                             BufferSyncHandler *buffer_sync_handler)
-    : buffer_allocator_(buffer_allocator), buffer_sync_handler_(buffer_sync_handler),
-      num_used_slot_(0) {
-}
-
-void BufferManager::Start() {
-  uint32_t slot = 0, num_ready_slot = 0;
-
-  // Change the state of acquired buffer_slot to kBufferSlotReady
-  while ((num_ready_slot < num_used_slot_) && (slot < kMaxBufferSlotCount)) {
-    if (buffer_slot_[slot].state == kBufferSlotFree) {
-      slot++;
-      continue;
-    }
-
-    buffer_slot_[slot++].state = kBufferSlotReady;
-    num_ready_slot++;
-  }
-}
-
-DisplayError BufferManager::GetNextBuffer(HWBufferInfo *hw_buffer_info) {
-  DisplayError error = kErrorNone;
-  const BufferConfig &buffer_config = hw_buffer_info->buffer_config;
-
-  DLOGI_IF(kTagBufferManager, "Input: w = %d h = %d f = %d", buffer_config.width,
-           buffer_config.height, buffer_config.format);
-
-  uint32_t free_slot = num_used_slot_;
-  uint32_t acquired_slot = kMaxBufferSlotCount;
-  uint32_t num_used_slot = 0;
-
-  // First look for a buffer slot in ready state, if no buffer slot found in ready state matching
-  // with current input config, assign a buffer slot in free state and allocate buffers for it.
-  for (uint32_t slot = 0; slot < kMaxBufferSlotCount && num_used_slot < num_used_slot_; slot++) {
-    HWBufferInfo &hw_buffer_info = buffer_slot_[slot].hw_buffer_info;
-
-    if (buffer_slot_[slot].state == kBufferSlotFree) {
-      free_slot = slot;
-    } else {
-      if ((buffer_slot_[slot].state == kBufferSlotReady)) {
-        if ((::memcmp(&buffer_config, &hw_buffer_info.buffer_config, sizeof(BufferConfig)) == 0)) {
-          buffer_slot_[slot].state = kBufferSlotAcquired;
-          acquired_slot = slot;
-          break;
-        }
-      }
-      num_used_slot++;
-    }
-  }
-
-  // If the input config does not match with existing config, then allocate buffers for the new
-  // buffer slot and change the state to kBufferSlotAcquired
-  if (acquired_slot == kMaxBufferSlotCount) {
-    if (free_slot >= kMaxBufferSlotCount) {
-      return kErrorMemory;
-    }
-
-    buffer_slot_[free_slot].hw_buffer_info.buffer_config = hw_buffer_info->buffer_config;
-
-    error = buffer_allocator_->AllocateBuffer(&buffer_slot_[free_slot].hw_buffer_info);
-    if (error != kErrorNone) {
-      return error;
-    }
-
-    buffer_slot_[free_slot].Init();
-    buffer_slot_[free_slot].state = kBufferSlotAcquired;
-    acquired_slot = free_slot;
-    num_used_slot_++;
-
-    DLOGI_IF(kTagBufferManager, "Allocate Buffer acquired_slot = %d ", acquired_slot);
-  }
-
-  const AllocatedBufferInfo &alloc_buffer_info =
-    buffer_slot_[acquired_slot].hw_buffer_info.alloc_buffer_info;
-  uint32_t curr_index = buffer_slot_[acquired_slot].curr_index;
-
-  // Wait for the release fence fd before buffer slot being given to the client.
-  buffer_sync_handler_->SyncWait(buffer_slot_[acquired_slot].release_fd[curr_index]);
-  buffer_slot_[acquired_slot].release_fd[curr_index] = -1;
-
-  hw_buffer_info->output_buffer.width = buffer_config.width;
-  hw_buffer_info->output_buffer.height = buffer_config.height;
-  hw_buffer_info->output_buffer.format = buffer_config.format;
-  hw_buffer_info->output_buffer.flags.secure = buffer_config.secure;
-
-  hw_buffer_info->output_buffer.planes[0].stride = alloc_buffer_info.stride;
-  hw_buffer_info->output_buffer.planes[0].fd = alloc_buffer_info.fd;
-  hw_buffer_info->output_buffer.planes[0].offset = buffer_slot_[acquired_slot].offset[curr_index];
-  hw_buffer_info->slot = acquired_slot;
-
-  DLOGI_IF(kTagBufferManager, "Output: w = %d h = %d f = %d session_id %d acquired slot = %d " \
-           "num_used_slot %d curr_index = %d offset %d", hw_buffer_info->output_buffer.width,
-           hw_buffer_info->output_buffer.height, hw_buffer_info->output_buffer.format,
-           hw_buffer_info->session_id, acquired_slot, num_used_slot_, curr_index,
-           hw_buffer_info->output_buffer.planes[0].offset);
-
-  return kErrorNone;
-}
-
-DisplayError BufferManager::Stop(int *session_ids) {
-  DisplayError error = kErrorNone;
-  uint32_t slot = 0, count = 0;
-
-  // Free all the buffer slots which were not acquired in the current cycle and deallocate the
-  // buffers associated with it.
-  while ((num_used_slot_ > 0) && (slot < kMaxBufferSlotCount)) {
-    if (buffer_slot_[slot].state == kBufferSlotReady) {
-      if (buffer_slot_[slot].hw_buffer_info.session_id != -1) {
-        session_ids[count++] = buffer_slot_[slot].hw_buffer_info.session_id;
-      }
-
-      error = FreeBufferSlot(slot);
-      if (error != kErrorNone) {
-        return error;
-      }
-
-      num_used_slot_--;
-    }
-    slot++;
-  }
-
-  session_ids[count] = -1;
-
-  return kErrorNone;
-}
-
-DisplayError BufferManager::SetReleaseFd(uint32_t slot, int fd) {
-  if ((slot >= kMaxBufferSlotCount) || (buffer_slot_[slot].state != kBufferSlotAcquired)) {
-    DLOGE("Invalid Parameters slot %d state %s", slot, buffer_slot_[slot].state);
-    kErrorParameters;
-  }
-
-  uint32_t &curr_index = buffer_slot_[slot].curr_index;
-  const HWBufferInfo &hw_buffer_info = buffer_slot_[slot].hw_buffer_info;
-  uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
-
-  // 1. Store the release fence fd, so that buffer manager waits for the release fence fd to be
-  //    signaled and gives the buffer slot to the client.
-  // 2. Modify the curr_index to point to next buffer.
-  buffer_slot_[slot].release_fd[curr_index] = fd;
-  curr_index = (curr_index + 1) % buffer_count;
-
-  DLOGI_IF(kTagBufferManager, "w = %d h = %d f = %d session_id %d slot = %d curr_index = %d " \
-           "sync fd %d", hw_buffer_info.output_buffer.width, hw_buffer_info.output_buffer.height,
-           hw_buffer_info.output_buffer.format, hw_buffer_info.session_id, slot, curr_index, fd);
-
-  return kErrorNone;
-}
-
-
-DisplayError BufferManager::SetSessionId(uint32_t slot, int session_id) {
-  if ((slot >= kMaxBufferSlotCount) || (buffer_slot_[slot].state != kBufferSlotAcquired)) {
-    DLOGE("Invalid Parameters slot %d state %s", slot, buffer_slot_[slot].state);
-    kErrorParameters;
-  }
-
-  HWBufferInfo *hw_buffer_info = &buffer_slot_[slot].hw_buffer_info;
-
-  hw_buffer_info->session_id = session_id;
-
-  DLOGI_IF(kTagBufferManager, "w = %d h = %d f = %d session_id %d slot = %d",
-           hw_buffer_info->output_buffer.width, hw_buffer_info->output_buffer.height,
-           hw_buffer_info->output_buffer.format, hw_buffer_info->session_id, slot);
-
-  return kErrorNone;
-}
-
-DisplayError BufferManager::FreeBufferSlot(uint32_t slot) {
-  DisplayError error = kErrorNone;
-
-  HWBufferInfo *hw_buffer_info = &buffer_slot_[slot].hw_buffer_info;
-
-  error = buffer_allocator_->FreeBuffer(hw_buffer_info);
-  if (error != kErrorNone) {
-    return error;
-  }
-
-  DLOGI_IF(kTagBufferManager, "session_id %d slot = %d num_used_slot %d",
-           hw_buffer_info->session_id, slot, num_used_slot_);
-
-  buffer_slot_[slot].Deinit();
-
-  return kErrorNone;
-}
-
-}  // namespace sde
diff --git a/displayengine/libs/core/buffer_manager.h b/displayengine/libs/core/buffer_manager.h
deleted file mode 100644
index 29bcd03..0000000
--- a/displayengine/libs/core/buffer_manager.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-* Copyright (c) 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:
-*  * Redistributions of source code must retain the above copyright
-*    notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*    copyright notice, this list of conditions and the following
-*    disclaimer in the documentation and/or other materials provided
-*    with the distribution.
-*  * Neither the name of The Linux Foundation nor the names of its
-*    contributors may be used to endorse or promote products derived
-*    from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
-* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef __BUFFER_MANAGER_H__
-#define __BUFFER_MANAGER_H__
-
-#include <utils/locker.h>
-#include <core/buffer_allocator.h>
-#include "hw_interface.h"
-
-namespace sde {
-
-class BufferManager {
- public:
-  BufferManager(BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
-
-  void Start();
-  DisplayError GetNextBuffer(HWBufferInfo *hw_buffer_info);
-  DisplayError Stop(int *session_ids);
-  DisplayError SetReleaseFd(uint32_t slot, int fd);
-  DisplayError SetSessionId(uint32_t slot, int session_id);
-
- private:
-  static const uint32_t kMaxBufferSlotCount = 32;
-
-  enum kBufferSlotState {
-    kBufferSlotFree     = 0,
-    kBufferSlotReady    = 1,
-    kBufferSlotAcquired = 2,
-  };
-
-  struct BufferSlot {
-    HWBufferInfo hw_buffer_info;
-    kBufferSlotState state;
-    int *release_fd;
-    uint32_t *offset;
-    uint32_t curr_index;
-
-    BufferSlot() : state(kBufferSlotFree), release_fd(NULL), offset(NULL), curr_index(0) { }
-    DisplayError Init();
-    DisplayError Deinit();
-  };
-
-  DisplayError FreeBufferSlot(uint32_t index);
-
-  BufferSlot buffer_slot_[kMaxBufferSlotCount];
-  BufferAllocator *buffer_allocator_;
-  BufferSyncHandler *buffer_sync_handler_;
-  uint32_t num_used_slot_;
-};
-
-}  // namespace sde
-
-#endif  // __BUFFER_MANAGER_H__
-
-
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index cc58465..82f7b8d 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -39,13 +39,12 @@
     registered_displays_(0), configured_displays_(0), safe_mode_(false) {
 }
 
-DisplayError CompManager::Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
-                               BufferSyncHandler *buffer_sync_handler) {
+DisplayError CompManager::Init(const HWResourceInfo &hw_res_info) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
 
-  error = res_mgr_.Init(hw_res_info, buffer_allocator, buffer_sync_handler);
+  error = res_mgr_.Init(hw_res_info);
   if (error != kErrorNone) {
     return error;
   }
@@ -80,6 +79,8 @@
     destroy_strategy_intf_ = StrategyDefault::DestroyStrategyInterface;
   }
 
+  hw_res_info_ = hw_res_info;
+
   return error;
 }
 
@@ -96,7 +97,7 @@
 }
 
 DisplayError CompManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
-                                          Handle *display_ctx) {
+                                          const HWPanelInfo &hw_panel_info, Handle *display_ctx) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
@@ -106,7 +107,7 @@
     return kErrorMemory;
   }
 
-  if (create_strategy_intf_(STRATEGY_VERSION_TAG, type,
+  if (create_strategy_intf_(STRATEGY_VERSION_TAG, type, &hw_res_info_, &hw_panel_info,
                             &display_comp_ctx->strategy_intf) != kErrorNone) {
     DLOGW("Unable to create strategy interface");
     delete display_comp_ctx;
@@ -114,7 +115,8 @@
     return kErrorUndefined;
   }
 
-  error = res_mgr_.RegisterDisplay(type, attributes, &display_comp_ctx->display_resource_ctx);
+  error = res_mgr_.RegisterDisplay(type, attributes, hw_panel_info,
+                                   &display_comp_ctx->display_resource_ctx);
   if (error != kErrorNone) {
     destroy_strategy_intf_(display_comp_ctx->strategy_intf);
     delete display_comp_ctx;
@@ -170,8 +172,8 @@
 
   constraints->safe_mode = safe_mode_;
 
-  // Limit 2 layer SDE Comp on HDMI
-  if (display_comp_ctx->display_type == kHDMI) {
+  // Limit 2 layer SDE Comp on HDMI/Virtual
+  if (display_comp_ctx->display_type != kPrimary) {
     constraints->max_layers = 2;
   }
 
@@ -180,7 +182,7 @@
     constraints->safe_mode = true;
   }
 
-  if (display_comp_ctx->idle_fallback) {
+  if (display_comp_ctx->idle_fallback || display_comp_ctx->fallback_) {
     constraints->safe_mode = true;
   }
 }
@@ -318,6 +320,19 @@
   return false;
 }
 
+void CompManager::ProcessThermalEvent(Handle display_ctx, int64_t thermal_level) {
+  SCOPE_LOCK(locker_);
+
+  DisplayCompositionContext *display_comp_ctx =
+          reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+
+  if (thermal_level >= kMaxThermalLevel) {
+    display_comp_ctx->fallback_ = true;
+  } else {
+    display_comp_ctx->fallback_ = false;
+  }
+}
+
 DisplayError CompManager::SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages) {
   SCOPE_LOCK(locker_);
 
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index 0a21ee0..ae638e0 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -36,11 +36,10 @@
 class CompManager : public DumpImpl {
  public:
   CompManager();
-  DisplayError Init(const HWResourceInfo &hw_res_info_, BufferAllocator *buffer_allocator,
-                    BufferSyncHandler *buffer_sync_handler_);
+  DisplayError Init(const HWResourceInfo &hw_res_info_);
   DisplayError Deinit();
   DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
-                               Handle *res_mgr_hnd);
+                               const HWPanelInfo &hw_panel_info, Handle *res_mgr_hnd);
   DisplayError UnregisterDisplay(Handle res_mgr_hnd);
   void PrePrepare(Handle display_ctx, HWLayers *hw_layers);
   DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
@@ -48,12 +47,15 @@
   DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
   void Purge(Handle display_ctx);
   bool ProcessIdleTimeout(Handle display_ctx);
+  void ProcessThermalEvent(Handle display_ctx, int64_t thermal_level);
   DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
 
  private:
+  static const int kMaxThermalLevel = 3;
+
   void PrepareStrategyConstraints(Handle display_ctx, HWLayers *hw_layers);
 
   struct DisplayCompositionContext {
@@ -65,10 +67,12 @@
     uint32_t remaining_strategies;
     bool idle_fallback;
     bool handle_idle_timeout;
+    bool fallback_;
 
     DisplayCompositionContext()
       : display_resource_ctx(NULL), display_type(kPrimary), max_strategies(0),
-        remaining_strategies(0), idle_fallback(false), handle_idle_timeout(true) { }
+        remaining_strategies(0), idle_fallback(false), handle_idle_timeout(true),
+        fallback_(false) { }
   };
 
   Locker locker_;
@@ -81,6 +85,7 @@
   bool safe_mode_;                      // Flag to notify all displays to be in resource crunch
                                         // mode, where strategy manager chooses the best strategy
                                         // that uses optimal number of pipes for each display
+  HWResourceInfo hw_res_info_;
 };
 
 }  // namespace sde
diff --git a/displayengine/libs/core/core_impl.cpp b/displayengine/libs/core/core_impl.cpp
index f04bbb9..4f68fcb 100644
--- a/displayengine/libs/core/core_impl.cpp
+++ b/displayengine/libs/core/core_impl.cpp
@@ -31,6 +31,7 @@
 #include "display_hdmi.h"
 #include "display_virtual.h"
 #include "hw_info_interface.h"
+#include "rotator_ctrl.h"
 
 #define __CLASS__ "CoreImpl"
 
@@ -39,7 +40,7 @@
 CoreImpl::CoreImpl(CoreEventHandler *event_handler, BufferAllocator *buffer_allocator,
                    BufferSyncHandler *buffer_sync_handler)
   : event_handler_(event_handler), buffer_allocator_(buffer_allocator),
-    buffer_sync_handler_(buffer_sync_handler), hw_resource_(NULL) {
+    buffer_sync_handler_(buffer_sync_handler), hw_resource_(NULL), rotator_ctrl_(NULL) {
 }
 
 DisplayError CoreImpl::Init() {
@@ -62,16 +63,24 @@
     goto CleanUpOnError;
   }
 
-  error = comp_mgr_.Init(*hw_resource_, buffer_allocator_, buffer_sync_handler_);
+  error = comp_mgr_.Init(*hw_resource_);
   if (error != kErrorNone) {
-    comp_mgr_.Deinit();
     goto CleanUpOnError;
   }
 
-  error = offline_ctrl_.Init(buffer_sync_handler_);
-  if (error != kErrorNone) {
+  rotator_ctrl_ = new RotatorCtrl();
+  if (!rotator_ctrl_) {
+    comp_mgr_.Deinit();
+    error = kErrorMemory;
     goto CleanUpOnError;
   }
+
+  error = rotator_ctrl_->Init(buffer_allocator_, buffer_sync_handler_);
+  if (error != kErrorNone) {
+    delete rotator_ctrl_;
+    rotator_ctrl_ = NULL;
+  }
+
   return kErrorNone;
 
 CleanUpOnError:
@@ -88,7 +97,7 @@
 DisplayError CoreImpl::Deinit() {
   SCOPE_LOCK(locker_);
 
-  offline_ctrl_.Deinit();
+  rotator_ctrl_->Deinit();
   comp_mgr_.Deinit();
   HWInfoInterface::Destroy(hw_info_intf_);
 
@@ -108,15 +117,15 @@
   switch (type) {
   case kPrimary:
     display_base = new DisplayPrimary(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                      &comp_mgr_, &offline_ctrl_);
+                                      &comp_mgr_, rotator_ctrl_);
     break;
   case kHDMI:
     display_base = new DisplayHDMI(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                   &comp_mgr_, &offline_ctrl_);
+                                   &comp_mgr_, rotator_ctrl_);
     break;
   case kVirtual:
     display_base = new DisplayVirtual(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                      &comp_mgr_, &offline_ctrl_);
+                                      &comp_mgr_, rotator_ctrl_);
     break;
   default:
     DLOGE("Spurious display type %d", type);
diff --git a/displayengine/libs/core/core_impl.h b/displayengine/libs/core/core_impl.h
index 03733a8..5ac1613 100644
--- a/displayengine/libs/core/core_impl.h
+++ b/displayengine/libs/core/core_impl.h
@@ -31,13 +31,13 @@
 
 #include "hw_interface.h"
 #include "comp_manager.h"
-#include "offline_ctrl.h"
 
 #define SET_REVISION(major, minor) ((major << 8) | minor)
 
 namespace sde {
 
 class HWInfoInterface;
+class RotatorCtrl;
 
 class CoreImpl : public CoreInterface {
  public:
@@ -66,7 +66,7 @@
   BufferSyncHandler *buffer_sync_handler_;
   HWResourceInfo *hw_resource_;
   CompManager comp_mgr_;
-  OfflineCtrl offline_ctrl_;
+  RotatorCtrl *rotator_ctrl_;
   HWInfoInterface *hw_info_intf_;
 };
 
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index e58b4f8..47beac0 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -22,11 +22,12 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
+#include <stdio.h>
 #include <utils/constants.h>
 #include <utils/debug.h>
 
 #include "display_base.h"
-#include "offline_ctrl.h"
+#include "rotator_ctrl.h"
 
 #define __CLASS__ "DisplayBase"
 
@@ -35,10 +36,10 @@
 // TODO(user): Have a single structure handle carries all the interface pointers and variables.
 DisplayBase::DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
                          HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
-                         CompManager *comp_manager, OfflineCtrl *offline_ctrl)
+                         CompManager *comp_manager, RotatorCtrl *rotator_ctrl)
   : display_type_(display_type), event_handler_(event_handler), hw_device_type_(hw_device_type),
     buffer_sync_handler_(buffer_sync_handler), comp_manager_(comp_manager),
-    offline_ctrl_(offline_ctrl), state_(kStateOff), hw_device_(0), display_comp_ctx_(0),
+    rotator_ctrl_(rotator_ctrl), state_(kStateOff), hw_device_(0), display_comp_ctx_(0),
     display_attributes_(NULL), num_modes_(0), active_mode_index_(0), pending_commit_(false),
     vsync_enable_(false) {
 }
@@ -74,14 +75,16 @@
   }
 
   error = comp_manager_->RegisterDisplay(display_type_, display_attributes_[active_mode_index_],
-                                        &display_comp_ctx_);
+                                         hw_panel_info_, &display_comp_ctx_);
   if (error != kErrorNone) {
     goto CleanupOnError;
   }
 
-  error = offline_ctrl_->RegisterDisplay(display_type_, &display_offline_ctx_);
-  if (error != kErrorNone) {
-    goto CleanupOnError;
+  if (rotator_ctrl_) {
+    error = rotator_ctrl_->RegisterDisplay(display_type_, &display_rotator_ctx_);
+    if (error != kErrorNone) {
+      goto CleanupOnError;
+    }
   }
 
   return kErrorNone;
@@ -102,7 +105,9 @@
 }
 
 DisplayError DisplayBase::Deinit() {
-  offline_ctrl_->UnregisterDisplay(display_offline_ctx_);
+  if (rotator_ctrl_) {
+    rotator_ctrl_->UnregisterDisplay(display_rotator_ctx_);
+  }
 
   comp_manager_->UnregisterDisplay(display_comp_ctx_);
 
@@ -137,7 +142,18 @@
         break;
       }
 
-      error = offline_ctrl_->Prepare(display_offline_ctx_, &hw_layers_);
+      if (IsRotationRequired(&hw_layers_)) {
+        if (!rotator_ctrl_) {
+          continue;
+        }
+        error = rotator_ctrl_->Prepare(display_rotator_ctx_, &hw_layers_);
+      } else {
+        // Release all the previous rotator sessions.
+        if (rotator_ctrl_) {
+          error = rotator_ctrl_->Purge(display_rotator_ctx_, &hw_layers_);
+        }
+      }
+
       if (error == kErrorNone) {
         error = hw_intf_->Validate(&hw_layers_);
         if (error == kErrorNone) {
@@ -162,30 +178,41 @@
     return kErrorParameters;
   }
 
-  if (state_ == kStateOn) {
-    if (!pending_commit_) {
-      DLOGE("Commit: Corresponding Prepare() is not called for display = %d", display_type_);
-      return kErrorUndefined;
-    }
-
-    error = offline_ctrl_->Commit(display_offline_ctx_, &hw_layers_);
-    if (error == kErrorNone) {
-      error = hw_intf_->Commit(&hw_layers_);
-      if (error == kErrorNone) {
-        error = comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
-        if (error != kErrorNone) {
-          DLOGE("Composition manager PostCommit failed");
-        }
-      } else {
-        DLOGE("Unexpected error. Commit failed on driver.");
-      }
-    }
-  } else {
+  if (state_ != kStateOn) {
     return kErrorNotSupported;
   }
 
+  if (!pending_commit_) {
+    DLOGE("Commit: Corresponding Prepare() is not called for display = %d", display_type_);
+    return kErrorUndefined;
+  }
+
   pending_commit_ = false;
 
+  if (rotator_ctrl_ && IsRotationRequired(&hw_layers_)) {
+    error = rotator_ctrl_->Commit(display_rotator_ctx_, &hw_layers_);
+    if (error != kErrorNone) {
+      return error;
+    }
+  }
+
+  error = hw_intf_->Commit(&hw_layers_);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  if (rotator_ctrl_ && IsRotationRequired(&hw_layers_)) {
+    error = rotator_ctrl_->PostCommit(display_rotator_ctx_, &hw_layers_);
+    if (error != kErrorNone) {
+      return error;
+    }
+  }
+
+  error = comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
+  if (error != kErrorNone) {
+    return error;
+  }
+
   return kErrorNone;
 }
 
@@ -292,6 +319,10 @@
     error = hw_intf_->Doze();
     break;
 
+  case kStateDozeSuspend:
+    error = hw_intf_->DozeSuspend();
+    break;
+
   case kStateStandby:
     error = hw_intf_->Standby();
     break;
@@ -327,7 +358,8 @@
     comp_manager_->UnregisterDisplay(display_comp_ctx_);
   }
 
-  error = comp_manager_->RegisterDisplay(display_type_, display_attributes, &display_comp_ctx_);
+  error = comp_manager_->RegisterDisplay(display_type_, display_attributes, hw_panel_info_,
+                                         &display_comp_ctx_);
   if (error != kErrorNone) {
     return error;
   }
@@ -355,7 +387,7 @@
     comp_manager_->UnregisterDisplay(display_comp_ctx_);
   }
 
-  error = comp_manager_->RegisterDisplay(display_type_, display_attributes_[index],
+  error = comp_manager_->RegisterDisplay(display_type_, display_attributes_[index], hw_panel_info_,
                                          &display_comp_ctx_);
 
   return error;
@@ -383,9 +415,11 @@
                          num_modes_, active_mode_index_);
 
   DisplayConfigVariableInfo &info = display_attributes_[active_mode_index_];
-  DumpImpl::AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
-                         info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps,
-                         info.vsync_period_ns);
+  DumpImpl::AppendString(buffer, length, "\nres:%u x %u, dpi:%.2f x %.2f, fps:%.2f,"
+                         "vsync period: %u", info.x_pixels, info.y_pixels, info.x_dpi,
+                         info.y_dpi, info.fps, info.vsync_period_ns);
+
+  DumpImpl::AppendString(buffer, length, "\n");
 
   uint32_t num_layers = 0;
   uint32_t num_hw_layers = 0;
@@ -394,64 +428,158 @@
     num_hw_layers = hw_layers_.info.count;
   }
 
-  DumpImpl::AppendString(buffer, length, "\n\nnum actual layers: %u, num sde layers: %u",
-                         num_layers, num_hw_layers);
+  if (num_hw_layers == 0) {
+    DumpImpl::AppendString(buffer, length, "\nNo hardware layers programmed");
+    return;
+  }
+
+  HWLayersInfo &layer_info = hw_layers_.info;
+  LayerRect &l_roi = layer_info.left_partial_update;
+  LayerRect &r_roi = layer_info.right_partial_update;
+  DumpImpl::AppendString(buffer, length, "\nROI(L T R B) : LEFT(%d %d %d %d), RIGHT(%d %d %d %d)",
+                         INT(l_roi.left), INT(l_roi.top), INT(l_roi.right), INT(l_roi.bottom),
+                         INT(r_roi.left), INT(r_roi.top), INT(r_roi.right), INT(r_roi.bottom));
+
+  const char *header  = "\n| Idx |  Comp Type  |  Split | WB |  Pipe |    W x H    |       Format       |  Src Rect (L T R B) |  Dst Rect (L T R B) |  Z |    Flags   | Deci(HxV) |";  //NOLINT
+  const char *newline = "\n|-----|-------------|--------|----|-------|-------------|--------------------|---------------------|---------------------|----|------------|-----------|";  //NOLINT
+  const char *format  = "\n| %3s | %11s "     "| %6s " "| %2s | 0x%03x | %4d x %4d | %18s "            "| %4d %4d %4d %4d "  "| %4d %4d %4d %4d "  "| %2s | %10s "   "| %9s |";  //NOLINT
+
+  DumpImpl::AppendString(buffer, length, "\n");
+  DumpImpl::AppendString(buffer, length, newline);
+  DumpImpl::AppendString(buffer, length, header);
+  DumpImpl::AppendString(buffer, length, newline);
 
   for (uint32_t i = 0; i < num_hw_layers; i++) {
-    Layer &layer = hw_layers_.info.stack->layers[hw_layers_.info.index[i]];
+    uint32_t layer_index = hw_layers_.info.index[i];
+    Layer &layer = hw_layers_.info.stack->layers[layer_index];
     LayerBuffer *input_buffer = layer.input_buffer;
     HWLayerConfig &layer_config = hw_layers_.config[i];
-    HWPipeInfo &left_pipe = hw_layers_.config[i].left_pipe;
-    HWPipeInfo &right_pipe = hw_layers_.config[i].right_pipe;
-    HWRotateInfo &left_rotate = hw_layers_.config[i].rotates[0];
-    HWRotateInfo &right_rotate = hw_layers_.config[i].rotates[1];
+    HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
 
-    DumpImpl::AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i,
-                           hw_layers_.info.index[i]);
-    DumpImpl::AppendString(buffer, length, "\nw: %u, h: %u, fmt: %u",
-                           input_buffer->width, input_buffer->height, input_buffer->format);
-    AppendRect(buffer, length, "\nsrc_rect:", &layer.src_rect);
-    AppendRect(buffer, length, "\ndst_rect:", &layer.dst_rect);
+    char idx[8] = { 0 };
+    const char *comp_type = GetName(layer.composition);
+    const char *buffer_format = GetName(input_buffer->format);
+    const char *rotate_split[2] = { "Rot-L", "Rot-R" };
+    const char *comp_split[2] = { "Comp-L", "Comp-R" };
 
-    if (left_rotate.valid) {
-      DumpImpl::AppendString(buffer, length, "\n\tleft rotate =>");
-      DumpImpl::AppendString(buffer, length, "\n\t  pipe id: 0x%x", left_rotate.pipe_id);
-      AppendRect(buffer, length, "\n\t  src_roi:", &left_rotate.src_roi);
-      AppendRect(buffer, length, "\n\t  dst_roi:", &left_rotate.dst_roi);
+    snprintf(idx, sizeof(idx), "%d", layer_index);
+
+    for (uint32_t count = 0; count < hw_rotator_session.hw_block_count; count++) {
+      char writeback_id[8];
+      HWRotateInfo &rotate = hw_rotator_session.hw_rotate_info[count];
+      LayerRect &src_roi = rotate.src_roi;
+      LayerRect &dst_roi = rotate.dst_roi;
+
+      snprintf(writeback_id, sizeof(writeback_id), "%d", rotate.writeback_id);
+
+      DumpImpl::AppendString(buffer, length, format, idx, comp_type, rotate_split[count],
+                             writeback_id, rotate.pipe_id, input_buffer->width,
+                             input_buffer->height, buffer_format, INT(src_roi.left),
+                             INT(src_roi.top), INT(src_roi.right), INT(src_roi.bottom),
+                             INT(dst_roi.left), INT(dst_roi.top), INT(dst_roi.right),
+                             INT(dst_roi.bottom), "-", "-    ", "-    ");
+
+      // print the below only once per layer block, fill with spaces for rest.
+      idx[0] = 0;
+      comp_type = "";
     }
 
-    if (right_rotate.valid) {
-      DumpImpl::AppendString(buffer, length, "\n\tright rotate =>");
-      DumpImpl::AppendString(buffer, length, "\n\t  pipe id: 0x%x", right_rotate.pipe_id);
-      AppendRect(buffer, length, "\n\t  src_roi:", &right_rotate.src_roi);
-      AppendRect(buffer, length, "\n\t  dst_roi:", &right_rotate.dst_roi);
+    if (hw_rotator_session.hw_block_count > 0) {
+      input_buffer = &hw_rotator_session.output_buffer;
+      buffer_format = GetName(input_buffer->format);
     }
 
-    if (left_pipe.valid) {
-      DumpImpl::AppendString(buffer, length, "\n\tleft pipe =>");
-      DumpImpl::AppendString(buffer, length, "\n\t  pipe id: 0x%x", left_pipe.pipe_id);
-      AppendRect(buffer, length, "\n\t  src_roi:", &left_pipe.src_roi);
-      AppendRect(buffer, length, "\n\t  dst_roi:", &left_pipe.dst_roi);
+    for (uint32_t count = 0; count < 2; count++) {
+      char decimation[16];
+      char flags[16];
+      char z_order[8];
+      HWPipeInfo &pipe = (count == 0) ? layer_config.left_pipe : layer_config.right_pipe;
+
+      if (!pipe.valid) {
+        continue;
+      }
+
+      LayerRect &src_roi = pipe.src_roi;
+      LayerRect &dst_roi = pipe.dst_roi;
+
+      snprintf(z_order, sizeof(z_order), "%d", pipe.z_order);
+      snprintf(flags, sizeof(flags), "0x%08x", layer.flags.flags);
+      snprintf(decimation, sizeof(decimation), "%3d x %3d", pipe.horizontal_decimation,
+               pipe.vertical_decimation);
+
+      DumpImpl::AppendString(buffer, length, format, idx, comp_type, comp_split[count],
+                             "-", pipe.pipe_id, input_buffer->width, input_buffer->height,
+                             buffer_format, INT(src_roi.left), INT(src_roi.top),
+                             INT(src_roi.right), INT(src_roi.bottom), INT(dst_roi.left),
+                             INT(dst_roi.top), INT(dst_roi.right), INT(dst_roi.bottom),
+                             z_order, flags, decimation);
+
+      // print the below only once per layer block, fill with spaces for rest.
+      idx[0] = 0;
+      comp_type = "";
     }
 
-    if (right_pipe.valid) {
-      DumpImpl::AppendString(buffer, length, "\n\tright pipe =>");
-      DumpImpl::AppendString(buffer, length, "\n\t  pipe id: 0x%x", right_pipe.pipe_id);
-      AppendRect(buffer, length, "\n\t  src_roi:", &right_pipe.src_roi);
-      AppendRect(buffer, length, "\n\t  dst_roi:", &right_pipe.dst_roi);
-    }
+    DumpImpl::AppendString(buffer, length, newline);
   }
 }
 
-void DisplayBase::AppendRect(char *buffer, uint32_t length, const char *rect_name,
-                             LayerRect *rect) {
-  DumpImpl::AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
-                         rect_name, rect->left, rect->top, rect->right, rect->bottom);
-}
-
 int DisplayBase::GetBestConfig() {
   return (num_modes_ == 1) ? 0 : -1;
 }
 
-}  // namespace sde
+bool DisplayBase::IsRotationRequired(HWLayers *hw_layers) {
+  HWLayersInfo &layer_info = hw_layers->info;
 
+  for (uint32_t i = 0; i < layer_info.count; i++) {
+    Layer& layer = layer_info.stack->layers[layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+    if (hw_rotator_session->hw_block_count) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+const char * DisplayBase::GetName(const LayerComposition &composition) {
+  switch (composition) {
+  case kCompositionGPU:         return "GPU";
+  case kCompositionSDE:         return "SDE";
+  case kCompositionGPUTarget:   return "GPU_TARGET";
+  default:                      return "UNKNOWN";
+  }
+}
+
+const char * DisplayBase::GetName(const LayerBufferFormat &format) {
+  switch (format) {
+  case kFormatARGB8888:                 return "ARGB_8888";
+  case kFormatRGBA8888:                 return "RGBA_8888";
+  case kFormatBGRA8888:                 return "BGRA_8888";
+  case kFormatXRGB8888:                 return "XRGB_8888";
+  case kFormatRGBX8888:                 return "RGBX_8888";
+  case kFormatBGRX8888:                 return "BGRX_8888";
+  case kFormatRGBA5551:                 return "RGBA_5551";
+  case kFormatRGBA4444:                 return "RGBA_4444";
+  case kFormatRGB888:                   return "RGB_888";
+  case kFormatBGR888:                   return "BGR_888";
+  case kFormatRGB565:                   return "RGB_565";
+  case kFormatRGBA8888Ubwc:             return "RGBA_8888_UBWC";
+  case kFormatRGBX8888Ubwc:             return "RGBX_8888_UBWC";
+  case kFormatRGB565Ubwc:               return "RGB_565_UBWC";
+  case kFormatYCbCr420Planar:           return "Y_CB_CR_420";
+  case kFormatYCrCb420Planar:           return "Y_CR_CB_420";
+  case kFormatYCbCr420SemiPlanar:       return "Y_CBCR_420";
+  case kFormatYCrCb420SemiPlanar:       return "Y_CRCB_420";
+  case kFormatYCbCr420SemiPlanarVenus:  return "Y_CBCR_420_VENUS";
+  case kFormatYCbCr422H1V2SemiPlanar:   return "Y_CBCR_422_H1V2";
+  case kFormatYCrCb422H1V2SemiPlanar:   return "Y_CRCB_422_H1V2";
+  case kFormatYCbCr422H2V1SemiPlanar:   return "Y_CBCR_422_H2V1";
+  case kFormatYCrCb422H2V1SemiPlanar:   return "Y_CRCB_422_H2V2";
+  case kFormatYCbCr420SPVenusUbwc:      return "Y_CBCR_420_VENUS_UBWC";
+  case kFormatYCbCr422H2V1Packed:       return "YCBYCR_422_H2V1";
+  default:                              return "UNKNOWN";
+  }
+}
+
+}  // namespace sde
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 6d107a0..0a33011 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -31,18 +31,17 @@
 
 #include "hw_interface.h"
 #include "comp_manager.h"
-#include "buffer_manager.h"
 
 
 namespace sde {
 
-class OfflineCtrl;
+class RotatorCtrl;
 
 class DisplayBase : public DisplayInterface {
  public:
   DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
               HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
-              CompManager *comp_manager, OfflineCtrl *offline_ctrl);
+              CompManager *comp_manager, RotatorCtrl *rotator_ctrl);
   virtual ~DisplayBase() { }
   virtual DisplayError Init();
   virtual DisplayError Deinit();
@@ -64,9 +63,11 @@
  protected:
   // DumpImpl method
   void AppendDump(char *buffer, uint32_t length);
-  void AppendRect(char *buffer, uint32_t length, const char *rect_name, LayerRect *rect);
 
   virtual int GetBestConfig();
+  bool IsRotationRequired(HWLayers *hw_layers);
+  const char * GetName(const LayerComposition &composition);
+  const char * GetName(const LayerBufferFormat &format);
 
   DisplayType display_type_;
   DisplayEventHandler *event_handler_;
@@ -75,11 +76,11 @@
   HWPanelInfo hw_panel_info_;
   BufferSyncHandler *buffer_sync_handler_;
   CompManager *comp_manager_;
-  OfflineCtrl *offline_ctrl_;
+  RotatorCtrl *rotator_ctrl_;
   DisplayState state_;
   Handle hw_device_;
   Handle display_comp_ctx_;
-  Handle display_offline_ctx_;
+  Handle display_rotator_ctx_;
   HWDisplayAttributes *display_attributes_;
   uint32_t num_modes_;
   uint32_t active_mode_index_;
diff --git a/displayengine/libs/core/display_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
index 2b6ba81..65ea21f 100644
--- a/displayengine/libs/core/display_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -35,9 +35,9 @@
 
 DisplayHDMI::DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                          BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                         OfflineCtrl *offline_ctrl)
+                         RotatorCtrl *rotator_ctrl)
   : DisplayBase(kHDMI, event_handler, kDeviceHDMI, buffer_sync_handler, comp_manager,
-                offline_ctrl), hw_info_intf_(hw_info_intf) {
+                rotator_ctrl), hw_info_intf_(hw_info_intf) {
 }
 
 DisplayError DisplayHDMI::Init() {
diff --git a/displayengine/libs/core/display_hdmi.h b/displayengine/libs/core/display_hdmi.h
index fc2be21..ea1b80c 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -26,6 +26,7 @@
 #define __DISPLAY_HDMI_H__
 
 #include "display_base.h"
+#include "dump_impl.h"
 
 namespace sde {
 
@@ -36,7 +37,7 @@
  public:
   DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-              OfflineCtrl *offline_ctrl);
+              RotatorCtrl *rotator_ctrl);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
   virtual DisplayError Prepare(LayerStack *layer_stack);
diff --git a/displayengine/libs/core/display_primary.cpp b/displayengine/libs/core/display_primary.cpp
index 6f705f7..0fa5d2b 100644
--- a/displayengine/libs/core/display_primary.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -35,9 +35,9 @@
 
 DisplayPrimary::DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                                BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                               OfflineCtrl *offline_ctrl)
+                               RotatorCtrl *rotator_ctrl)
   : DisplayBase(kPrimary, event_handler, kDevicePrimary, buffer_sync_handler, comp_manager,
-    offline_ctrl), hw_info_intf_(hw_info_intf) {
+    rotator_ctrl), hw_info_intf_(hw_info_intf) {
 }
 
 DisplayError DisplayPrimary::Init() {
@@ -166,7 +166,7 @@
 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 == kModeCommand) {
+  if (hw_panel_info_.mode == kModeVideo) {
     hw_primary_intf_->SetIdleTimeoutMs(timeout_ms);
   }
 }
@@ -186,7 +186,7 @@
     return kErrorNotSupported;
   }
 
-  switch(mode) {
+  switch (mode) {
   case kModeVideo:
     hw_display_mode = kModeVideo;
     break;
@@ -243,5 +243,10 @@
   }
 }
 
+void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
+  SCOPE_LOCK(locker_);
+  comp_manager_->ProcessThermalEvent(display_comp_ctx_, thermal_level);
+}
+
 }  // namespace sde
 
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index 8ce4f28..1ed28b2 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -26,6 +26,7 @@
 #define __DISPLAY_PRIMARY_H__
 
 #include "display_base.h"
+#include "dump_impl.h"
 
 namespace sde {
 
@@ -36,7 +37,7 @@
  public:
   DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                 OfflineCtrl *offline_ctrl);
+                 RotatorCtrl *rotator_ctrl);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
   virtual DisplayError Prepare(LayerStack *layer_stack);
@@ -61,6 +62,7 @@
   virtual DisplayError VSync(int64_t timestamp);
   virtual DisplayError Blank(bool blank);
   virtual void IdleTimeout();
+  virtual void ThermalEvent(int64_t thermal_level);
 
  private:
   Locker locker_;
diff --git a/displayengine/libs/core/display_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
index a5af9bf..5480f0e 100644
--- a/displayengine/libs/core/display_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -35,9 +35,9 @@
 
 DisplayVirtual::DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                                BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                               OfflineCtrl *offline_ctrl)
+                               RotatorCtrl *rotator_ctrl)
   : DisplayBase(kVirtual, event_handler, kDeviceVirtual, buffer_sync_handler, comp_manager,
-                offline_ctrl), hw_info_intf_(hw_info_intf) {
+                rotator_ctrl), hw_info_intf_(hw_info_intf) {
 }
 
 DisplayError DisplayVirtual::Init() {
diff --git a/displayengine/libs/core/display_virtual.h b/displayengine/libs/core/display_virtual.h
index 419c6ec..f868612 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -26,6 +26,7 @@
 #define __DISPLAY_VIRTUAL_H__
 
 #include "display_base.h"
+#include "dump_impl.h"
 
 namespace sde {
 
@@ -36,7 +37,7 @@
  public:
   DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                 OfflineCtrl *offline_ctrl);
+                 RotatorCtrl *rotator_ctrl);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
   virtual DisplayError Prepare(LayerStack *layer_stack);
diff --git a/displayengine/libs/core/dump_impl.cpp b/displayengine/libs/core/dump_impl.cpp
index a5aca81..f9219f3 100755
--- a/displayengine/libs/core/dump_impl.cpp
+++ b/displayengine/libs/core/dump_impl.cpp
@@ -44,7 +44,7 @@
   for (uint32_t i = 0; i < DumpImpl::dump_count_; i++) {
     DumpImpl::dump_list_[i]->AppendDump(buffer, length);
   }
-  DumpImpl::AppendString(buffer, length, "\n-------------------------------------------\n");
+  DumpImpl::AppendString(buffer, length, "\n\n");
 
   return kErrorNone;
 }
diff --git a/displayengine/libs/core/fb/hw_device.cpp b/displayengine/libs/core/fb/hw_device.cpp
index a0a0fe2..6db1370 100644
--- a/displayengine/libs/core/fb/hw_device.cpp
+++ b/displayengine/libs/core/fb/hw_device.cpp
@@ -183,6 +183,10 @@
   return kErrorNone;
 }
 
+DisplayError HWDevice::DozeSuspend() {
+  return kErrorNone;
+}
+
 DisplayError HWDevice::Standby() {
   return kErrorNone;
 }
@@ -209,14 +213,16 @@
     LayerBuffer *input_buffer = layer.input_buffer;
     HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
     HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+    bool is_rotator_used = (hw_rotator_session->hw_block_count != 0);
     mdp_input_layer mdp_layer;
 
     for (uint32_t count = 0; count < 2; count++) {
       HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
 
-      if (rotate_info->valid) {
-        input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+      if (hw_rotate_info->valid) {
+        input_buffer = &hw_rotator_session->output_buffer;
       }
 
       if (pipe_info->valid) {
@@ -241,18 +247,7 @@
 
         SetRect(pipe_info->src_roi, &mdp_layer.src_rect);
         SetRect(pipe_info->dst_roi, &mdp_layer.dst_rect);
-
-        // Flips will be taken care by rotator, if layer requires 90 rotation. So Dont use MDP for
-        // flip operation, if layer transform is 90.
-        if (!layer.transform.rotation) {
-          if (layer.transform.flip_vertical) {
-            mdp_layer.flags |= MDP_LAYER_FLIP_UD;
-          }
-
-          if (layer.transform.flip_horizontal) {
-            mdp_layer.flags |= MDP_LAYER_FLIP_LR;
-          }
-        }
+        SetMDPFlags(layer, is_rotator_used, &mdp_layer.flags);
 
         mdp_scale_data* mdp_scale = GetScaleDataRef(mdp_layer_count);
 #ifdef USES_SCALAR
@@ -272,8 +267,9 @@
         DLOGV_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d", mdp_buffer.width, mdp_buffer.height,
                  mdp_buffer.format);
         DLOGV_IF(kTagDriverConfig, "plane_alpha %d, zorder %d, blending %d, horz_deci %d, "
-                 "vert_deci %d", mdp_layer.alpha, mdp_layer.z_order, mdp_layer.blend_op,
-                 mdp_layer.horz_deci, mdp_layer.vert_deci);
+                 "vert_deci %d, pipe_id = 0x%x, mdp_flags 0x%x", mdp_layer.alpha, mdp_layer.z_order,
+                 mdp_layer.blend_op, mdp_layer.horz_deci, mdp_layer.vert_deci, mdp_layer.pipe_ndx,
+                 mdp_layer.flags);
         DLOGV_IF(kTagDriverConfig, "src_rect [%d, %d, %d, %d]", mdp_layer.src_rect.x,
                  mdp_layer.src_rect.y, mdp_layer.src_rect.w, mdp_layer.src_rect.h);
         DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_layer.dst_rect.x,
@@ -305,11 +301,11 @@
     mdp_out_layer_.buffer.height = output_buffer->height;
     SetFormat(output_buffer->format, &mdp_out_layer_.buffer.format);
 
-    DLOGI_IF(kTagDriverConfig, "******************* Output buffer Info **********************");
+    DLOGI_IF(kTagDriverConfig, "********************* Output buffer Info ************************");
     DLOGI_IF(kTagDriverConfig, "out_w %d, out_h %d, out_f %d, wb_id %d",
              mdp_out_layer_.buffer.width, mdp_out_layer_.buffer.height,
              mdp_out_layer_.buffer.format, mdp_out_layer_.writeback_ndx);
-    DLOGI_IF(kTagDriverConfig, "*************************************************************");
+    DLOGI_IF(kTagDriverConfig, "*****************************************************************");
   }
 
   mdp_commit.flags |= MDP_VALIDATE_LAYER;
@@ -322,22 +318,22 @@
   return kErrorNone;
 }
 
-void HWDevice::DumpLayerCommit(mdp_layer_commit &layer_commit) {
-  mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
-  mdp_input_layer *mdp_layers = mdp_commit.input_layers;
+void HWDevice::DumpLayerCommit(const mdp_layer_commit &layer_commit) {
+  const mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
+  const mdp_input_layer *mdp_layers = mdp_commit.input_layers;
 
-  DLOGE("mdp_commt: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
+  DLOGE("mdp_commit: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
   DLOGE("left_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.left_roi.x, mdp_commit.left_roi.y,
          mdp_commit.left_roi.w, mdp_commit.left_roi.h);
   DLOGE("right_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.right_roi.x,
          mdp_commit.right_roi.y, mdp_commit.right_roi.w, mdp_commit.right_roi.h);
   for (uint32_t i = 0; i < mdp_commit.input_layer_cnt; i++) {
-    DLOGE("mdp_commt: layer_cnt = %d, pipe_ndx = %x, zorder = %d, flags = %x",
+    DLOGE("mdp_commit: layer_cnt = %d, pipe_ndx = %x, zorder = %d, flags = %x",
           i, mdp_layers[i].pipe_ndx, mdp_layers[i].z_order, mdp_layers[i].flags);
-    mdp_rect &src_rect = mdp_layers[i].src_rect;
+    const mdp_rect &src_rect = mdp_layers[i].src_rect;
     DLOGE("src rect: x = %d, y = %d, w = %d, h = %d",
           src_rect.x, src_rect.y, src_rect.w, src_rect.h);
-    mdp_rect &dst_rect = mdp_layers[i].dst_rect;
+    const mdp_rect &dst_rect = mdp_layers[i].dst_rect;
     DLOGE("dst rect: x = %d, y = %d, w = %d, h = %d",
           dst_rect.x, dst_rect.y, dst_rect.w, dst_rect.h);
   }
@@ -361,13 +357,14 @@
     LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
     HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
     HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
 
     for (uint32_t count = 0; count < 2; count++) {
       HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
 
-      if (rotate_info->valid) {
-        input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+      if (hw_rotate_info->valid) {
+        input_buffer = &hw_rotator_session->output_buffer;
       }
 
       if (pipe_info->valid) {
@@ -416,11 +413,11 @@
 
     mdp_out_layer_.buffer.fence = output_buffer->acquire_fence_fd;
 
-    DLOGI_IF(kTagDriverConfig, "******************* Output buffer Info **********************");
+    DLOGI_IF(kTagDriverConfig, "********************** Output buffer Info ***********************");
     DLOGI_IF(kTagDriverConfig, "out_fd %d, out_offset %d, out_stride %d, acquire_fence %d",
              mdp_out_layer_.buffer.planes[0].fd, mdp_out_layer_.buffer.planes[0].offset,
              mdp_out_layer_.buffer.planes[0].stride,  mdp_out_layer_.buffer.fence);
-    DLOGI_IF(kTagDriverConfig, "*************************************************************");
+    DLOGI_IF(kTagDriverConfig, "*****************************************************************");
   }
 
   mdp_commit.release_fence = -1;
@@ -442,8 +439,9 @@
   for (uint32_t i = 0; i < hw_layer_info.count; i++) {
     uint32_t layer_index = hw_layer_info.index[i];
     LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
-    HWRotateInfo *left_rotate = &hw_layers->config[i].rotates[0];
-    HWRotateInfo *right_rotate = &hw_layers->config[i].rotates[1];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+    HWRotateInfo *left_rotate = &hw_rotator_session->hw_rotate_info[0];
+    HWRotateInfo *right_rotate = &hw_rotator_session->hw_rotate_info[1];
 
     if (!left_rotate->valid && !right_rotate->valid) {
       input_buffer->release_fence_fd = dup(mdp_commit.release_fence);
@@ -451,9 +449,9 @@
     }
 
     for (uint32_t count = 0; count < 2; count++) {
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
-      if (rotate_info->valid) {
-        input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
+      if (hw_rotate_info->valid) {
+        input_buffer = &hw_rotator_session->output_buffer;
         input_buffer->release_fence_fd = dup(mdp_commit.release_fence);
         close_(input_buffer->acquire_fence_fd);
         input_buffer->acquire_fence_fd = -1;
@@ -463,7 +461,7 @@
   DLOGI_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
            device_name_);
   DLOGI_IF(kTagDriverConfig, "retire_fence_fd %d", stack->retire_fence_fd);
-  DLOGI_IF(kTagDriverConfig, "*************************************************************");
+  DLOGI_IF(kTagDriverConfig, "*******************************************************************");
 
   close_(mdp_commit.release_fence);
 
@@ -515,6 +513,7 @@
   case kFormatYCbCr422H2V1Packed:       *target = MDP_YCBYCR_H2V1;       break;
   case kFormatYCbCr420SemiPlanarVenus:  *target = MDP_Y_CBCR_H2V2_VENUS; break;
   case kFormatRGBA8888Ubwc:             *target = MDP_RGBA_8888_UBWC;    break;
+  case kFormatRGBX8888Ubwc:             *target = MDP_RGBX_8888_UBWC;    break;
   case kFormatRGB565Ubwc:               *target = MDP_RGB_565_UBWC;      break;
   case kFormatYCbCr420SPVenusUbwc:      *target = MDP_Y_CBCR_H2V2_UBWC;  break;
   default:
@@ -527,7 +526,7 @@
 
 DisplayError HWDevice::SetStride(HWDeviceType device_type, LayerBufferFormat format,
                                       uint32_t width, uint32_t *target) {
-  // TODO(user): This SetStride function is an workaround to satisfy the driver expectation for
+  // TODO(user): This SetStride function is a workaround to satisfy the driver expectation for
   // rotator and virtual devices. Eventually this will be taken care in the driver.
   if (device_type != kDeviceRotator && device_type != kDeviceVirtual) {
     *target = width;
@@ -540,6 +539,8 @@
   case kFormatBGRA8888:
   case kFormatRGBX8888:
   case kFormatBGRX8888:
+  case kFormatRGBA8888Ubwc:
+  case kFormatRGBX8888Ubwc:
     *target = width * 4;
     break;
   case kFormatRGB888:
@@ -547,7 +548,8 @@
     *target = width * 3;
     break;
   case kFormatRGB565:
-    *target = width * 3;
+  case kFormatRGB565Ubwc:
+    *target = width * 2;
     break;
   case kFormatYCbCr420SemiPlanarVenus:
   case kFormatYCbCr420SPVenusUbwc:
@@ -589,6 +591,35 @@
   target->h = UINT32(source.bottom) - target->y;
 }
 
+void HWDevice::SetMDPFlags(const Layer &layer, const bool &is_rotator_used,
+                           uint32_t *mdp_flags) {
+  LayerBuffer *input_buffer = layer.input_buffer;
+
+  // Flips will be taken care by rotator, if layer uses rotator for downscale/rotation. So ignore
+  // flip flags for MDP.
+  if (!is_rotator_used) {
+    if (layer.transform.flip_vertical) {
+      *mdp_flags |= MDP_LAYER_FLIP_UD;
+    }
+
+    if (layer.transform.flip_horizontal) {
+      *mdp_flags |= MDP_LAYER_FLIP_LR;
+    }
+  }
+
+  if (input_buffer->flags.interlace) {
+    *mdp_flags |= MDP_LAYER_DEINTERLACE;
+  }
+
+  if (input_buffer->flags.secure) {
+    *mdp_flags |= MDP_LAYER_SECURE_SESSION;
+  }
+
+  if (input_buffer->flags.secure_display) {
+    *mdp_flags |= MDP_SECURE_DISPLAY_OVERLAY_SESSION;
+  }
+}
+
 void HWDevice::SyncMerge(const int &fd1, const int &fd2, int *target) {
   if (fd1 >= 0 && fd2 >= 0) {
     buffer_sync_handler_->SyncMerge(fd1, fd2, target);
diff --git a/displayengine/libs/core/fb/hw_device.h b/displayengine/libs/core/fb/hw_device.h
index 07d9e4d..734b69d 100644
--- a/displayengine/libs/core/fb/hw_device.h
+++ b/displayengine/libs/core/fb/hw_device.h
@@ -57,6 +57,7 @@
   DisplayError PowerOn();
   DisplayError PowerOff();
   DisplayError Doze();
+  DisplayError DozeSuspend();
   DisplayError Standby();
   DisplayError Validate(HWLayers *hw_layers);
   DisplayError Commit(HWLayers *hw_layers);
@@ -69,14 +70,15 @@
 
   static const int kMaxStringLength = 1024;
   static const int kNumPhysicalDisplays = 2;
-  static const int kNumDisplayEvents = 3;
+  static const int kNumDisplayEvents = 4;
 
-  void DumpLayerCommit(mdp_layer_commit &layer_commit);
+  void DumpLayerCommit(const mdp_layer_commit &layer_commit);
   DisplayError SetFormat(const LayerBufferFormat &source, uint32_t *target);
   DisplayError SetStride(HWDeviceType device_type, LayerBufferFormat format,
                          uint32_t width, uint32_t *target);
   void SetBlending(const LayerBlending &source, mdss_mdp_blend_op *target);
   void SetRect(const LayerRect &source, mdp_rect *target);
+  void SetMDPFlags(const Layer &layer, const bool &is_rotator_used, uint32_t *mdp_flags);
   void SyncMerge(const int &fd1, const int &fd2, int *target);
 
   // Retrieves HW FrameBuffer Node Index
diff --git a/displayengine/libs/core/fb/hw_hdmi.cpp b/displayengine/libs/core/fb/hw_hdmi.cpp
index bc97cf6..67fa2c6 100644
--- a/displayengine/libs/core/fb/hw_hdmi.cpp
+++ b/displayengine/libs/core/fb/hw_hdmi.cpp
@@ -222,6 +222,8 @@
   display_attributes->y_pixels = timing_mode->active_v;
   display_attributes->v_total = timing_mode->active_v + timing_mode->front_porch_v +
       timing_mode->back_porch_v + timing_mode->pulse_width_v;
+  display_attributes->h_total = timing_mode->active_h + timing_mode->front_porch_h +
+      timing_mode->back_porch_h + timing_mode->pulse_width_h;
   display_attributes->x_dpi = 0;
   display_attributes->y_dpi = 0;
   display_attributes->fps = FLOAT(timing_mode->refresh_rate) / 1000.0f;
@@ -312,6 +314,10 @@
   return HWDevice::Doze();
 }
 
+DisplayError HWHDMI::DozeSuspend() {
+  return HWDevice::DozeSuspend();
+}
+
 DisplayError HWHDMI::Standby() {
   return HWDevice::Standby();
 }
diff --git a/displayengine/libs/core/fb/hw_hdmi.h b/displayengine/libs/core/fb/hw_hdmi.h
index 8fc3c47..322e664 100644
--- a/displayengine/libs/core/fb/hw_hdmi.h
+++ b/displayengine/libs/core/fb/hw_hdmi.h
@@ -46,6 +46,7 @@
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
+  virtual DisplayError DozeSuspend();
   virtual DisplayError Standby();
   virtual DisplayError Validate(HWLayers *hw_layers);
   virtual DisplayError Commit(HWLayers *hw_layers);
diff --git a/displayengine/libs/core/fb/hw_info.cpp b/displayengine/libs/core/fb/hw_info.cpp
index cddb590..7833c3c 100644
--- a/displayengine/libs/core/fb/hw_info.cpp
+++ b/displayengine/libs/core/fb/hw_info.cpp
@@ -123,6 +123,8 @@
         hw_resource->max_bandwidth_high = atol(tokens[1]);
       } else if (!strncmp(tokens[0], "max_mixer_width", strlen("max_mixer_width"))) {
         hw_resource->max_mixer_width = atoi(tokens[1]);
+      } else if (!strncmp(tokens[0], "max_pipe_width", strlen("max_pipe_width"))) {
+        hw_resource->max_pipe_width = atoi(tokens[1]);
       } else if (!strncmp(tokens[0], "max_pipe_bw", strlen("max_pipe_bw"))) {
         hw_resource->max_pipe_bw = atoi(tokens[1]);
       } else if (!strncmp(tokens[0], "max_mdp_clk", strlen("max_mdp_clk"))) {
diff --git a/displayengine/libs/core/fb/hw_primary.cpp b/displayengine/libs/core/fb/hw_primary.cpp
index 3b22054..7b9cbe0 100644
--- a/displayengine/libs/core/fb/hw_primary.cpp
+++ b/displayengine/libs/core/fb/hw_primary.cpp
@@ -75,7 +75,8 @@
   DisplayError error = kErrorNone;
   char node_path[kMaxStringLength] = {0};
   char data[kMaxStringLength] = {0};
-  const char* event_name[kNumDisplayEvents] = {"vsync_event", "show_blank_event", "idle_notify"};
+  const char* event_name[kNumDisplayEvents] = {"vsync_event", "show_blank_event", "idle_notify",
+                                              "msm_fb_thermal_level"};
 
   error = HWDevice::Init();
   if (error != kErrorNone) {
@@ -190,6 +191,8 @@
   display_attributes->y_pixels = var_screeninfo.yres;
   display_attributes->v_total = var_screeninfo.yres + var_screeninfo.lower_margin +
       var_screeninfo.upper_margin + var_screeninfo.vsync_len;
+  display_attributes->h_total = var_screeninfo.xres + var_screeninfo.right_margin +
+      var_screeninfo.left_margin + var_screeninfo.hsync_len;
   display_attributes->x_dpi =
       (FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
   display_attributes->y_dpi =
@@ -222,11 +225,26 @@
     IOCTL_LOGE(FB_BLANK_POWERDOWN, device_type_);
     return kErrorHardware;
   }
+
   return kErrorNone;
 }
 
 DisplayError HWPrimary::Doze() {
-  return HWDevice::Doze();
+  if (ioctl_(device_fd_, FBIOBLANK, FB_BLANK_NORMAL) < 0) {
+    IOCTL_LOGE(FB_BLANK_NORMAL, device_type_);
+    return kErrorHardware;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError HWPrimary::DozeSuspend() {
+  if (ioctl_(device_fd_, FBIOBLANK, FB_BLANK_VSYNC_SUSPEND) < 0) {
+    IOCTL_LOGE(FB_BLANK_VSYNC_SUSPEND, device_type_);
+    return kErrorHardware;
+  }
+
+  return kErrorNone;
 }
 
 DisplayError HWPrimary::Standby() {
@@ -285,7 +303,8 @@
   typedef void (HWPrimary::*EventHandler)(char*);
   EventHandler event_handler[kNumDisplayEvents] = { &HWPrimary::HandleVSync,
                                                     &HWPrimary::HandleBlank,
-                                                    &HWPrimary::HandleIdleTimeout };
+                                                    &HWPrimary::HandleIdleTimeout,
+                                                    &HWPrimary::HandleThermal };
 
   while (!exit_threads_) {
     int error = poll_(poll_fds_, kNumDisplayEvents, -1);
@@ -330,6 +349,17 @@
   event_handler_->IdleTimeout();
 }
 
+void HWPrimary::HandleThermal(char *data) {
+  int64_t thermal_level = 0;
+  if (!strncmp(data, "thermal_level=", strlen("thermal_level="))) {
+    thermal_level = strtoull(data + strlen("thermal_level="), NULL, 0);
+  }
+
+  DLOGI("Received thermal notification with thermal level = %d",thermal_level);
+
+  event_handler_->ThermalEvent(thermal_level);
+}
+
 void HWPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
   char node_path[kMaxStringLength] = {0};
 
diff --git a/displayengine/libs/core/fb/hw_primary.h b/displayengine/libs/core/fb/hw_primary.h
index b008c92..c41f387 100644
--- a/displayengine/libs/core/fb/hw_primary.h
+++ b/displayengine/libs/core/fb/hw_primary.h
@@ -46,6 +46,7 @@
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
+  virtual DisplayError DozeSuspend();
   virtual DisplayError Standby();
   virtual DisplayError Validate(HWLayers *hw_layers);
   virtual DisplayError Commit(HWLayers *hw_layers);
@@ -68,6 +69,7 @@
   void HandleVSync(char *data);
   void HandleBlank(char *data);
   void HandleIdleTimeout(char *data);
+  void HandleThermal(char *data);
 
   pollfd poll_fds_[kNumDisplayEvents];
   pthread_t event_thread_;
diff --git a/displayengine/libs/core/fb/hw_rotator.cpp b/displayengine/libs/core/fb/hw_rotator.cpp
index cc9caa5..c698445 100644
--- a/displayengine/libs/core/fb/hw_rotator.cpp
+++ b/displayengine/libs/core/fb/hw_rotator.cpp
@@ -36,8 +36,8 @@
 
 namespace sde {
 
-DisplayError HWRotatorInterface::Create(HWRotatorInterface **intf,
-                                        BufferSyncHandler *buffer_sync_handler) {
+DisplayError HWRotatorInterface::Create(BufferSyncHandler *buffer_sync_handler,
+                                        HWRotatorInterface **intf) {
   DisplayError error = kErrorNone;
   HWRotator *hw_rotator = NULL;
 
@@ -85,79 +85,98 @@
   return kErrorNone;
 }
 
-DisplayError HWRotator::OpenSession(HWRotateInfo *rotate_info) {
-  LayerBuffer *input_buffer = rotate_info->input_buffer;
-  HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+DisplayError HWRotator::OpenSession(HWRotatorSession *hw_rotator_session) {
+  uint32_t frame_rate = hw_rotator_session->hw_session_config.frame_rate;
+  LayerBufferFormat src_format = hw_rotator_session->hw_session_config.src_format;
+  LayerBufferFormat dst_format = hw_rotator_session->hw_session_config.dst_format;
+  bool rot90 = (hw_rotator_session->transform.rotation == 90.0f);
 
-  ResetRotatorParams();
+  for (uint32_t i = 0; i < hw_rotator_session->hw_block_count; i++) {
+    HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[i];
 
-  STRUCT_VAR(mdp_rotation_config, mdp_rot_config);
-  mdp_rot_config.version = MDP_ROTATION_REQUEST_VERSION_1_0;
-  mdp_rot_config.input.width = input_buffer->width;
-  mdp_rot_config.input.height = input_buffer->height;
-  HWDevice::SetFormat(input_buffer->format, &mdp_rot_config.input.format);
-  mdp_rot_config.output.width = rot_buf_info->output_buffer.width;
-  mdp_rot_config.output.height = rot_buf_info->output_buffer.height;
-  HWDevice::SetFormat(rot_buf_info->output_buffer.format, &mdp_rot_config.output.format);
-  mdp_rot_config.frame_rate = rotate_info->frame_rate;
+    if (!hw_rotate_info->valid) {
+      continue;
+    }
 
-  if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_OPEN, &mdp_rot_config) < 0) {
-    IOCTL_LOGE(MDSS_ROTATION_OPEN, HWDevice::device_type_);
-    return kErrorHardware;
+    uint32_t src_width = UINT32(hw_rotate_info->src_roi.right - hw_rotate_info->src_roi.left);
+    uint32_t src_height =
+        UINT32(hw_rotate_info->src_roi.bottom - hw_rotate_info->src_roi.top);
+
+    uint32_t dst_width = UINT32(hw_rotate_info->dst_roi.right - hw_rotate_info->dst_roi.left);
+    uint32_t dst_height =
+        UINT32(hw_rotate_info->dst_roi.bottom - hw_rotate_info->dst_roi.top);
+
+    STRUCT_VAR(mdp_rotation_config, mdp_rot_config);
+
+    mdp_rot_config.version = MDP_ROTATION_REQUEST_VERSION_1_0;
+    mdp_rot_config.input.width = src_width;
+    mdp_rot_config.input.height = src_height;
+    SetFormat(src_format, &mdp_rot_config.input.format);
+    mdp_rot_config.output.width = dst_width;
+    mdp_rot_config.output.height = dst_height;
+    SetFormat(dst_format, &mdp_rot_config.output.format);
+    mdp_rot_config.frame_rate = frame_rate;
+
+    if (rot90) {
+      mdp_rot_config.flags |= MDP_ROTATION_90;
+    }
+
+    if (ioctl_(device_fd_, MDSS_ROTATION_OPEN, &mdp_rot_config) < 0) {
+      IOCTL_LOGE(MDSS_ROTATION_OPEN, device_type_);
+      return kErrorHardware;
+    }
+
+    hw_rotate_info->rotate_id = mdp_rot_config.session_id;
+
+    DLOGV_IF(kTagDriverConfig, "session_id %d", hw_rotate_info->rotate_id);
   }
 
-  rot_buf_info->session_id = mdp_rot_config.session_id;
-
-  DLOGV_IF(kTagDriverConfig, "session_id %d", rot_buf_info->session_id);
-
   return kErrorNone;
 }
 
-DisplayError HWRotator::CloseSession(int32_t session_id) {
-  if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_CLOSE, (uint32_t)session_id) < 0) {
-    IOCTL_LOGE(MDSS_ROTATION_CLOSE, HWDevice::device_type_);
-    return kErrorHardware;
-  }
+DisplayError HWRotator::CloseSession(HWRotatorSession *hw_rotator_session) {
+  for (uint32_t i = 0; i < hw_rotator_session->hw_block_count; i++) {
+    HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[i];
 
-  DLOGV_IF(kTagDriverConfig, "session_id %d", session_id);
+    if (!hw_rotate_info->valid) {
+      continue;
+    }
+
+    if (ioctl_(device_fd_, MDSS_ROTATION_CLOSE, UINT32(hw_rotate_info->rotate_id)) < 0) {
+      IOCTL_LOGE(MDSS_ROTATION_CLOSE, device_type_);
+      return kErrorHardware;
+    }
+
+    DLOGV_IF(kTagDriverConfig, "session_id %d", hw_rotate_info->rotate_id);
+  }
 
   return kErrorNone;
 }
 
-void HWRotator::SetRotatorCtrlParams(HWLayers *hw_layers) {
+void HWRotator::SetCtrlParams(HWLayers *hw_layers) {
   DLOGV_IF(kTagDriverConfig, "************************* %s Validate Input ************************",
            HWDevice::device_name_);
 
-  ResetRotatorParams();
+  ResetParams();
 
   HWLayersInfo &hw_layer_info = hw_layers->info;
 
   uint32_t &rot_count = mdp_rot_request_.count;
   for (uint32_t i = 0; i < hw_layer_info.count; i++) {
     Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+    bool rot90 = (layer.transform.rotation == 90.0f);
 
-    for (uint32_t count = 0; count < 2; count++) {
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+    for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
 
-      if (rotate_info->valid) {
-        HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+      if (hw_rotate_info->valid) {
         mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
-        bool rot90 = (layer.transform.rotation == 90.0f);
 
-        if (rot90) {
-          mdp_rot_item->flags |= MDP_ROTATION_90;
-        }
+        SetMDPFlags(layer, &mdp_rot_item->flags);
 
-        if (layer.transform.flip_horizontal) {
-          mdp_rot_item->flags |= MDP_ROTATION_FLIP_LR;
-        }
-
-        if (layer.transform.flip_vertical) {
-          mdp_rot_item->flags |= MDP_ROTATION_FLIP_UD;
-        }
-
-        HWDevice::SetRect(rotate_info->src_roi, &mdp_rot_item->src_rect);
-        HWDevice::SetRect(rotate_info->dst_roi, &mdp_rot_item->dst_rect);
+        SetRect(hw_rotate_info->src_roi, &mdp_rot_item->src_rect);
+        SetRect(hw_rotate_info->dst_roi, &mdp_rot_item->dst_rect);
 
         // TODO(user): Need to assign the writeback id and pipe id  returned from resource manager.
         mdp_rot_item->pipe_idx = 0;
@@ -165,11 +184,13 @@
 
         mdp_rot_item->input.width = layer.input_buffer->width;
         mdp_rot_item->input.height = layer.input_buffer->height;
-        HWDevice::SetFormat(layer.input_buffer->format, &mdp_rot_item->input.format);
+        SetFormat(layer.input_buffer->format, &mdp_rot_item->input.format);
 
-        mdp_rot_item->output.width = rot_buf_info->output_buffer.width;
-        mdp_rot_item->output.height = rot_buf_info->output_buffer.height;
-        HWDevice::SetFormat(rot_buf_info->output_buffer.format, &mdp_rot_item->output.format);
+        mdp_rot_item->output.width = hw_rotator_session->output_buffer.width;
+        mdp_rot_item->output.height = hw_rotator_session->output_buffer.height;
+        SetFormat(hw_rotator_session->output_buffer.format, &mdp_rot_item->output.format);
+
+        mdp_rot_item->session_id = hw_rotate_info->rotate_id;
 
         rot_count++;
 
@@ -179,8 +200,9 @@
                  mdp_rot_item->input.width, mdp_rot_item->input.height, mdp_rot_item->input.format,
                  mdp_rot_item->output.width, mdp_rot_item->output.height,
                  mdp_rot_item->output.format);
-        DLOGV_IF(kTagDriverConfig, "pipe_id %d, wb_id %d, rot_flag %d", mdp_rot_item->pipe_idx,
-                 mdp_rot_item->wb_idx, mdp_rot_item->flags);
+        DLOGV_IF(kTagDriverConfig, "pipe_id 0x%x, wb_id %d, rot_flag 0x%x, session_id %d",
+                 mdp_rot_item->pipe_idx, mdp_rot_item->wb_idx, mdp_rot_item->flags,
+                 mdp_rot_item->session_id);
         DLOGV_IF(kTagDriverConfig, "src_rect [%d, %d, %d, %d]", mdp_rot_item->src_rect.x,
                  mdp_rot_item->src_rect.y, mdp_rot_item->src_rect.w, mdp_rot_item->src_rect.h);
         DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_rot_item->dst_rect.x,
@@ -191,7 +213,7 @@
   }
 }
 
-void HWRotator::SetRotatorBufferParams(HWLayers *hw_layers) {
+void HWRotator::SetBufferParams(HWLayers *hw_layers) {
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t rot_count = 0;
 
@@ -201,26 +223,26 @@
 
   for (uint32_t i = 0; i < hw_layer_info.count; i++) {
     Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
 
-    for (uint32_t count = 0; count < 2; count++) {
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+    for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
 
-      if (rotate_info->valid) {
-        HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+      if (hw_rotate_info->valid) {
         mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
 
         mdp_rot_item->input.planes[0].fd = layer.input_buffer->planes[0].fd;
         mdp_rot_item->input.planes[0].offset = layer.input_buffer->planes[0].offset;
-        HWDevice::SetStride(HWDevice::device_type_, layer.input_buffer->format,
-                            layer.input_buffer->width, &mdp_rot_item->input.planes[0].stride);
+        SetStride(device_type_, layer.input_buffer->format, layer.input_buffer->width,
+                  &mdp_rot_item->input.planes[0].stride);
         mdp_rot_item->input.plane_count = 1;
         mdp_rot_item->input.fence = layer.input_buffer->acquire_fence_fd;
 
-        mdp_rot_item->output.planes[0].fd = rot_buf_info->output_buffer.planes[0].fd;
-        mdp_rot_item->output.planes[0].offset = rot_buf_info->output_buffer.planes[0].offset;
-        HWDevice::SetStride(HWDevice::device_type_, rot_buf_info->output_buffer.format,
-                            rot_buf_info->output_buffer.planes[0].stride,
-                            &mdp_rot_item->output.planes[0].stride);
+        mdp_rot_item->output.planes[0].fd = hw_rotator_session->output_buffer.planes[0].fd;
+        mdp_rot_item->output.planes[0].offset = hw_rotator_session->output_buffer.planes[0].offset;
+        SetStride(device_type_, hw_rotator_session->output_buffer.format,
+                  hw_rotator_session->output_buffer.planes[0].stride,
+                  &mdp_rot_item->output.planes[0].stride);
         mdp_rot_item->output.plane_count = 1;
         mdp_rot_item->output.fence = -1;
 
@@ -242,8 +264,29 @@
   }
 }
 
+ void HWRotator::SetMDPFlags(const Layer &layer, uint32_t *mdp_flags) {
+  LayerTransform transform = layer.transform;
+  bool rot90 = (transform.rotation == 90.0f);
+
+  if (rot90) {
+    *mdp_flags |= MDP_ROTATION_90;
+  }
+
+  if (transform.flip_horizontal) {
+    *mdp_flags |= MDP_ROTATION_FLIP_LR;
+  }
+
+  if (transform.flip_vertical) {
+    *mdp_flags |= MDP_ROTATION_FLIP_UD;
+  }
+
+  if (layer.input_buffer->flags.secure) {
+    *mdp_flags |= MDP_ROTATION_SECURE;
+  }
+}
+
 DisplayError HWRotator::Validate(HWLayers *hw_layers) {
-  SetRotatorCtrlParams(hw_layers);
+  SetCtrlParams(hw_layers);
 
   mdp_rot_request_.flags = MDSS_ROTATION_REQUEST_VALIDATE;
   if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_REQUEST, &mdp_rot_request_) < 0) {
@@ -258,9 +301,9 @@
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t rot_count = 0;
 
-  SetRotatorCtrlParams(hw_layers);
+  SetCtrlParams(hw_layers);
 
-  SetRotatorBufferParams(hw_layers);
+  SetBufferParams(hw_layers);
 
   mdp_rot_request_.flags &= ~MDSS_ROTATION_REQUEST_VALIDATE;
   if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_REQUEST, &mdp_rot_request_) < 0) {
@@ -270,20 +313,20 @@
 
   for (uint32_t i = 0; i < hw_layer_info.count; i++) {
     Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
 
     layer.input_buffer->release_fence_fd = -1;
 
-    for (uint32_t count = 0; count < 2; count++) {
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+    for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+      HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
 
-      if (rotate_info->valid) {
-        HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+      if (hw_rotate_info->valid) {
         mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
 
         HWDevice::SyncMerge(layer.input_buffer->release_fence_fd, dup(mdp_rot_item->output.fence),
                             &layer.input_buffer->release_fence_fd);
 
-        rot_buf_info->output_buffer.acquire_fence_fd = dup(mdp_rot_item->output.fence);
+        hw_rotator_session->output_buffer.acquire_fence_fd = dup(mdp_rot_item->output.fence);
 
         close_(mdp_rot_item->output.fence);
         rot_count++;
@@ -294,7 +337,7 @@
   return kErrorNone;
 }
 
-void HWRotator::ResetRotatorParams() {
+void HWRotator::ResetParams() {
   memset(&mdp_rot_request_, 0, sizeof(mdp_rot_request_));
   memset(&mdp_rot_layers_, 0, sizeof(mdp_rot_layers_));
 
diff --git a/displayengine/libs/core/fb/hw_rotator.h b/displayengine/libs/core/fb/hw_rotator.h
index 6e7727d..b78b657 100644
--- a/displayengine/libs/core/fb/hw_rotator.h
+++ b/displayengine/libs/core/fb/hw_rotator.h
@@ -44,15 +44,16 @@
   explicit HWRotator(BufferSyncHandler *buffer_sync_handler);
   virtual DisplayError Open();
   virtual DisplayError Close();
-  virtual DisplayError OpenSession(HWRotateInfo *hw_layers);
-  virtual DisplayError CloseSession(int32_t session_id);
+  virtual DisplayError OpenSession(HWRotatorSession *hw_session_info);
+  virtual DisplayError CloseSession(HWRotatorSession *hw_session_info);
   virtual DisplayError Validate(HWLayers *hw_layers);
   virtual DisplayError Commit(HWLayers *hw_layers);
 
  private:
-  void ResetRotatorParams();
-  void SetRotatorCtrlParams(HWLayers *hw_layers);
-  void SetRotatorBufferParams(HWLayers *hw_layers);
+  void ResetParams();
+  void SetCtrlParams(HWLayers *hw_layers);
+  void SetBufferParams(HWLayers *hw_layers);
+  void SetMDPFlags(const Layer &layer, uint32_t *rot_flags);
 
   struct mdp_rotation_request mdp_rot_request_;
   struct mdp_rotation_item mdp_rot_layers_[kMaxSDELayers * 2];  // split panel (left + right)
diff --git a/displayengine/libs/core/fb/hw_virtual.cpp b/displayengine/libs/core/fb/hw_virtual.cpp
index 81b31d0..374cc45 100644
--- a/displayengine/libs/core/fb/hw_virtual.cpp
+++ b/displayengine/libs/core/fb/hw_virtual.cpp
@@ -110,6 +110,10 @@
   return HWDevice::Doze();
 }
 
+DisplayError HWVirtual::DozeSuspend() {
+  return HWDevice::DozeSuspend();
+}
+
 DisplayError HWVirtual::Standby() {
   return HWDevice::Standby();
 }
diff --git a/displayengine/libs/core/fb/hw_virtual.h b/displayengine/libs/core/fb/hw_virtual.h
index fb7c784..509f1c5 100644
--- a/displayengine/libs/core/fb/hw_virtual.h
+++ b/displayengine/libs/core/fb/hw_virtual.h
@@ -46,6 +46,7 @@
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
+  virtual DisplayError DozeSuspend();
   virtual DisplayError Standby();
   virtual DisplayError Validate(HWLayers *hw_layers);
   virtual DisplayError Commit(HWLayers *hw_layers);
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index e8e0c63..36cb85e 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -43,33 +43,65 @@
   kHWBlockMax
 };
 
-struct HWBufferInfo : public BufferInfo {
-  LayerBuffer output_buffer;
-  int session_id;
-  uint32_t slot;
+struct HWSessionConfig {
+  uint32_t src_width;
+  uint32_t src_height;
+  LayerBufferFormat src_format;
+  uint32_t dst_width;
+  uint32_t dst_height;
+  LayerBufferFormat dst_format;
+  uint32_t buffer_count;
+  bool secure;
+  bool cache;
+  uint32_t frame_rate;
 
-  HWBufferInfo() : session_id(-1), slot(0) { }
+  HWSessionConfig()
+    : src_width(0), src_height(0), src_format(kFormatInvalid), dst_width(0), dst_height(0),
+      dst_format(kFormatInvalid), buffer_count(0), secure(false), cache(false), frame_rate(0) { }
+
+  bool operator != (const HWSessionConfig &input_config) const {
+    if ((src_width != input_config.src_width) || (src_height != input_config.src_height) ||
+        (src_format != input_config.src_format) || (dst_width != input_config.dst_width) ||
+        (dst_height != input_config.dst_height) || (dst_format != input_config.dst_format) ||
+        (buffer_count != input_config.buffer_count) || (secure != input_config.secure) ||
+        (cache != input_config.cache) || (frame_rate != input_config.frame_rate)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  bool operator == (const HWSessionConfig &input_config) const {
+    return !(operator != (input_config));
+  }
 };
 
 struct HWRotateInfo {
-  LayerBuffer *input_buffer;
   uint32_t pipe_id;
   LayerRect src_roi;
   LayerRect dst_roi;
-  LayerBufferFormat dst_format;
   HWBlockType writeback_id;
-  float downscale_ratio;
-  HWBufferInfo hw_buffer_info;
   bool valid;
-  uint32_t frame_rate;
+  int rotate_id;
 
-  HWRotateInfo() : input_buffer(NULL), pipe_id(0), dst_format(kFormatInvalid),
-                   writeback_id(kHWWriteback0), downscale_ratio(1.0f), valid(false),
-                   frame_rate(0) { }
+  HWRotateInfo()
+    : pipe_id(0), writeback_id(kHWWriteback0), valid(false), rotate_id(-1) { }
 
   void Reset() { *this = HWRotateInfo(); }
 };
 
+struct HWRotatorSession {
+  HWRotateInfo hw_rotate_info[kMaxRotatePerLayer];
+  uint32_t hw_block_count;  // number of rotator hw blocks used by rotator session
+  float downscale_ratio;
+  LayerTransform transform;
+  HWSessionConfig hw_session_config;
+  LayerBuffer output_buffer;
+  int session_id;
+
+  HWRotatorSession() : hw_block_count(0), downscale_ratio(1.0f), session_id(-1) { }
+};
+
 struct HWPipeInfo {
   uint32_t pipe_id;
   LayerRect src_roi;
@@ -79,8 +111,8 @@
   bool valid;
   uint32_t z_order;
 
-  HWPipeInfo() : pipe_id(0), horizontal_decimation(0), vertical_decimation(0), valid(false),
-                 z_order(0) { }
+  HWPipeInfo()
+    : pipe_id(0), horizontal_decimation(0), vertical_decimation(0), valid(false), z_order(0) { }
 
   void Reset() { *this = HWPipeInfo(); }
 };
@@ -89,10 +121,9 @@
   bool use_non_dma_pipe;  // set by client
   HWPipeInfo left_pipe;  // pipe for left side of output
   HWPipeInfo right_pipe;  // pipe for right side of output
-  uint32_t num_rotate;  // number of rotate
-  HWRotateInfo rotates[kMaxRotatePerLayer];  // rotation for the buffer
+  HWRotatorSession hw_rotator_session;
 
-  HWLayerConfig() : use_non_dma_pipe(false), num_rotate(0) { }
+  HWLayerConfig() : use_non_dma_pipe(false) { }
 
   void Reset() { *this = HWLayerConfig(); }
 };
@@ -100,11 +131,6 @@
 struct HWLayers {
   HWLayersInfo info;
   HWLayerConfig config[kMaxSDELayers];
-  int closed_session_ids[kMaxSDELayers * 2];  // split panel (left + right)
-
-  HWLayers() { memset(closed_session_ids, -1, sizeof(closed_session_ids)); }
-
-  void Reset() { *this = HWLayers(); }
 };
 
 struct HWDisplayAttributes : DisplayConfigVariableInfo {
@@ -123,6 +149,7 @@
   virtual DisplayError VSync(int64_t timestamp) = 0;
   virtual DisplayError Blank(bool blank) = 0;
   virtual void IdleTimeout() = 0;
+  virtual void ThermalEvent(int64_t thermal_level) = 0;
  protected:
   virtual ~HWEventHandler() { }
 };
@@ -140,6 +167,7 @@
   virtual DisplayError PowerOn() = 0;
   virtual DisplayError PowerOff() = 0;
   virtual DisplayError Doze() = 0;
+  virtual DisplayError DozeSuspend() = 0;
   virtual DisplayError Standby() = 0;
   virtual DisplayError Validate(HWLayers *hw_layers) = 0;
   virtual DisplayError Commit(HWLayers *hw_layers) = 0;
diff --git a/displayengine/libs/core/hw_rotator_interface.h b/displayengine/libs/core/hw_rotator_interface.h
index 35876d6..0de5d52 100644
--- a/displayengine/libs/core/hw_rotator_interface.h
+++ b/displayengine/libs/core/hw_rotator_interface.h
@@ -30,15 +30,16 @@
 class BufferSyncHandler;
 struct HWRotateInfo;
 struct HWLayers;
+struct HWRotatorSession;
 
 class HWRotatorInterface {
  public:
-  static DisplayError Create(HWRotatorInterface **intf, BufferSyncHandler *buffer_sync_handler);
+  static DisplayError Create(BufferSyncHandler *buffer_sync_handler, HWRotatorInterface **intf);
   static DisplayError Destroy(HWRotatorInterface *intf);
   virtual DisplayError Open() = 0;
   virtual DisplayError Close() = 0;
-  virtual DisplayError OpenSession(HWRotateInfo *rotate_info) = 0;
-  virtual DisplayError CloseSession(int32_t session_id) = 0;
+  virtual DisplayError OpenSession(HWRotatorSession *hw_rotator_session) = 0;
+  virtual DisplayError CloseSession(HWRotatorSession *hw_rotator_session) = 0;
   virtual DisplayError Validate(HWLayers *hw_layers) = 0;
   virtual DisplayError Commit(HWLayers *hw_layers) = 0;
 
diff --git a/displayengine/libs/core/offline_ctrl.cpp b/displayengine/libs/core/offline_ctrl.cpp
deleted file mode 100644
index b7d5eef..0000000
--- a/displayengine/libs/core/offline_ctrl.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-* 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:
-*    * Redistributions of source code must retain the above copyright notice, this list of
-*      conditions and the following disclaimer.
-*    * Redistributions in binary form must reproduce the above copyright notice, this list of
-*      conditions and the following disclaimer in the documentation and/or other materials provided
-*      with the distribution.
-*    * Neither the name of The Linux Foundation nor the names of its contributors may be used to
-*      endorse or promote products derived from this software without specific prior written
-*      permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-* NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <utils/constants.h>
-#include <utils/debug.h>
-
-#include "offline_ctrl.h"
-#include "hw_rotator_interface.h"
-#include <core/buffer_sync_handler.h>
-#include "hw_interface.h"
-
-#define __CLASS__ "OfflineCtrl"
-
-namespace sde {
-
-// TODO(user): Move this offline controller under composition manager like other modules
-// [resource manager]. Implement session management and buffer management in offline controller.
-OfflineCtrl::OfflineCtrl() : hw_rotator_intf_(NULL), hw_rotator_present_(false) {
-}
-
-DisplayError OfflineCtrl::Init(BufferSyncHandler *buffer_sync_handler) {
-  DisplayError error = kErrorNone;
-
-  error = HWRotatorInterface::Create(&hw_rotator_intf_, buffer_sync_handler);
-  if (error != kErrorNone) {
-    if (hw_rotator_intf_) {
-      HWRotatorInterface::Destroy(hw_rotator_intf_);
-    }
-    return error;
-  }
-
-  error = hw_rotator_intf_->Open();
-  if (error != kErrorNone) {
-    DLOGW("Failed to open rotator device");
-  } else {
-    hw_rotator_present_ = true;
-  }
-
-  return kErrorNone;
-}
-
-DisplayError OfflineCtrl::Deinit() {
-  DisplayError error = kErrorNone;
-
-  error = hw_rotator_intf_->Close();
-  if (error != kErrorNone) {
-    DLOGW("Failed to close rotator device");
-    return error;
-  }
-  hw_rotator_present_ = false;
-  HWRotatorInterface::Destroy(hw_rotator_intf_);
-
-  return kErrorNone;
-}
-
-DisplayError OfflineCtrl::RegisterDisplay(DisplayType type, Handle *display_ctx) {
-  DisplayOfflineContext *disp_offline_ctx = new DisplayOfflineContext();
-  if (disp_offline_ctx == NULL) {
-    return kErrorMemory;
-  }
-
-  disp_offline_ctx->display_type = type;
-  *display_ctx = disp_offline_ctx;
-
-  return kErrorNone;
-}
-
-void OfflineCtrl::UnregisterDisplay(Handle display_ctx) {
-  DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
-  delete disp_offline_ctx;
-  disp_offline_ctx = NULL;
-}
-
-
-DisplayError OfflineCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
-  DisplayError error = kErrorNone;
-
-  DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
-  disp_offline_ctx->pending_rot_commit = false;
-
-  if (!hw_rotator_present_ && IsRotationRequired(hw_layers)) {
-    DLOGV_IF(kTagOfflineCtrl, "No Rotator device found");
-    return kErrorHardware;
-  }
-
-  error = CloseRotatorSession(hw_layers);
-  if (error != kErrorNone) {
-    DLOGE("Close rotator session failed for display %d", disp_offline_ctx->display_type);
-    return error;
-  }
-
-
-  if (IsRotationRequired(hw_layers)) {
-    error = OpenRotatorSession(hw_layers);
-    if (error != kErrorNone) {
-      DLOGE("Open rotator session failed for display %d", disp_offline_ctx->display_type);
-      return error;
-    }
-
-    error = hw_rotator_intf_->Validate(hw_layers);
-    if (error != kErrorNone) {
-      DLOGE("Rotator validation failed for display %d", disp_offline_ctx->display_type);
-      return error;
-    }
-    disp_offline_ctx->pending_rot_commit = true;
-  }
-
-  return kErrorNone;
-}
-
-DisplayError OfflineCtrl::Commit(Handle display_ctx, HWLayers *hw_layers) {
-  DisplayError error = kErrorNone;
-
-  DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
-  if (disp_offline_ctx->pending_rot_commit) {
-    error = hw_rotator_intf_->Commit(hw_layers);
-    if (error != kErrorNone) {
-      DLOGE("Rotator commit failed for display %d", disp_offline_ctx->display_type);
-      return error;
-    }
-    disp_offline_ctx->pending_rot_commit = false;
-  }
-
-  return kErrorNone;
-}
-
-DisplayError OfflineCtrl::OpenRotatorSession(HWLayers *hw_layers) {
-  HWLayersInfo &hw_layer_info = hw_layers->info;
-  DisplayError error = kErrorNone;
-
-  for (uint32_t i = 0; i < hw_layer_info.count; i++) {
-    Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
-    bool rot90 = (layer.transform.rotation == 90.0f);
-
-    for (uint32_t count = 0; count < 2; count++) {
-      HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
-      HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
-
-      if (!rotate_info->valid || rot_buf_info->session_id >= 0) {
-        continue;
-      }
-
-      rotate_info->input_buffer = layer.input_buffer;
-      rotate_info->frame_rate = layer.frame_rate;
-
-      error = hw_rotator_intf_->OpenSession(rotate_info);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-  }
-
-  return kErrorNone;
-}
-
-DisplayError OfflineCtrl::CloseRotatorSession(HWLayers *hw_layers) {
-  DisplayError error = kErrorNone;
-  uint32_t i = 0;
-
-  while (hw_layers->closed_session_ids[i] >= 0) {
-    error = hw_rotator_intf_->CloseSession(hw_layers->closed_session_ids[i]);
-    if (error != kErrorNone) {
-      return error;
-    }
-    hw_layers->closed_session_ids[i++] = -1;
-  }
-
-  return kErrorNone;
-}
-
-bool OfflineCtrl::IsRotationRequired(HWLayers *hw_layers) {
-  HWLayersInfo &layer_info = hw_layers->info;
-
-  for (uint32_t i = 0; i < layer_info.count; i++) {
-    Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-
-    HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-    if (rotate->valid) {
-      return true;
-    }
-
-    rotate = &hw_layers->config[i].rotates[1];
-    if (rotate->valid) {
-      return true;
-    }
-  }
-  return false;
-}
-
-}  // namespace sde
-
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index ea90dfb..c5a8a06 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -42,21 +42,22 @@
   }
 }
 
-void ResManager::RotationConfig(LayerBufferFormat format, const LayerTransform &transform,
-                                const float &downscale, LayerRect *src_rect,
+void ResManager::RotationConfig(const Layer &layer, const float &downscale, LayerRect *src_rect,
                                 struct HWLayerConfig *layer_config, uint32_t *rotate_count) {
-  HWRotateInfo *rotate = &layer_config->rotates[0];
+  HWRotatorSession *hw_rotator_session = &layer_config->hw_rotator_session;
+  HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[0];
   float src_width = src_rect->right - src_rect->left;
   float src_height = src_rect->bottom - src_rect->top;
-  bool rot90 = IsRotationNeeded(transform.rotation);
+  bool rot90 = IsRotationNeeded(layer.transform.rotation);
+  bool is_opaque = (layer.blending == kBlendingOpaque);
   LayerRect dst_rect;
   // Rotate output is a temp buffer, always output to the top left corner for saving memory
   dst_rect.top = 0.0f;
   dst_rect.left = 0.0f;
 
-  rotate->downscale_ratio = downscale;
+  hw_rotator_session->downscale_ratio = downscale;
   uint32_t align_x, align_y;
-  GetAlignFactor(format, &align_x, &align_y);
+  GetAlignFactor(layer.input_buffer->format, &align_x, &align_y);
 
   // downscale when doing rotation
   if (rot90) {
@@ -79,20 +80,17 @@
     dst_rect.bottom = src_height / downscale;
   }
 
-  rotate->src_roi = *src_rect;
-  rotate->valid = true;
-  rotate->dst_roi = dst_rect;
+  hw_rotate_info->src_roi = *src_rect;
+  hw_rotate_info->valid = true;
+  hw_rotate_info->dst_roi = dst_rect;
 
-  // Set WHF for Rotator output
-  LayerBufferFormat ouput_format;
-  SetRotatorOutputFormat(format, false /* bwc */, rot90, downscale, &ouput_format);
-  HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-  hw_buffer_info->buffer_config.format = ouput_format;
-  hw_buffer_info->buffer_config.width = UINT32(rotate->dst_roi.right);
-  hw_buffer_info->buffer_config.height = UINT32(rotate->dst_roi.bottom);
+  LayerBufferFormat *output_format = &hw_rotator_session->output_buffer.format;
+  SetRotatorOutputFormat(layer.input_buffer->format, is_opaque, rot90, (downscale > 1.0f),
+                         output_format);
 
   *src_rect = dst_rect;
-  layer_config->num_rotate = 1;
+  hw_rotator_session->hw_block_count = 1;
+  hw_rotator_session->transform = layer.transform;
   (*rotate_count)++;
 }
 
@@ -124,7 +122,7 @@
   // For perf/power optimization, even if "always_src_split" is enabled, use 2 pipes only if:
   // 1. Source width is greater than split_left (left_mixer_width)
   // 2. Pipe clock exceeds the mixer clock
-  if ((src_width > kMaxSourcePipeWidth) || (dst_width > kMaxSourcePipeWidth) ||
+  if ((src_width > hw_res_info_.max_pipe_width) || (dst_width > hw_res_info_.max_pipe_width) ||
       (display_resource_ctx->display_attributes.always_src_split &&
       ((src_width > left_mixer_width) || (pipe_clock > mixer_clock)))) {
     SplitRect(transform.flip_horizontal, src_rect, dst_rect, &left_pipe->src_roi,
@@ -167,11 +165,11 @@
   scissor.bottom = FLOAT(display_attributes.y_pixels);
   bool crop_right_valid = false;
 
-  if (IsValidRect(scissor)) {
+  if (IsValid(scissor)) {
     crop_right_valid = CalculateCropRects(scissor, transform, &crop_right, &dst_right);
   }
 
-  if (crop_left_valid && (crop_left.right - crop_left.left) > kMaxSourcePipeWidth) {
+  if (crop_left_valid && (crop_left.right - crop_left.left) > hw_res_info_.max_pipe_width) {
     if (crop_right_valid) {
       DLOGV_IF(kTagResources, "Need more than 2 pipes: left width = %.0f, right width = %.0f",
                crop_left.right - crop_left.left, crop_right.right - crop_right.left);
@@ -183,7 +181,8 @@
     left_pipe->valid = true;
     right_pipe->valid = true;
     crop_right_valid = true;
-  } else if (crop_right_valid && (crop_right.right - crop_right.left) > kMaxSourcePipeWidth) {
+  } else if (crop_right_valid &&
+             (crop_right.right - crop_right.left) > hw_res_info_.max_pipe_width) {
     if (crop_left_valid) {
       DLOGV_IF(kTagResources, "Need more than 2 pipes: left width = %.0f, right width = %.0f",
                crop_left.right - crop_left.left, crop_right.right - crop_right.left);
@@ -236,12 +235,11 @@
 
   for (uint32_t i = 0; i < layer_info.count; i++) {
     Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-    float rot_scale = 1.0f;
-    if (!IsValidDimension(layer.src_rect, layer.dst_rect)) {
-      DLOGV_IF(kTagResources, "Input is invalid");
-      LogRect(kTagResources, "input layer src_rect", layer.src_rect);
-      LogRect(kTagResources, "input layer dst_rect", layer.dst_rect);
-      return kErrorNotSupported;
+    float rotator_scale_factor = 1.0f;
+
+    error = ValidateLayerDimensions(layer);
+    if (error != kErrorNone) {
+      return error;
     }
 
     LayerRect scissor, src_rect, dst_rect;
@@ -253,6 +251,9 @@
     struct HWLayerConfig *layer_config = &hw_layers->config[i];
     HWPipeInfo &left_pipe = layer_config->left_pipe;
     HWPipeInfo &right_pipe = layer_config->right_pipe;
+    HWRotatorSession *hw_rotator_session = &layer_config->hw_rotator_session;
+    LayerTransform transform = layer.transform;
+    bool rotated90 = IsRotationNeeded(transform.rotation);
 
     if (!CalculateCropRects(scissor, layer.transform, &src_rect, &dst_rect)) {
       layer_config->Reset();
@@ -264,23 +265,32 @@
     uint32_t align_x, align_y;
     GetAlignFactor(layer.input_buffer->format, &align_x, &align_y);
     if (align_x > 1 || align_y > 1) {
-      NormalizeRect(align_x, align_y, &src_rect);
+      Normalize(align_x, align_y, &src_rect);
     }
 
-    if (ValidateScaling(layer, src_rect, dst_rect, &rot_scale)) {
-      return kErrorNotSupported;
+    error = ValidateDimensions(src_rect, dst_rect, rotated90);
+    if (error != kErrorNone) {
+      return error;
+    }
+
+    error = ValidateScaling(src_rect, dst_rect, rotated90);
+    if (error != kErrorNone) {
+      return error;
+    }
+
+    error = GetRotatorScaleFactor(src_rect, dst_rect, rotated90, &rotator_scale_factor);
+    if (error != kErrorNone) {
+      return error;
     }
 
     // config rotator first
     for (uint32_t j = 0; j < kMaxRotatePerLayer; j++) {
-      layer_config->rotates[j].Reset();
+      hw_rotator_session->hw_rotate_info[j].Reset();
     }
-    layer_config->num_rotate = 0;
+    hw_rotator_session->hw_block_count = 0;
 
-    LayerTransform transform = layer.transform;
-    if (IsRotationNeeded(transform.rotation) || UINT32(rot_scale) != 1) {
-      RotationConfig(layer.input_buffer->format, layer.transform, rot_scale, &src_rect,
-                     layer_config, rotate_count);
+    if (rotated90 || UINT32(rotator_scale_factor) != 1) {
+      RotationConfig(layer, rotator_scale_factor, &src_rect, layer_config, rotate_count);
       // rotator will take care of flipping, reset tranform
       transform = LayerTransform();
     }
@@ -304,21 +314,21 @@
 
     DLOGV_IF(kTagResources, "==== layer = %d, left pipe valid = %d ====",
              i, layer_config->left_pipe.valid);
-    LogRect(kTagResources, "input layer src_rect", layer.src_rect);
-    LogRect(kTagResources, "input layer dst_rect", layer.dst_rect);
-    for (uint32_t k = 0; k < layer_config->num_rotate; k++) {
-      DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rot_scale);
-      LogRect(kTagResources, "rotate src", layer_config->rotates[k].src_roi);
-      LogRect(kTagResources, "rotate dst", layer_config->rotates[k].dst_roi);
+    Log(kTagResources, "input layer src_rect", layer.src_rect);
+    Log(kTagResources, "input layer dst_rect", layer.dst_rect);
+    for (uint32_t k = 0; k < hw_rotator_session->hw_block_count; k++) {
+      DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rotator_scale_factor);
+      Log(kTagResources, "rotate src", hw_rotator_session->hw_rotate_info[k].src_roi);
+      Log(kTagResources, "rotate dst", hw_rotator_session->hw_rotate_info[k].dst_roi);
     }
 
-    LogRect(kTagResources, "cropped src_rect", src_rect);
-    LogRect(kTagResources, "cropped dst_rect", dst_rect);
-    LogRect(kTagResources, "left pipe src", layer_config->left_pipe.src_roi);
-    LogRect(kTagResources, "left pipe dst", layer_config->left_pipe.dst_roi);
+    Log(kTagResources, "cropped src_rect", src_rect);
+    Log(kTagResources, "cropped dst_rect", dst_rect);
+    Log(kTagResources, "left pipe src", layer_config->left_pipe.src_roi);
+    Log(kTagResources, "left pipe dst", layer_config->left_pipe.dst_roi);
     if (hw_layers->config[i].right_pipe.valid) {
-      LogRect(kTagResources, "right pipe src", layer_config->right_pipe.src_roi);
-      LogRect(kTagResources, "right pipe dst", layer_config->right_pipe.dst_roi);
+      Log(kTagResources, "right pipe src", layer_config->right_pipe.src_roi);
+      Log(kTagResources, "right pipe dst", layer_config->right_pipe.dst_roi);
     }
     // set z_order, left_pipe should always be valid
     left_pipe.z_order = z_order;
@@ -344,91 +354,6 @@
   return error;
 }
 
-DisplayError ResManager::ValidateScaling(const Layer &layer, const LayerRect &crop,
-                                         const LayerRect &dst, float *rot_scale) {
-  bool rotated90 = IsRotationNeeded(layer.transform.rotation) && (rot_scale != NULL);
-  float crop_width = rotated90 ? crop.bottom - crop.top : crop.right - crop.left;
-  float crop_height = rotated90 ? crop.right - crop.left : crop.bottom - crop.top;
-  float dst_width = dst.right - dst.left;
-  float dst_height = dst.bottom - dst.top;
-
-  if ((dst_width < 1.0f) || (dst_height < 1.0f)) {
-    DLOGV_IF(kTagResources, "dst ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
-             dst_width, dst_height, dst.right, dst.bottom);
-    return kErrorNotSupported;
-  }
-
-  if ((crop_width < 1.0f) || (crop_height < 1.0f)) {
-    DLOGV_IF(kTagResources, "src ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
-             crop_width, crop_height, crop.right, crop.bottom);
-    return kErrorNotSupported;
-  }
-
-  if ((UINT32(crop_width - dst_width) == 1) || (UINT32(crop_height - dst_height) == 1)) {
-    DLOGV_IF(kTagResources, "One pixel downscaling detected crop_w = %.0f, dst_w = %.0f, " \
-             "crop_h = %.0f, dst_h = %.0f", crop_width, dst_width, crop_height, dst_height);
-    return kErrorNotSupported;
-  }
-
-  float scale_x = crop_width / dst_width;
-  float scale_y = crop_height / dst_height;
-  uint32_t rot_scale_local = 1;
-
-  if ((UINT32(scale_x) > 1) || (UINT32(scale_y) > 1)) {
-    float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
-
-    if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling &&
-        rot_scale && !IsMacroTileFormat(layer.input_buffer)) {
-      float scale_min = MIN(scale_x, scale_y);
-      float scale_max = MAX(scale_x, scale_y);
-      // use rotator to downscale when over the pipe scaling ability
-      if (UINT32(scale_min) >= 2 && scale_max > max_scale_down) {
-        // downscaling ratio needs be the same for both direction, use the smaller one.
-        rot_scale_local = 1 << UINT32(ceilf(log2f(scale_min / max_scale_down)));
-        if (rot_scale_local > kMaxRotateDownScaleRatio)
-          rot_scale_local = kMaxRotateDownScaleRatio;
-        scale_x /= FLOAT(rot_scale_local);
-        scale_y /= FLOAT(rot_scale_local);
-      }
-      *rot_scale = FLOAT(rot_scale_local);
-    }
-
-    if (hw_res_info_.has_decimation && !property_setting_.disable_decimation &&
-               !IsMacroTileFormat(layer.input_buffer)) {
-      max_scale_down *= FLOAT(kMaxDecimationDownScaleRatio);
-    }
-
-    if (scale_x > max_scale_down || scale_y > max_scale_down) {
-      DLOGV_IF(kTagResources,
-               "Scaling down is over the limit: is_tile = %d, scale_x = %.0f, scale_y = %.0f, " \
-               "crop_w = %.0f, dst_w = %.0f, has_deci = %d, disable_deci = %d, rot_scale = %d",
-               IsMacroTileFormat(layer.input_buffer), scale_x, scale_y, crop_width, dst_width,
-               hw_res_info_.has_decimation, property_setting_.disable_decimation, rot_scale_local);
-      return kErrorNotSupported;
-    }
-  }
-
-  float max_scale_up = FLOAT(hw_res_info_.max_scale_up);
-  if (UINT32(scale_x) < 1 && scale_x > 0.0f) {
-    if ((1.0f / scale_x) > max_scale_up) {
-      DLOGV_IF(kTagResources, "Scaling up is over limit scale_x = %f", 1.0f / scale_x);
-      return kErrorNotSupported;
-    }
-  }
-
-  if (UINT32(scale_y) < 1 && scale_y > 0.0f) {
-    if ((1.0f / scale_y) > max_scale_up) {
-      DLOGV_IF(kTagResources, "Scaling up is over limit scale_y = %f", 1.0f / scale_y);
-      return kErrorNotSupported;
-    }
-  }
-
-  DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rot_scale = %d",
-           scale_x, scale_y, rot_scale_local);
-
-  return kErrorNone;
-}
-
 void ResManager::CalculateCut(const LayerTransform &transform, float *left_cut_ratio,
                               float *top_cut_ratio, float *right_cut_ratio,
                               float *bottom_cut_ratio) {
@@ -507,30 +432,247 @@
   crop_top += crop_height * top_cut_ratio;
   crop_right -= crop_width * right_cut_ratio;
   crop_bottom -= crop_height * bottom_cut_ratio;
-  NormalizeRect(1, 1, crop);
-  NormalizeRect(1, 1, dst);
-  if (IsValidRect(*crop) && IsValidRect(*dst))
+  Normalize(1, 1, crop);
+  Normalize(1, 1, dst);
+  if (IsValid(*crop) && IsValid(*dst))
     return true;
   else
     return false;
 }
 
-bool ResManager::IsValidDimension(const LayerRect &src, const LayerRect &dst) {
-  // Make sure source in integral
-  if (src.left - roundf(src.left)     ||
-      src.top - roundf(src.top)       ||
-      src.right - roundf(src.right)   ||
-      src.bottom - roundf(src.bottom)) {
-    DLOGV_IF(kTagResources, "Input ROI is not integral");
-    return false;
+DisplayError ResManager::ValidateLayerDimensions(const Layer &layer) {
+  const LayerRect &src = layer.src_rect;
+  const LayerRect &dst = layer.dst_rect;
+  LayerBuffer *input_buffer = layer.input_buffer;
+
+  if (!IsValid(src) || !IsValid(dst)) {
+    Log(kTagResources, "input layer src_rect", src);
+    Log(kTagResources, "input layer dst_rect", dst);
+    return kErrorNotSupported;
   }
 
-  if (src.left > src.right || src.top > src.bottom || dst.left > dst.right ||
-      dst.top > dst.bottom) {
-    return false;
-  } else {
-    return true;
+  // Make sure source in integral only if it is a non secure layer.
+  if (!input_buffer->flags.secure && (src.left - roundf(src.left) || src.top - roundf(src.top) ||
+      src.right - roundf(src.right) || src.bottom - roundf(src.bottom))) {
+    DLOGV_IF(kTagResources, "Input ROI is not integral");
+    return kErrorNotSupported;
   }
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::ValidateDimensions(const LayerRect &crop, const LayerRect &dst,
+                                            bool rotated90) {
+  float crop_width = 0.0f, crop_height = 0.0f, dst_width = 0.0f, dst_height = 0.0f;
+
+  DisplayError error = GetCropAndDestination(crop, dst, rotated90, &crop_width, &crop_height,
+                                             &dst_width, &dst_height);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  if ((dst_width < 1.0f) || (dst_height < 1.0f)) {
+    DLOGV_IF(kTagResources, "dst ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
+             dst_width, dst_height, dst.right, dst.bottom);
+    return kErrorNotSupported;
+  }
+
+  if ((crop_width < 1.0f) || (crop_height < 1.0f)) {
+    DLOGV_IF(kTagResources, "src ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
+             crop_width, crop_height, crop.right, crop.bottom);
+    return kErrorNotSupported;
+  }
+
+  if ((UINT32(crop_width - dst_width) == 1) || (UINT32(crop_height - dst_height) == 1)) {
+    DLOGV_IF(kTagResources, "One pixel downscaling detected crop_w = %.0f, dst_w = %.0f, " \
+             "crop_h = %.0f, dst_h = %.0f", crop_width, dst_width, crop_height, dst_height);
+    return kErrorNotSupported;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::ValidatePipeParams(HWPipeInfo *pipe_info) {
+  DisplayError error = kErrorNone;
+
+  const LayerRect &src_rect = pipe_info->src_roi;
+  const LayerRect &dst_rect = pipe_info->dst_roi;
+
+  error = ValidateDimensions(src_rect, dst_rect, false /* rotated90 */);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = ValidateScaling(src_rect, dst_rect, false /* rotated90 */);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::ValidateScaling(const LayerRect &crop, const LayerRect &dst,
+                                         bool rotated90) {
+  DisplayError error = kErrorNone;
+
+  float scale_x = 1.0f;
+  float scale_y = 1.0f;
+
+  error = GetScaleFactor(crop, dst, rotated90, &scale_x, &scale_y);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = ValidateDownScaling(scale_x, scale_y);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = ValidateUpScaling(scale_x, scale_y);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::ValidateDownScaling(float scale_x, float scale_y) {
+  if ((UINT32(scale_x) > 1) || (UINT32(scale_y) > 1)) {
+    float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
+    float rotator_scale_factor = 1.0f;
+
+    if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling) {
+      rotator_scale_factor =  GetRotatorScaleFactor(scale_x, scale_y);
+      scale_x /= rotator_scale_factor;
+      scale_y /= rotator_scale_factor;
+
+      DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rotator_scale_factor = %d",
+               scale_x, scale_y, rotator_scale_factor);
+    }
+
+    if (hw_res_info_.has_decimation && !property_setting_.disable_decimation) {
+      max_scale_down *= FLOAT(kMaxDecimationDownScaleRatio);
+    }
+
+    if (scale_x > max_scale_down || scale_y > max_scale_down) {
+      DLOGV_IF(kTagResources,
+               "Scaling down is over the limit: scale_x = %.0f, scale_y = %.0f, " \
+               "has_deci = %d, disable_deci = %d, rotator_scale_factor= %.0f",
+               scale_x, scale_y, hw_res_info_.has_decimation, property_setting_.disable_decimation,
+               rotator_scale_factor);
+      return kErrorNotSupported;
+    }
+  }
+
+  DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f", scale_x, scale_y);
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::ValidateUpScaling(float scale_x, float scale_y) {
+  float max_scale_up = FLOAT(hw_res_info_.max_scale_up);
+
+  if (UINT32(scale_x) < 1 && scale_x > 0.0f) {
+    if ((1.0f / scale_x) > max_scale_up) {
+      DLOGV_IF(kTagResources, "Scaling up is over limit scale_x = %f", 1.0f / scale_x);
+      return kErrorNotSupported;
+    }
+  }
+
+  if (UINT32(scale_y) < 1 && scale_y > 0.0f) {
+    if ((1.0f / scale_y) > max_scale_up) {
+      DLOGV_IF(kTagResources, "Scaling up is over limit scale_y = %f", 1.0f / scale_y);
+      return kErrorNotSupported;
+    }
+  }
+
+  DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f", scale_x, scale_y);
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::GetCropAndDestination(const LayerRect &crop, const LayerRect &dst,
+                                               const bool rotated90, float *crop_width,
+                                               float *crop_height, float *dst_width,
+                                               float *dst_height) {
+  if (!IsValid(crop)) {
+    Log(kTagResources, "Invalid crop rect", crop);
+    return kErrorNotSupported;
+  }
+
+  if (!IsValid(dst)) {
+    Log(kTagResources, "Invalid dst rect", dst);
+    return kErrorNotSupported;
+  }
+
+  *crop_width = crop.right - crop.left;
+  *crop_height = crop.bottom - crop.top;
+  if (rotated90) {
+    Swap(*crop_width, *crop_height);
+  }
+
+  *dst_width = dst.right - dst.left;
+  *dst_height = dst.bottom - dst.top;
+
+  return kErrorNone;
+}
+
+DisplayError ResManager::GetRotatorScaleFactor(const LayerRect &crop, const LayerRect &dst,
+                                               bool rotated90, float *rotator_scale_factor) {
+  DisplayError error = kErrorNone;
+
+  float scale_x = 1.0f;
+  float scale_y = 1.0f;
+
+  if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling) {
+    error = GetScaleFactor(crop, dst, rotated90, &scale_x, &scale_y);
+    if (error != kErrorNone) {
+      return error;
+    }
+
+    *rotator_scale_factor =  GetRotatorScaleFactor(scale_x, scale_y);
+  } else {
+    *rotator_scale_factor = 1.0f;
+  }
+
+  return kErrorNone;
+}
+
+float ResManager::GetRotatorScaleFactor(float scale_x, float scale_y) {
+  float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
+  float scale_min = MIN(scale_x, scale_y);
+  float scale_max = MAX(scale_x, scale_y);
+  uint32_t rotator_scale_factor = 1;
+
+  // use rotator to downscale when over the pipe scaling ability
+  if (UINT32(scale_min) >= 2 && scale_max > max_scale_down) {
+    // downscaling ratio needs be the same for both direction, use the smaller one.
+    rotator_scale_factor = 1 << UINT32(ceilf(log2f(scale_min / max_scale_down)));
+    if (rotator_scale_factor > kMaxRotateDownScaleRatio) {
+      rotator_scale_factor = kMaxRotateDownScaleRatio;
+    }
+  }
+
+  DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rotator_scale_factor = %d",
+           scale_x, scale_y, rotator_scale_factor);
+
+  return FLOAT(rotator_scale_factor);
+}
+
+DisplayError ResManager::GetScaleFactor(const LayerRect &crop, const LayerRect &dst,
+                                        bool rotated90, float *scale_x, float *scale_y) {
+  float crop_width = 1.0f, crop_height = 1.0f, dst_width = 1.0f, dst_height = 1.0f;
+
+  DisplayError error = GetCropAndDestination(crop, dst, rotated90, &crop_width, &crop_height,
+                                             &dst_width, &dst_height);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  *scale_x = crop_width / dst_width;
+  *scale_y = crop_height / dst_height;
+
+  return kErrorNone;
 }
 
 DisplayError ResManager::SetDecimationFactor(HWPipeInfo *pipe) {
@@ -612,12 +754,12 @@
   // 2. Normalize source and destination rect of a layer to multiple of 1.
   // TODO(user) Check buffer format and check if rotate is involved.
 
-  NormalizeRect(align_x, align_y, &left_pipe->src_roi);
-  NormalizeRect(1, 1, &left_pipe->dst_roi);
+  Normalize(align_x, align_y, &left_pipe->src_roi);
+  Normalize(1, 1, &left_pipe->dst_roi);
 
   if (right_pipe->valid) {
-    NormalizeRect(align_x, align_y, &right_pipe->src_roi);
-    NormalizeRect(1, 1, &right_pipe->dst_roi);
+    Normalize(align_x, align_y, &right_pipe->src_roi);
+    Normalize(1, 1, &right_pipe->dst_roi);
   }
 
   if (right_pipe->valid) {
@@ -629,13 +771,14 @@
     }
     right_pipe->dst_roi.left = left_pipe->dst_roi.right;
   }
-  error = ValidateScaling(layer, left_pipe->src_roi, left_pipe->dst_roi, NULL);
+
+  error = ValidatePipeParams(left_pipe);
   if (error != kErrorNone) {
     goto PipeConfigExit;
   }
 
   if (right_pipe->valid) {
-    error = ValidateScaling(layer, right_pipe->src_roi, right_pipe->dst_roi, NULL);
+    error = ValidatePipeParams(right_pipe);
   }
 PipeConfigExit:
   if (error != kErrorNone) {
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index 09b64ab..261155f 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -39,28 +39,19 @@
     buffer_allocator_(NULL), buffer_sync_handler_(NULL) {
 }
 
-DisplayError ResManager::Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
-                              BufferSyncHandler *buffer_sync_handler) {
-  hw_res_info_ = hw_res_info;
-
-  buffer_sync_handler_ = buffer_sync_handler;
-
-  if (!hw_res_info_.max_mixer_width)
-    hw_res_info_.max_mixer_width = kMaxSourcePipeWidth;
-
-  buffer_allocator_ = buffer_allocator;
-
-  buffer_sync_handler_ = buffer_sync_handler;
-
+DisplayError ResManager::Init(const HWResourceInfo &hw_res_info) {
   DisplayError error = kErrorNone;
+  uint32_t num_pipe = 0;
 
-  num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
+  num_pipe = hw_res_info.num_vig_pipe + hw_res_info.num_rgb_pipe + hw_res_info.num_dma_pipe;
 
-  if (num_pipe_ > kPipeIdMax) {
-    DLOGE("Number of pipe is over the limit! %d", num_pipe_);
+  if (num_pipe > kPipeIdMax) {
+    DLOGE("Number of pipe is over the limit! %d", num_pipe);
     return kErrorParameters;
   }
 
+  num_pipe_ = num_pipe;
+  hw_res_info_ = hw_res_info;
   // Init pipe info
   vig_pipes_ = &src_pipes_[0];
   rgb_pipes_ = &src_pipes_[hw_res_info_.num_vig_pipe];
@@ -122,6 +113,8 @@
 #ifdef USES_SCALAR
   ScalarHelper::GetInstance()->Init();
 #endif
+
+  max_system_bw_ = FLOAT(hw_res_info_.max_bandwidth_high);
   return kErrorNone;
 }
 
@@ -133,7 +126,7 @@
 }
 
 DisplayError ResManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
-                                         Handle *display_ctx) {
+                                         const HWPanelInfo &hw_panel_info, Handle *display_ctx) {
   DisplayError error = kErrorNone;
 
   HWBlockType hw_block_id = kHWBlockMax;
@@ -170,13 +163,7 @@
     return kErrorMemory;
   }
 
-  display_resource_ctx->buffer_manager = new BufferManager(buffer_allocator_, buffer_sync_handler_);
-  if (display_resource_ctx->buffer_manager == NULL) {
-    delete display_resource_ctx;
-    display_resource_ctx = NULL;
-    return kErrorMemory;
-  }
-
+  display_resource_ctx->hw_panel_info_ = hw_panel_info;
   hw_block_ctx_[hw_block_id].is_in_use = true;
 
   display_resource_ctx->display_attributes = attributes;
@@ -312,6 +299,7 @@
   for (uint32_t i = 0; i < layer_info.count; i++) {
     Layer &layer = layer_info.stack->layers[layer_info.index[i]];
     struct HWLayerConfig &layer_config = hw_layers->config[i];
+    HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
     bool use_non_dma_pipe = layer_config.use_non_dma_pipe;
 
     // TODO(user): set this from comp_manager
@@ -319,8 +307,8 @@
       use_non_dma_pipe = true;
     }
 
-    for (uint32_t j = 0; j < layer_config.num_rotate; j++) {
-      AssignRotator(&layer_config.rotates[j], &rotate_count);
+    for (uint32_t j = 0; j < hw_rotator_session.hw_block_count; j++) {
+      AssignRotator(&hw_rotator_session.hw_rotate_info[j], &rotate_count);
     }
 
     HWPipeInfo *pipe_info = &layer_config.left_pipe;
@@ -403,12 +391,6 @@
     goto CleanupOnError;
   }
 
-  error = AllocRotatorBuffer(display_ctx, hw_layers);
-  if (error != kErrorNone) {
-    DLOGV_IF(kTagResources, "Rotator buffer allocation failed");
-    goto CleanupOnError;
-  }
-
   return kErrorNone;
 
 CleanupOnError:
@@ -445,7 +427,9 @@
     right_pipe_bw[i] = right_pipe->valid ? GetPipeBw(display_ctx, right_pipe, bpp) : 0;
 
     if ((left_pipe_bw[i] > max_pipe_bw) || (right_pipe_bw[i] > max_pipe_bw)) {
-      DLOGV_IF(kTagResources, "Pipe bandwidth exceeds limit for layer index = %d", i);
+      DLOGV_IF(kTagResources, "Pipe bandwidth exceeds limit for layer index=%d !" \
+               " left_pipe_bw=%f, right_pipe_bw=%f, max_pipe_bw=%f",
+               i, left_pipe_bw[i], right_pipe_bw[i], max_pipe_bw);
       return false;
     }
 
@@ -466,9 +450,14 @@
     last_primary_bw_ = left_mixer_bw + right_mixer_bw;
   }
 
-  // If system has Video mode panel, use max_bandwidth_low, else use max_bandwidth_high
-  if ((display_bw + bw_claimed_) > (hw_res_info_.max_bandwidth_low / 1000000)) {
-    DLOGV_IF(kTagResources, "Overlap bandwidth exceeds limit!");
+  // If system has Video mode panel, then bw limit is max_bandwidth_low
+  if (display_ctx->hw_panel_info_.mode == kModeVideo) {
+    max_system_bw_ = FLOAT(hw_res_info_.max_bandwidth_low);
+  }
+
+  if ((display_bw + bw_claimed_) > (max_system_bw_ / 1000000)) {
+    DLOGV_IF(kTagResources, "Overlap bandwidth: %f exceeds system limit: %f (GBps)!",
+             (display_bw + bw_claimed_), (max_system_bw_ / 1000000));
     return false;
   }
 
@@ -480,7 +469,8 @@
 
   // Apply fudge factor to consider in-efficieny
   if ((system_clk * hw_res_info_.clk_fudge_factor) > max_sde_clk) {
-    DLOGV_IF(kTagResources, "Clock requirement exceeds limit!");
+    DLOGV_IF(kTagResources, "Clock requirement: %f exceeds system limit: %f (MHz)!",
+             (system_clk * hw_res_info_.clk_fudge_factor), max_sde_clk);
     return false;
   }
 
@@ -512,6 +502,15 @@
   // (v_total / v_active) * (v_active / dst_h)
   bw *= FLOAT(display_attributes.v_total) / dst_h;
 
+  // Bandwidth is the rate at which data needs to be fetched from source to MDP (bytes/time).
+  // On Video mode panel, there is no transfer of data from MDP to panel in horizontal blanking
+  // time (hBP + hFP + hPW). So MDP gets this extra time to fetch data from source. But on the
+  // Command mode panel, data gets transferred from MDP to panel during blanking time as well,
+  // which means MDP needs to fetch the data faster. So pipe bandwidth needs to be adjusted.
+  if (display_ctx->hw_panel_info_.mode == kModeCommand) {
+    bw *= FLOAT(display_attributes.h_total) / FLOAT(display_attributes.x_pixels);
+  }
+
   // Bandwidth in GBps
   return (bw / 1000000000.0f);
 }
@@ -642,84 +641,8 @@
   }
 }
 
-DisplayError ResManager::AllocRotatorBuffer(Handle display_ctx, HWLayers *hw_layers) {
-  DisplayResourceContext *display_resource_ctx =
-                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
-  DisplayError error = kErrorNone;
-
-  BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
-  HWLayersInfo &layer_info = hw_layers->info;
-
-  // TODO(user): Do session management during prepare and allocate buffer and associate that with
-  // the session during commit.
-  buffer_manager->Start();
-
-  for (uint32_t i = 0; i < layer_info.count; i++) {
-    Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-    HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
-    if (rotate->valid) {
-      HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-      // Allocate two rotator output buffers by default for double buffering.
-      hw_buffer_info->buffer_config.buffer_count = 2;
-      hw_buffer_info->buffer_config.secure = layer.input_buffer->flags.secure;
-
-      error = buffer_manager->GetNextBuffer(hw_buffer_info);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-
-    rotate = &hw_layers->config[i].rotates[1];
-    if (rotate->valid) {
-      HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-      // Allocate two rotator output buffers by default for double buffering.
-      hw_buffer_info->buffer_config.buffer_count = 2;
-      hw_buffer_info->buffer_config.secure = layer.input_buffer->flags.secure;
-
-      error = buffer_manager->GetNextBuffer(hw_buffer_info);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-  }
-  buffer_manager->Stop(hw_layers->closed_session_ids);
-
-  return kErrorNone;
-}
-
 DisplayError ResManager::PostPrepare(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
-  DisplayResourceContext *display_resource_ctx =
-                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
-  DisplayError error = kErrorNone;
-
-  BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
-  HWLayersInfo &layer_info = hw_layers->info;
-
-  for (uint32_t i = 0; i < layer_info.count; i++) {
-    Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-    HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
-    if (rotate->valid) {
-      HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-
-      error = buffer_manager->SetSessionId(hw_buffer_info->slot, hw_buffer_info->session_id);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-
-    rotate = &hw_layers->config[i].rotates[1];
-    if (rotate->valid) {
-      HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-
-      error = buffer_manager->SetSessionId(hw_buffer_info->slot, hw_buffer_info->session_id);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-  }
 
   return kErrorNone;
 }
@@ -779,35 +702,6 @@
   }
   display_resource_ctx->frame_start = false;
 
-  BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
-  HWLayersInfo &layer_info = hw_layers->info;
-
-  for (uint32_t i = 0; i < layer_info.count; i++) {
-    Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-    HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
-    if (rotate->valid) {
-      HWBufferInfo *rot_buf_info = &rotate->hw_buffer_info;
-
-      error = buffer_manager->SetReleaseFd(rot_buf_info->slot,
-                                                rot_buf_info->output_buffer.release_fence_fd);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-
-    rotate = &hw_layers->config[i].rotates[1];
-    if (rotate->valid) {
-      HWBufferInfo *rot_buf_info = &rotate->hw_buffer_info;
-
-      error = buffer_manager->SetReleaseFd(rot_buf_info->slot,
-                                                rot_buf_info->output_buffer.release_fence_fd);
-      if (error != kErrorNone) {
-        return error;
-      }
-    }
-  }
-
   return kErrorNone;
 }
 
@@ -1113,38 +1007,95 @@
   }
 }
 
-void ResManager::SetRotatorOutputFormat(const LayerBufferFormat &input_format, bool bwc, bool rot90,
-                                        bool downscale, LayerBufferFormat *output_format) {
+void ResManager::SetRotatorOutputFormat(const LayerBufferFormat &input_format,
+                                        const bool &is_opaque, const bool &rot90,
+                                        const bool &downscale, LayerBufferFormat *output_format) {
+  // Initialize the output format with input format by default.
   *output_format = input_format;
 
   switch (input_format) {
-  case kFormatRGB565:
-    if (rot90)
-      *output_format = kFormatRGB888;
-    break;
+  case kFormatARGB8888:
   case kFormatRGBA8888:
-    if (bwc)
-      *output_format = kFormatBGRA8888;
+    if (is_opaque) {
+      *output_format = kFormatRGB888;
+    }
     break;
-  case kFormatYCbCr420SemiPlanarVenus:
+  case kFormatBGRA8888:
+    if (is_opaque) {
+      *output_format = kFormatBGR888;
+    }
+    break;
+  case kFormatBGRX8888:
+    *output_format = kFormatBGR888;
+    break;
+  case kFormatXRGB8888:
+  case kFormatRGBX8888:
+    *output_format = kFormatRGB888;
+    break;
+  case kFormatYCrCb420SemiPlanar:
   case kFormatYCbCr420SemiPlanar:
-    if (rot90)
-      *output_format = kFormatYCrCb420SemiPlanar;
-    break;
-  case kFormatYCbCr420SPVenusUbwc:
-    if (downscale)
-      *output_format = kFormatYCrCb420SemiPlanar;
-    break;
-  case kFormatYCbCr420Planar:
-  case kFormatYCrCb420Planar:
-    *output_format = kFormatYCrCb420SemiPlanar;
+  case kFormatYCbCr420SemiPlanarVenus:
+    *output_format = kFormatYCbCr420SemiPlanar;
     break;
   default:
     break;
   }
 
-  DLOGV_IF(kTagResources, "Input format %x, Output format = %x, rot90 %d", input_format,
-           *output_format, rot90);
+  if (downscale) {
+    switch (input_format) {
+    case kFormatRGBA8888Ubwc:
+      *output_format = is_opaque ? kFormatRGB888 : kFormatRGBA8888;
+      break;
+    case kFormatRGBX8888Ubwc:
+      *output_format = kFormatRGB888;
+      break;
+    case kFormatRGB565Ubwc:
+      *output_format = kFormatRGB565;
+      break;
+    case kFormatYCbCr420SPVenusUbwc:
+      *output_format = kFormatYCbCr420SemiPlanar;
+      break;
+    default:
+      break;
+    }
+  } else {
+    if (hw_res_info_.has_ubwc) {
+      switch (input_format) {
+      case kFormatRGBA8888:
+        *output_format = kFormatRGBA8888Ubwc;
+        break;
+      case kFormatRGBX8888:
+        *output_format = kFormatRGBX8888Ubwc;
+        break;
+      case kFormatRGB565:
+        *output_format = kFormatRGB565Ubwc;
+        break;
+      case kFormatYCrCb420SemiPlanar:
+      case kFormatYCbCr420SemiPlanar:
+      case kFormatYCbCr420SemiPlanarVenus:
+        *output_format = kFormatYCbCr420SPVenusUbwc;
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  if (rot90) {
+    if (input_format == kFormatYCbCr422H2V1SemiPlanar) {
+      *output_format = kFormatYCbCr422H1V2SemiPlanar;
+    } else if (input_format == kFormatYCbCr422H1V2SemiPlanar) {
+      *output_format = kFormatYCbCr422H2V1SemiPlanar;
+    } else if (input_format == kFormatYCrCb422H2V1SemiPlanar) {
+      *output_format = kFormatYCrCb422H1V2SemiPlanar;
+    } else if (input_format == kFormatYCrCb422H1V2SemiPlanar) {
+      *output_format = kFormatYCrCb422H2V1SemiPlanar;
+    }
+  }
+
+  DLOGV_IF(kTagResources, "Input format = %x, Output format = %x, rot90 = %d, ubwc = %d,"
+           "downscale = %d", input_format, *output_format, rot90, hw_res_info_.has_ubwc,
+           downscale);
 
   return;
 }
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index 7f78b29..7fa5260 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -31,18 +31,16 @@
 
 #include "hw_interface.h"
 #include "dump_impl.h"
-#include "buffer_manager.h"
 
 namespace sde {
 
 class ResManager : public DumpImpl {
  public:
   ResManager();
-  DisplayError Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
-                    BufferSyncHandler *buffer_sync_handler);
+  DisplayError Init(const HWResourceInfo &hw_res_info);
   DisplayError Deinit();
   DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
-                               Handle *display_ctx);
+                               const HWPanelInfo &hw_panel_info, Handle *display_ctx);
   DisplayError UnregisterDisplay(Handle display_ctx);
   DisplayError Start(Handle display_ctx);
   DisplayError Stop(Handle display_ctx);
@@ -51,6 +49,7 @@
   DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
   void Purge(Handle display_ctx);
   DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
+  DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst, bool rotate90);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
@@ -87,7 +86,6 @@
 
   // todo: retrieve all these from kernel
   enum {
-    kMaxSourcePipeWidth = 2048,
     kMaxInterfaceWidth = 2048,
     kMaxRotateDownScaleRatio = 8,
     kMaxDecimationDownScaleRatio = 8,
@@ -117,9 +115,9 @@
 
   struct DisplayResourceContext {
     HWDisplayAttributes display_attributes;
-    BufferManager *buffer_manager;
     DisplayType display_type;
     HWBlockType hw_block_id;
+    HWPanelInfo hw_panel_info_;
     uint64_t frame_count;
     int32_t session_id;  // applicable for virtual display sessions only
     uint32_t rotate_count;
@@ -128,13 +126,6 @@
 
     DisplayResourceContext() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1),
                     rotate_count(0), frame_start(false), max_mixer_stages(0) { }
-
-    ~DisplayResourceContext() {
-      if (buffer_manager) {
-        delete buffer_manager;
-        buffer_manager = NULL;
-      }
-    }
   };
 
   struct HWBlockContext {
@@ -173,8 +164,6 @@
                                   const LayerTransform &transform, const LayerRect &src_rect,
                                   const LayerRect &dst_rect, HWLayerConfig *layer_config,
                                   uint32_t align_x);
-  DisplayError ValidateScaling(const Layer &layer, const LayerRect &crop,
-                               const LayerRect &dst, float *rot_scale);
   DisplayError SrcSplitConfig(DisplayResourceContext *display_resource_ctx,
                               const LayerTransform &transform, const LayerRect &src_rect,
                               const LayerRect &dst_rect, HWLayerConfig *layer_config,
@@ -183,7 +172,19 @@
                     float *right_cut_ratio, float *bottom_cut_ratio);
   bool CalculateCropRects(const LayerRect &scissor, const LayerTransform &transform,
                           LayerRect *crop, LayerRect *dst);
-  bool IsValidDimension(const LayerRect &src, const LayerRect &dst);
+  DisplayError ValidateLayerDimensions(const Layer &layer);
+  DisplayError ValidateDimensions(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+  DisplayError ValidatePipeParams(HWPipeInfo *pipe_info);
+  DisplayError ValidateDownScaling(float scale_x, float scale_y);
+  DisplayError ValidateUpScaling(float scale_x, float scale_y);
+  DisplayError GetCropAndDestination(const LayerRect &crop, const LayerRect &dst,
+                                     bool rotate90, float *crop_width, float *crop_height,
+                                     float *dst_width, float *dst_height);
+  DisplayError GetRotatorScaleFactor(const LayerRect &crop, const LayerRect &dst,
+                                     bool rotate90, float *rotator_scale_factor);
+  float GetRotatorScaleFactor(float scale_x, float scale_y);
+  DisplayError GetScaleFactor(const LayerRect &crop, const LayerRect &dst, bool rotate90,
+                              float *scale_x, float *scale_y);
   bool CheckBandwidth(DisplayResourceContext *display_ctx, HWLayers *hw_layers);
   float GetPipeBw(DisplayResourceContext *display_ctx, HWPipeInfo *pipe, float bpp);
   float GetClockForPipe(DisplayResourceContext *display_ctx, HWPipeInfo *pipe);
@@ -196,21 +197,20 @@
   bool IsMacroTileFormat(const LayerBuffer *buffer) { return buffer->flags.macro_tile; }
   bool IsRotationNeeded(float rotation)
          { return (UINT32(rotation) == 90 || UINT32(rotation) == 270); }
-  void RotationConfig(LayerBufferFormat format, const LayerTransform &transform,
-                      const float &downscale, LayerRect *src_rect,
-                      struct HWLayerConfig *layer_config, uint32_t *rotate_count);
+  void RotationConfig(const Layer &layer, const float &downscale, LayerRect *src_rect,
+                      HWLayerConfig *layer_config, uint32_t *rotate_count);
   DisplayError AcquireRotator(DisplayResourceContext *display_resource_ctx,
                               const uint32_t roate_cnt);
   void AssignRotator(HWRotateInfo *rotate, uint32_t *rotate_cnt);
   void ClearRotator(DisplayResourceContext *display_resource_ctx);
-  DisplayError AllocRotatorBuffer(Handle display_ctx, HWLayers *hw_layers);
-  void SetRotatorOutputFormat(const LayerBufferFormat &input_format, bool bwc, bool rot90,
-                              bool downscale, LayerBufferFormat *output_format);
+  void SetRotatorOutputFormat(const LayerBufferFormat &input_format, const bool &is_opaque,
+                              const bool &rot90, const bool &downscale,
+                              LayerBufferFormat *output_format);
   DisplayError AlignPipeConfig(const Layer &layer, const LayerTransform &transform,
                                HWPipeInfo *left_pipe, HWPipeInfo *right_pipe,
                                uint32_t align_x, uint32_t align_y);
   void ResourceStateLog(void);
-  DisplayError CalculateDecimation(float downscale, uint8_t* decimation);
+  DisplayError CalculateDecimation(float downscale, uint8_t *decimation);
 
   Locker locker_;
   HWResourceInfo hw_res_info_;
@@ -224,6 +224,7 @@
   float bw_claimed_;  // Bandwidth claimed by other display
   float clk_claimed_;  // Clock claimed by other display
   float last_primary_bw_;
+  float max_system_bw_;
   uint32_t virtual_count_;
   struct HWRotator rotators_[kMaxNumRotator];
   BufferAllocator *buffer_allocator_;
diff --git a/displayengine/libs/core/rotator_ctrl.cpp b/displayengine/libs/core/rotator_ctrl.cpp
new file mode 100644
index 0000000..8018e31
--- /dev/null
+++ b/displayengine/libs/core/rotator_ctrl.cpp
@@ -0,0 +1,250 @@
+/*
+* 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:
+*    * Redistributions of source code must retain the above copyright notice, this list of
+*      conditions and the following disclaimer.
+*    * Redistributions in binary form must reproduce the above copyright notice, this list of
+*      conditions and the following disclaimer in the documentation and/or other materials provided
+*      with the distribution.
+*    * Neither the name of The Linux Foundation nor the names of its contributors may be used to
+*      endorse or promote products derived from this software without specific prior written
+*      permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+* NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <utils/constants.h>
+#include <utils/debug.h>
+#include <utils/rect.h>
+#include <core/buffer_allocator.h>
+#include <core/buffer_sync_handler.h>
+
+#include "rotator_ctrl.h"
+#include "hw_rotator_interface.h"
+#include "hw_interface.h"
+#include "session_manager.h"
+
+#define __CLASS__ "RotatorCtrl"
+
+namespace sde {
+
+RotatorCtrl::RotatorCtrl() : hw_rotator_intf_(NULL) {
+}
+
+DisplayError RotatorCtrl::Init(BufferAllocator *buffer_allocator,
+                               BufferSyncHandler *buffer_sync_handler) {
+  DisplayError error = kErrorNone;
+
+  error = HWRotatorInterface::Create(buffer_sync_handler, &hw_rotator_intf_);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = hw_rotator_intf_->Open();
+  if (error != kErrorNone) {
+    DLOGE("Failed to open rotator device");
+    return error;
+  }
+
+  session_manager_ = new SessionManager(hw_rotator_intf_, buffer_allocator, buffer_sync_handler);
+  if (session_manager_ == NULL) {
+    HWRotatorInterface::Destroy(hw_rotator_intf_);
+    return kErrorMemory;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::Deinit() {
+  DisplayError error = kErrorNone;
+
+  error = hw_rotator_intf_->Close();
+  if (error != kErrorNone) {
+    DLOGW("Failed to close rotator device");
+    return error;
+  }
+
+  if (session_manager_) {
+    delete session_manager_;
+    session_manager_ = NULL;
+  }
+
+  HWRotatorInterface::Destroy(hw_rotator_intf_);
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::RegisterDisplay(DisplayType type, Handle *display_ctx) {
+  DisplayRotatorContext *disp_rotator_ctx = new DisplayRotatorContext();
+  if (disp_rotator_ctx == NULL) {
+    return kErrorMemory;
+  }
+
+  disp_rotator_ctx->display_type = type;
+  *display_ctx = disp_rotator_ctx;
+
+  return kErrorNone;
+}
+
+void RotatorCtrl::UnregisterDisplay(Handle display_ctx) {
+  DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+
+  delete disp_rotator_ctx;
+  disp_rotator_ctx = NULL;
+}
+
+
+DisplayError RotatorCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayError error = kErrorNone;
+
+  DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+
+  error = PrepareSessions(disp_rotator_ctx, hw_layers);
+  if (error != kErrorNone) {
+    DLOGE("Prepare rotator session failed for display %d", disp_rotator_ctx->display_type);
+    return error;
+  }
+
+  error = hw_rotator_intf_->Validate(hw_layers);
+  if (error != kErrorNone) {
+    DLOGE("Rotator validation failed for display %d", disp_rotator_ctx->display_type);
+    return error;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::Commit(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayError error = kErrorNone;
+
+  DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+
+  error = GetOutputBuffers(disp_rotator_ctx, hw_layers);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = hw_rotator_intf_->Commit(hw_layers);
+  if (error != kErrorNone) {
+    DLOGE("Rotator commit failed for display %d", disp_rotator_ctx->display_type);
+    return error;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
+  HWLayersInfo &hw_layer_info = hw_layers->info;
+  DisplayError error = kErrorNone;
+  DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+  int client_id = INT(disp_rotator_ctx->display_type);
+
+  for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+    Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+    if (!hw_rotator_session->hw_block_count) {
+      continue;
+    }
+
+    error = session_manager_->SetReleaseFd(client_id, hw_rotator_session);
+    if (error != kErrorNone) {
+      DLOGE("Rotator Post commit failed for display %d", disp_rotator_ctx->display_type);
+      return error;
+    }
+  }
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::Purge(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+  int client_id = INT(disp_rotator_ctx->display_type);
+
+  session_manager_->Start(client_id);
+
+  return session_manager_->Stop(client_id);
+}
+
+DisplayError RotatorCtrl::PrepareSessions(DisplayRotatorContext *disp_rotator_ctx,
+                                          HWLayers *hw_layers) {
+  HWLayersInfo &hw_layer_info = hw_layers->info;
+  DisplayError error = kErrorNone;
+  int client_id = INT(disp_rotator_ctx->display_type);
+
+  session_manager_->Start(client_id);
+
+  for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+    Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+    HWSessionConfig &hw_session_config = hw_rotator_session->hw_session_config;
+    HWRotateInfo *left_rotate = &hw_rotator_session->hw_rotate_info[0];
+    HWRotateInfo *right_rotate = &hw_rotator_session->hw_rotate_info[1];
+
+    if (!hw_rotator_session->hw_block_count) {
+      continue;
+    }
+
+    hw_session_config.src_width = UINT32(layer.src_rect.right - layer.src_rect.left);
+    hw_session_config.src_height = UINT32(layer.src_rect.bottom - layer.src_rect.top);
+    hw_session_config.src_format = layer.input_buffer->format;
+
+    LayerRect dst_rect = Union(left_rotate->dst_roi, right_rotate->dst_roi);
+
+    hw_session_config.dst_width = UINT32(dst_rect.right - dst_rect.left);
+    hw_session_config.dst_height = UINT32(dst_rect.bottom - dst_rect.top);
+    hw_session_config.dst_format = hw_rotator_session->output_buffer.format;
+
+    // Allocate two rotator output buffers by default for double buffering.
+    hw_session_config.buffer_count = kDoubleBuffering;
+    hw_session_config.secure = layer.input_buffer->flags.secure;
+    hw_session_config.frame_rate = layer.frame_rate;
+
+    error = session_manager_->OpenSession(client_id, hw_rotator_session);
+    if (error != kErrorNone) {
+      return error;
+    }
+  }
+
+  error = session_manager_->Stop(client_id);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::GetOutputBuffers(DisplayRotatorContext *disp_rotator_ctx,
+                                           HWLayers *hw_layers) {
+  HWLayersInfo &hw_layer_info = hw_layers->info;
+  DisplayError error = kErrorNone;
+  int client_id = INT(disp_rotator_ctx->display_type);
+
+  for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+    Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+    if (!hw_rotator_session->hw_block_count) {
+      continue;
+    }
+
+    error = session_manager_->GetNextBuffer(client_id, hw_rotator_session);
+    if (error != kErrorNone) {
+      return error;
+    }
+  }
+
+  return kErrorNone;
+}
+
+}  // namespace sde
+
diff --git a/displayengine/libs/core/offline_ctrl.h b/displayengine/libs/core/rotator_ctrl.h
similarity index 72%
rename from displayengine/libs/core/offline_ctrl.h
rename to displayengine/libs/core/rotator_ctrl.h
index 1525bb8..3e5deaf 100644
--- a/displayengine/libs/core/offline_ctrl.h
+++ b/displayengine/libs/core/rotator_ctrl.h
@@ -22,8 +22,8 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __OFFLINE_CTRL_H__
-#define __OFFLINE_CTRL_H__
+#ifndef __ROTATOR_CTRL_H__
+#define __ROTATOR_CTRL_H__
 
 #include <utils/locker.h>
 #include <utils/debug.h>
@@ -32,36 +32,44 @@
 namespace sde {
 
 class HWRotatorInterface;
+class BufferAllocator;
 class BufferSyncHandler;
 struct HWLayers;
+class SessionManager;
 
-class OfflineCtrl {
+class RotatorCtrl {
  public:
-  OfflineCtrl();
-  DisplayError Init(BufferSyncHandler *buffer_sync_handler);
+  RotatorCtrl();
+  DisplayError Init(BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
   DisplayError Deinit();
   DisplayError RegisterDisplay(DisplayType type, Handle *display_ctx);
   void UnregisterDisplay(Handle display_ctx);
   DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
   DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
+  DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
+  DisplayError Purge(Handle display_ctx, HWLayers *hw_layers);
 
  private:
-  struct DisplayOfflineContext {
-    DisplayType display_type;
-    bool pending_rot_commit;
-
-    DisplayOfflineContext() : display_type(kPrimary), pending_rot_commit(false) { }
+  enum {
+    kSingleBuffering = 1,
+    kDoubleBuffering = 2,
+    kTripleBuffering = 3,
   };
 
-  DisplayError OpenRotatorSession(HWLayers *hw_layers);
-  DisplayError CloseRotatorSession(HWLayers *hw_layers);
-  bool IsRotationRequired(HWLayers *hw_layers);
+  struct DisplayRotatorContext {
+    DisplayType display_type;
+
+    DisplayRotatorContext() : display_type(kPrimary) { }
+  };
+
+  DisplayError PrepareSessions(DisplayRotatorContext *disp_rotator_ctx, HWLayers *hw_layers);
+  DisplayError GetOutputBuffers(DisplayRotatorContext *disp_rotator_ctx, HWLayers *hw_layers);
 
   HWRotatorInterface *hw_rotator_intf_;
-  bool hw_rotator_present_;
+  SessionManager *session_manager_;
 };
 
 }  // namespace sde
 
-#endif  // __OFFLINE_CTRL_H__
+#endif  // __ROTATOR_CTRL_H__
 
diff --git a/displayengine/libs/core/scalar_helper.cpp b/displayengine/libs/core/scalar_helper.cpp
index 55b462f..b5d8989 100644
--- a/displayengine/libs/core/scalar_helper.cpp
+++ b/displayengine/libs/core/scalar_helper.cpp
@@ -91,6 +91,7 @@
   case kFormatYCbCr422H2V1Packed:       format = scalar::YCBYCR_H2V1;       break;
   case kFormatYCbCr420SemiPlanarVenus:  format = scalar::Y_CBCR_H2V2_VENUS; break;
   case kFormatRGBA8888Ubwc:             format = scalar::RGBA_8888_UBWC;    break;
+  case kFormatRGBX8888Ubwc:             format = scalar::RGBX_8888_UBWC;    break;
   case kFormatRGB565Ubwc:               format = scalar::RGB_565_UBWC;      break;
   case kFormatYCbCr420SPVenusUbwc:      format = scalar::Y_CBCR_H2V2_UBWC;  break;
   default:
@@ -137,6 +138,7 @@
     LayerBufferFormat format = layer.input_buffer->format;
     HWPipeInfo* left_pipe = &hw_layers->config[i].left_pipe;
     HWPipeInfo* right_pipe = &hw_layers->config[i].right_pipe;
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
 
     // Prepare data structure for lib scalar
     uint32_t flags = 0;
@@ -152,12 +154,12 @@
 
     for (uint32_t count = 0; count < 2; count++) {
       HWPipeInfo* hw_pipe = (count == 0) ? left_pipe : right_pipe;
-      HWRotateInfo* rotate_info = &hw_layers->config[i].rotates[count];
+      HWRotateInfo* hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
       scalar::PipeInfo* pipe = (count == 0) ? &layer_info.left_pipe : &layer_info.right_pipe;
 
-      if (rotate_info->valid) {
-        width = rotate_info->hw_buffer_info.buffer_config.width;
-        format = rotate_info->hw_buffer_info.buffer_config.format;
+      if (hw_rotate_info->valid) {
+        width = UINT32(hw_rotate_info->dst_roi.right - hw_rotate_info->dst_roi.left);
+        format = hw_rotator_session->output_buffer.format;
       }
 
       pipe->flags = flags;
diff --git a/displayengine/libs/core/session_manager.cpp b/displayengine/libs/core/session_manager.cpp
new file mode 100644
index 0000000..dd4c29a
--- /dev/null
+++ b/displayengine/libs/core/session_manager.cpp
@@ -0,0 +1,364 @@
+/*
+* Copyright (c) 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:
+*  * Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+*  * Redistributions in binary form must reproduce the above
+*    copyright notice, this list of conditions and the following
+*    disclaimer in the documentation and/or other materials provided
+*    with the distribution.
+*  * Neither the name of The Linux Foundation nor the names of its
+*    contributors may be used to endorse or promote products derived
+*    from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <utils/debug.h>
+#include <utils/constants.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "session_manager.h"
+#include "hw_rotator_interface.h"
+
+#define __CLASS__ "SessionManager"
+
+namespace sde {
+
+// SessionManager State Transition
+// *******************************************************
+// Current State *             Next State
+//               *****************************************
+//               * RELEASED    READY        ACQUIRED
+// *******************************************************
+//  RELEASED     *    NA         NA        OpenSession()
+//  READY        *   Stop()      NA        OpenSession()
+//  ACQUIRED     *    NA       Start()          NA
+//********************************************************
+
+// ------------------------------- SessionManager Implementation -----------------------------------
+
+SessionManager::SessionManager(HWRotatorInterface *hw_rotator_intf,
+                               BufferAllocator *buffer_allocator,
+                               BufferSyncHandler *buffer_sync_handler)
+  : hw_rotator_intf_(hw_rotator_intf), buffer_allocator_(buffer_allocator),
+    buffer_sync_handler_(buffer_sync_handler), active_session_count_(0) {
+}
+
+void SessionManager::Start(const int &client_id) {
+  SCOPE_LOCK(locker_);
+
+  uint32_t session_count = 0;
+  uint32_t acquired_session_count = 0;
+
+  // Change the state of acquired session to kSessionReady
+  while ((acquired_session_count < active_session_count_) && (session_count < kMaxSessionCount)) {
+    if (session_list_[session_count].state == kSessionAcquired) {
+      if (session_list_[session_count].client_id == client_id) {
+        session_list_[session_count].state = kSessionReady;
+      }
+      acquired_session_count++;
+    }
+    session_count++;
+  }
+}
+
+DisplayError SessionManager::OpenSession(const int &client_id,
+                                         HWRotatorSession *hw_rotator_session) {
+  SCOPE_LOCK(locker_);
+
+  DisplayError error = kErrorNone;
+
+  const HWSessionConfig &input_config = hw_rotator_session->hw_session_config;
+
+  DLOGI_IF(kTagRotator, "Src buffer: width = %d, height = %d, format = %d",
+           input_config.src_width, input_config.src_height, input_config.src_format);
+  DLOGI_IF(kTagRotator, "Dst buffer: width = %d, height = %d, format = %d",
+           input_config.dst_width, input_config.dst_height, input_config.dst_format);
+  DLOGI_IF(kTagRotator, "buffer_count = %d, secure = %d, cache = %d, frame_rate = %d",
+           input_config.buffer_count, input_config.secure, input_config.cache,
+           input_config.frame_rate);
+
+  uint32_t free_session = active_session_count_;
+  uint32_t acquired_session = kMaxSessionCount;
+  uint32_t active_session_count = 0;
+
+  // First look for a session in ready state, if no session found in ready state matching
+  // with current input session config, assign a session in released state.
+  for (uint32_t session_count = 0; session_count < kMaxSessionCount &&
+       active_session_count < active_session_count_; session_count++) {
+    HWSessionConfig &hw_session_config =
+           session_list_[session_count].hw_rotator_session.hw_session_config;
+
+    if (session_list_[session_count].state == kSessionReleased) {
+      free_session = session_count;
+      continue;
+    }
+
+    if (session_list_[session_count].state == kSessionReady) {
+      if (session_list_[session_count].client_id == client_id &&
+          input_config == hw_session_config) {
+        session_list_[session_count].state = kSessionAcquired;
+        acquired_session = session_count;
+        break;
+      }
+    }
+    active_session_count++;
+  }
+
+  // If the input config does not match with existing config, then add new session and change the
+  // state to kSessionAcquired
+  if (acquired_session == kMaxSessionCount) {
+    if (free_session >= kMaxSessionCount) {
+      return kErrorMemory;
+    }
+
+    error = AcquireSession(hw_rotator_session, &session_list_[free_session]);
+    if (error !=kErrorNone) {
+      return error;
+    }
+
+    acquired_session = free_session;
+    hw_rotator_session->session_id = acquired_session;
+    session_list_[acquired_session].client_id = client_id;
+    active_session_count_++;
+
+    DLOGV_IF(kTagRotator, "Acquire new session Output: width = %d, height = %d, format = %d, " \
+             "session_id %d, client_id %d", hw_rotator_session->output_buffer.width,
+             hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
+             hw_rotator_session->session_id, client_id);
+
+    return kErrorNone;
+  }
+
+  *hw_rotator_session = session_list_[acquired_session].hw_rotator_session;
+
+  DLOGV_IF(kTagRotator, "Acquire existing session Output: width = %d, height = %d, format = %d, " \
+           "session_id %d, client_id %d", hw_rotator_session->output_buffer.width,
+           hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
+           hw_rotator_session->session_id, client_id);
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::GetNextBuffer(const int &client_id,
+                                           HWRotatorSession *hw_rotator_session) {
+  SCOPE_LOCK(locker_);
+
+  DisplayError error = kErrorNone;
+
+  int session_id = hw_rotator_session->session_id;
+  if (session_id > kMaxSessionCount) {
+    return kErrorParameters;
+  }
+
+  Session *session = &session_list_[session_id];
+  if (session->state != kSessionAcquired) {
+    DLOGE("Invalid session state %d", session->state);
+    return kErrorParameters;
+  }
+
+  uint32_t curr_index = session->curr_index;
+
+  BufferInfo *buffer_info = &session->buffer_info;
+  if (buffer_info->alloc_buffer_info.fd < 0) {
+    const uint32_t &buffer_count = buffer_info->buffer_config.buffer_count;
+    const size_t &buffer_size = buffer_info->alloc_buffer_info.size;
+
+    error = buffer_allocator_->AllocateBuffer(buffer_info);
+    if (error != kErrorNone) {
+      return error;
+    }
+
+    for (uint32_t idx = 0; idx < buffer_count; idx++) {
+      session->offset[idx] = UINT32((buffer_size / buffer_count) * idx);
+    }
+  }
+
+  // Wait for the release fence fd before the session being given to the client.
+  buffer_sync_handler_->SyncWait(session->release_fd[curr_index]);
+  close(session->release_fd[curr_index]);
+  session->release_fd[curr_index] = -1;
+
+  hw_rotator_session->output_buffer.planes[0].stride = buffer_info->alloc_buffer_info.stride;
+  hw_rotator_session->output_buffer.planes[0].fd = buffer_info->alloc_buffer_info.fd;
+  hw_rotator_session->output_buffer.planes[0].offset = session->offset[curr_index];
+
+  session->hw_rotator_session = *hw_rotator_session;
+
+  DLOGI_IF(kTagRotator, "Output: width = %d, height = %d, format = %d, stride %d, " \
+           "curr_index = %d, offset %d, fd %d, session_id %d, client_id %d",
+           hw_rotator_session->output_buffer.width, hw_rotator_session->output_buffer.height,
+           hw_rotator_session->output_buffer.format,
+           hw_rotator_session->output_buffer.planes[0].stride, curr_index,
+           hw_rotator_session->output_buffer.planes[0].offset,
+           hw_rotator_session->output_buffer.planes[0].fd, session_id, client_id);
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::Stop(const int &client_id) {
+  SCOPE_LOCK(locker_);
+
+  DisplayError error = kErrorNone;
+  uint32_t session_id = 0;
+
+  // Release all the sessions which were not acquired in the current cycle and deallocate the
+  // buffers associated with it.
+  while ((active_session_count_ > 0) && (session_id < kMaxSessionCount)) {
+    if (session_list_[session_id].state == kSessionReady &&
+        session_list_[session_id].client_id == client_id) {
+      error = ReleaseSession(&session_list_[session_id]);
+      if (error != kErrorNone) {
+        return error;
+      }
+      active_session_count_--;
+
+      DLOGI_IF(kTagRotator, "session_id = %d, active_session_count = %d, client_id %d", session_id,
+               active_session_count_, client_id);
+    }
+    session_id++;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::SetReleaseFd(const int &client_id,
+                                          HWRotatorSession *hw_rotator_session) {
+  SCOPE_LOCK(locker_);
+
+  int session_id = hw_rotator_session->session_id;
+  if (session_id > kMaxSessionCount) {
+    return kErrorParameters;
+  }
+
+  Session *session = &session_list_[session_id];
+  if (session->state != kSessionAcquired) {
+    DLOGE("Invalid session state %d", session->state);
+    return kErrorParameters;
+  }
+
+  uint32_t &curr_index = session->curr_index;
+  uint32_t buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+
+  // 1. Store the release fence fd, so that session manager waits for the release fence fd
+  //    to be signaled and populates the session info to the client.
+  // 2. Modify the curr_index to point to next buffer.
+  session->release_fd[curr_index] = hw_rotator_session->output_buffer.release_fence_fd;
+
+  curr_index = (curr_index + 1) % buffer_count;
+
+  DLOGI_IF(kTagRotator, "session_id %d, curr_index = %d, release fd %d, client_id %d", session_id,
+           curr_index, hw_rotator_session->output_buffer.release_fence_fd, client_id);
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::AcquireSession(HWRotatorSession *hw_rotator_session,
+                                            Session *session) {
+  DisplayError error = kErrorNone;
+  const HWSessionConfig &input_config = hw_rotator_session->hw_session_config;
+
+  error = hw_rotator_intf_->OpenSession(hw_rotator_session);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  hw_rotator_session->output_buffer = LayerBuffer();
+  hw_rotator_session->output_buffer.width = input_config.dst_width;
+  hw_rotator_session->output_buffer.height = input_config.dst_height;
+  hw_rotator_session->output_buffer.format = input_config.dst_format;
+  hw_rotator_session->output_buffer.flags.secure = input_config.secure;
+
+  uint32_t buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+
+  session->release_fd = new int[buffer_count];
+  if (session->release_fd == NULL) {
+    return kErrorMemory;
+  }
+
+  session->offset = new uint32_t[buffer_count];
+  if (session->offset == NULL) {
+    delete[] session->release_fd;
+    session->release_fd = NULL;
+    return kErrorMemory;
+  }
+
+  for (uint32_t idx = 0; idx < buffer_count; idx++) {
+    session->release_fd[idx] = -1;
+    session->offset[idx] = 0;
+  }
+  session->curr_index = 0;
+
+  session->hw_rotator_session = HWRotatorSession();
+  session->buffer_info = BufferInfo();
+
+  BufferInfo *buffer_info = &session->buffer_info;
+  buffer_info->buffer_config.buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+  buffer_info->buffer_config.secure = hw_rotator_session->hw_session_config.secure;
+  buffer_info->buffer_config.cache = hw_rotator_session->hw_session_config.cache;
+  buffer_info->buffer_config.width = hw_rotator_session->hw_session_config.dst_width;
+  buffer_info->buffer_config.height = hw_rotator_session->hw_session_config.dst_height;
+  buffer_info->buffer_config.format = hw_rotator_session->hw_session_config.dst_format;
+
+  session->state = kSessionAcquired;
+  session->hw_rotator_session = *hw_rotator_session;
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::ReleaseSession(Session *session) {
+  DisplayError error = kErrorNone;
+
+  BufferInfo *buffer_info = &session->buffer_info;
+
+  error = buffer_allocator_->FreeBuffer(buffer_info);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = hw_rotator_intf_->CloseSession(&session->hw_rotator_session);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  uint32_t buffer_count = buffer_info->buffer_config.buffer_count;
+
+  for (uint32_t idx = 0; idx < buffer_count; idx++) {
+    if (session->release_fd[idx] >= 0) {
+      close(session->release_fd[idx]);
+      session->release_fd[idx] = -1;
+    }
+  }
+
+  session->state = kSessionReleased;
+  session->client_id == -1;
+
+  if (session->offset) {
+    delete[] session->offset;
+    session->offset = NULL;
+  }
+
+  if (session->release_fd) {
+    delete[] session->release_fd;
+    session->release_fd = NULL;
+  }
+
+  return kErrorNone;
+}
+
+}  // namespace sde
diff --git a/displayengine/libs/core/session_manager.h b/displayengine/libs/core/session_manager.h
new file mode 100644
index 0000000..3324c3e
--- /dev/null
+++ b/displayengine/libs/core/session_manager.h
@@ -0,0 +1,90 @@
+/*
+* Copyright (c) 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:
+*  * Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+*  * Redistributions in binary form must reproduce the above
+*    copyright notice, this list of conditions and the following
+*    disclaimer in the documentation and/or other materials provided
+*    with the distribution.
+*  * Neither the name of The Linux Foundation nor the names of its
+*    contributors may be used to endorse or promote products derived
+*    from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef __SESSION_MANAGER_H__
+#define __SESSION_MANAGER_H__
+
+#include <utils/locker.h>
+#include <core/buffer_allocator.h>
+#include "hw_interface.h"
+
+namespace sde {
+
+class HWRotatorInterface;
+
+class SessionManager {
+ public:
+  SessionManager(HWRotatorInterface *hw_intf, BufferAllocator *buffer_allocator,
+                 BufferSyncHandler *buffer_sync_handler);
+
+  void Start(const int &client_id);
+  DisplayError Stop(const int &client_id);
+  DisplayError OpenSession(const int &client_id, HWRotatorSession *hw_rotator_session);
+  DisplayError GetNextBuffer(const int &client_id, HWRotatorSession *hw_rotator_session);
+  DisplayError SetReleaseFd(const int &client_id, HWRotatorSession *hw_rotator_session);
+
+ private:
+  // TODO(user): Read from hw capability instead of hardcoding
+  static const int kMaxSessionCount = 32;
+
+  enum SessionState {
+    kSessionReleased = 0,
+    kSessionReady    = 1,
+    kSessionAcquired = 2,
+  };
+
+  struct Session {
+    HWRotatorSession hw_rotator_session;
+    BufferInfo buffer_info;
+    SessionState state;
+    int *release_fd;
+    uint32_t *offset;
+    uint32_t curr_index;
+    int client_id;
+
+    Session() : state(kSessionReleased), release_fd(NULL), offset(NULL), curr_index(0),
+                client_id(-1) { }
+  };
+
+  DisplayError AcquireSession(HWRotatorSession *hw_rotator_session, Session *session);
+  DisplayError ReleaseSession(Session *session);
+
+  Locker locker_;
+  Session session_list_[kMaxSessionCount];
+  HWRotatorInterface *hw_rotator_intf_;
+  BufferAllocator *buffer_allocator_;
+  BufferSyncHandler *buffer_sync_handler_;
+  uint32_t active_session_count_;           // number of sessions in ready/acquired state.
+};
+
+}  // namespace sde
+
+#endif  // __SESSION_MANAGER_H__
+
+
diff --git a/displayengine/libs/core/strategy_default.cpp b/displayengine/libs/core/strategy_default.cpp
index e3270b7..48fc79d 100644
--- a/displayengine/libs/core/strategy_default.cpp
+++ b/displayengine/libs/core/strategy_default.cpp
@@ -35,6 +35,8 @@
 }
 
 DisplayError StrategyDefault::CreateStrategyInterface(uint16_t version, DisplayType type,
+                                                      const HWResourceInfo *hw_resource_info,
+                                                      const HWPanelInfo *hw_panel_info,
                                                       StrategyInterface **interface) {
   StrategyDefault *strategy_default  = new StrategyDefault();
 
diff --git a/displayengine/libs/core/strategy_default.h b/displayengine/libs/core/strategy_default.h
index 2ba19f8..7b6f594 100644
--- a/displayengine/libs/core/strategy_default.h
+++ b/displayengine/libs/core/strategy_default.h
@@ -35,6 +35,8 @@
   StrategyDefault();
 
   static DisplayError CreateStrategyInterface(uint16_t version, DisplayType type,
+                                              const HWResourceInfo *hw_resource_info,
+                                              const HWPanelInfo *hw_panel_info,
                                               StrategyInterface **interface);
   static DisplayError DestroyStrategyInterface(StrategyInterface *interface);
 
diff --git a/displayengine/libs/hwc/hwc_buffer_allocator.cpp b/displayengine/libs/hwc/hwc_buffer_allocator.cpp
index 2adfc3a..61d9913 100644
--- a/displayengine/libs/hwc/hwc_buffer_allocator.cpp
+++ b/displayengine/libs/hwc/hwc_buffer_allocator.cpp
@@ -63,11 +63,6 @@
   int height = INT(buffer_config.height);
   int format;
 
-  error = SetHALFormat(buffer_config.format, &format);
-  if (error != 0) {
-    return kErrorParameters;
-  }
-
   if (buffer_config.secure) {
     alloc_flags = GRALLOC_USAGE_PRIVATE_MM_HEAP;
     alloc_flags |= GRALLOC_USAGE_PROTECTED;
@@ -81,11 +76,16 @@
     alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
   }
 
+  error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
+  if (error != 0) {
+    return kErrorParameters;
+  }
+
   int aligned_width = 0, aligned_height = 0;
   uint32_t buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
                                                     aligned_width, aligned_height);
 
-  buffer_size = ROUND_UP((buffer_size * buffer_config.buffer_count), data.align);
+  buffer_size = ROUND_UP(buffer_size, data.align) * buffer_config.buffer_count;
 
   data.base = 0;
   data.fd = -1;
@@ -116,8 +116,9 @@
 
   AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
   MetaBufferInfo *meta_buffer_info = static_cast<MetaBufferInfo *> (buffer_info->private_data);
-  if ((alloc_buffer_info->fd < 0) || (meta_buffer_info->base_addr == NULL)) {
-    return kErrorNone;
+  if (alloc_buffer_info->fd < 0) {
+    DLOGE("Invalid parameters: fd %d", alloc_buffer_info->fd);
+    return kErrorParameters;
   }
 
   gralloc::IMemAlloc *memalloc = alloc_controller_->getAllocator(meta_buffer_info->alloc_type);
@@ -147,7 +148,7 @@
   return kErrorNone;
 }
 
-int HWCBufferAllocator::SetHALFormat(LayerBufferFormat format, int *target) {
+int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int *target, int *flags) {
   switch (format) {
   case kFormatRGBA8888:                 *target = HAL_PIXEL_FORMAT_RGBA_8888;             break;
   case kFormatRGBX8888:                 *target = HAL_PIXEL_FORMAT_RGBX_8888;             break;
@@ -163,7 +164,18 @@
   case kFormatYCbCr420SPVenusUbwc:    *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC; break;
   case kFormatRGBA5551:                 *target = HAL_PIXEL_FORMAT_RGBA_5551;             break;
   case kFormatRGBA4444:                 *target = HAL_PIXEL_FORMAT_RGBA_4444;             break;
-
+  case kFormatRGBA8888Ubwc:
+    *target = HAL_PIXEL_FORMAT_RGBA_8888;
+    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+    break;
+  case kFormatRGBX8888Ubwc:
+    *target = HAL_PIXEL_FORMAT_RGBX_8888;
+    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+    break;
+  case kFormatRGB565Ubwc:
+    *target = HAL_PIXEL_FORMAT_RGB_565;
+    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+    break;
   default:
     DLOGE("Unsupported format = 0x%x", format);
     return -EINVAL;
diff --git a/displayengine/libs/hwc/hwc_buffer_allocator.h b/displayengine/libs/hwc/hwc_buffer_allocator.h
index 123f04a..eb3d1fd 100644
--- a/displayengine/libs/hwc/hwc_buffer_allocator.h
+++ b/displayengine/libs/hwc/hwc_buffer_allocator.h
@@ -57,7 +57,7 @@
     void *base_addr;             //!< Specifies the base address of the allocated output buffer.
   };
 
-  int SetHALFormat(LayerBufferFormat format, int *target);
+  int SetBufferInfo(LayerBufferFormat format, int *target, int *flags);
 
   gralloc::IAllocController *alloc_controller_;
 };
diff --git a/displayengine/libs/hwc/hwc_debugger.cpp b/displayengine/libs/hwc/hwc_debugger.cpp
index d35e9cf..38f4f5c 100644
--- a/displayengine/libs/hwc/hwc_debugger.cpp
+++ b/displayengine/libs/hwc/hwc_debugger.cpp
@@ -76,19 +76,11 @@
   }
 }
 
-void HWCDebugHandler::DebugBufferManager(bool enable) {
+void HWCDebugHandler::DebugRotator(bool enable) {
   if (enable) {
-    SET_BIT(debug_flags_, kTagBufferManager);
+    SET_BIT(debug_flags_, kTagRotator);
   } else {
-    CLEAR_BIT(debug_flags_, kTagBufferManager);
-  }
-}
-
-void HWCDebugHandler::DebugOfflineCtrl(bool enable) {
-  if (enable) {
-    SET_BIT(debug_flags_, kTagOfflineCtrl);
-  } else {
-    CLEAR_BIT(debug_flags_, kTagOfflineCtrl);
+    CLEAR_BIT(debug_flags_, kTagRotator);
   }
 }
 
diff --git a/displayengine/libs/hwc/hwc_debugger.h b/displayengine/libs/hwc/hwc_debugger.h
index def31db..2fed120 100644
--- a/displayengine/libs/hwc/hwc_debugger.h
+++ b/displayengine/libs/hwc/hwc_debugger.h
@@ -59,8 +59,7 @@
   static void DebugStrategy(bool enable);
   static void DebugCompManager(bool enable);
   static void DebugDriverConfig(bool enable);
-  static void DebugBufferManager(bool enable);
-  static void DebugOfflineCtrl(bool enable);
+  static void DebugRotator(bool enable);
 
   virtual void Error(DebugTag tag, const char *format, ...);
   virtual void Warning(DebugTag tag, const char *format, ...);
diff --git a/displayengine/libs/hwc/hwc_display.cpp b/displayengine/libs/hwc/hwc_display.cpp
index e2327c5..8a73d3c 100644
--- a/displayengine/libs/hwc/hwc_display.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -27,6 +27,7 @@
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
+#include <math.h>
 #include <errno.h>
 #include <gralloc_priv.h>
 #include <utils/constants.h>
@@ -108,10 +109,13 @@
     last_power_mode_ = HWC_POWER_MODE_NORMAL;
     break;
   case HWC_POWER_MODE_DOZE:
-  case HWC_POWER_MODE_DOZE_SUSPEND:
     state = kStateDoze;
     last_power_mode_ = HWC_POWER_MODE_DOZE;
     break;
+  case HWC_POWER_MODE_DOZE_SUSPEND:
+    state = kStateDozeSuspend;
+    last_power_mode_ = HWC_POWER_MODE_DOZE_SUSPEND;
+    break;
   default:
     return -EINVAL;
   }
@@ -346,6 +350,14 @@
       if (meta_data && meta_data->operation & UPDATE_REFRESH_RATE) {
         layer.frame_rate = meta_data->refreshrate;
       }
+
+      if (meta_data && meta_data->operation == PP_PARAM_INTERLACED && meta_data->interlaced) {
+        layer_buffer->flags.interlace = true;
+      }
+
+      if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) {
+        layer_buffer->flags.secure_display = true;
+      }
     }
 
     SetRect(hwc_layer.displayFrame, &layer.dst_rect);
@@ -571,10 +583,10 @@
 }
 
 void HWCDisplay::SetRect(const hwc_frect_t &source, LayerRect *target) {
-  target->left = source.left;
-  target->top = source.top;
-  target->right = source.right;
-  target->bottom = source.bottom;
+  target->left = floorf(source.left);
+  target->top = floorf(source.top);
+  target->right = ceilf(source.right);
+  target->bottom = ceilf(source.bottom);
 }
 
 void HWCDisplay::SetComposition(const int32_t &source, LayerComposition *target) {
@@ -596,7 +608,7 @@
   switch (source) {
   case HWC_BLENDING_PREMULT:    *target = kBlendingPremultiplied;   break;
   case HWC_BLENDING_COVERAGE:   *target = kBlendingCoverage;        break;
-  default:                      *target = kBlendingNone;            break;
+  default:                      *target = kBlendingOpaque;          break;
   }
 }
 
@@ -621,6 +633,7 @@
   if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
     switch (source) {
     case HAL_PIXEL_FORMAT_RGBA_8888:          format = kFormatRGBA8888Ubwc;            break;
+    case HAL_PIXEL_FORMAT_RGBX_8888:          format = kFormatRGBX8888Ubwc;            break;
     case HAL_PIXEL_FORMAT_RGB_565:            format = kFormatRGB565Ubwc;              break;
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
@@ -751,6 +764,8 @@
     return "INTERLACE";
   case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
     return "YCbCr_420_SP_VENUS";
+  case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
+    return "YCbCr_420_SP_VENUS_UBWC";
   default:
     return "Unknown pixel format";
   }
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 652d7e0..2201aa6 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -706,8 +706,7 @@
   case qService::IQService::DEBUG_ROTATOR:
     HWCDebugHandler::DebugResources(enable);
     HWCDebugHandler::DebugDriverConfig(enable);
-    HWCDebugHandler::DebugBufferManager(enable);
-    HWCDebugHandler::DebugOfflineCtrl(enable);
+    HWCDebugHandler::DebugRotator(enable);
     break;
 
   default:
diff --git a/displayengine/libs/utils/debug_android.cpp b/displayengine/libs/utils/debug_android.cpp
index 96339df..77c82b0 100644
--- a/displayengine/libs/utils/debug_android.cpp
+++ b/displayengine/libs/utils/debug_android.cpp
@@ -89,5 +89,15 @@
   return false;
 }
 
+// This property serves to disable/enable partial update
+bool Debug::IsPartialUpdate() {
+  char property[PROPERTY_VALUE_MAX];
+  if (property_get("sde.hwc.partial_update", property, NULL) > 0) {
+    return (atoi(property) ? 1 : true, false);
+  }
+
+  return false;
+}
+
 }  // namespace sde
 
diff --git a/displayengine/libs/utils/rect.cpp b/displayengine/libs/utils/rect.cpp
index 8dfd7dd..9b05951 100644
--- a/displayengine/libs/utils/rect.cpp
+++ b/displayengine/libs/utils/rect.cpp
@@ -35,15 +35,33 @@
 
 namespace sde {
 
-bool IsValidRect(const LayerRect &rect) {
+bool IsValid(const LayerRect &rect) {
   return ((rect.bottom > rect.top) && (rect.right > rect.left));
 }
 
+bool IsCongruent(const LayerRect &rect1, const LayerRect &rect2) {
+  return ((rect1.left == rect2.left) &&
+          (rect1.top == rect2.top) &&
+          (rect1.right == rect2.right) &&
+          (rect1.bottom == rect2.bottom));
+}
 
-LayerRect GetIntersection(const LayerRect &rect1, const LayerRect &rect2) {
+void Log(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
+  DLOGV_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
+           prefix, roi.left, roi.top, roi.right, roi.bottom);
+}
+
+void Normalize(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect) {
+    rect->left = ROUND_UP_ALIGN_UP(rect->left, align_x);
+    rect->right = ROUND_UP_ALIGN_DOWN(rect->right, align_x);
+    rect->top = ROUND_UP_ALIGN_UP(rect->top, align_y);
+    rect->bottom = ROUND_UP_ALIGN_DOWN(rect->bottom, align_y);
+}
+
+LayerRect Intersection(const LayerRect &rect1, const LayerRect &rect2) {
   LayerRect res;
 
-  if (!IsValidRect(rect1) || !IsValidRect(rect2)) {
+  if (!IsValid(rect1) || !IsValid(rect2)) {
     return LayerRect();
   }
 
@@ -52,23 +70,72 @@
   res.right = MIN(rect1.right, rect2.right);
   res.bottom = MIN(rect1.bottom, rect2.bottom);
 
-  if (!IsValidRect(res)) {
+  if (!IsValid(res)) {
     return LayerRect();
   }
 
   return res;
 }
 
-void LogRect(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
-  DLOGV_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
-           prefix, roi.left, roi.top, roi.right, roi.bottom);
+LayerRect Reposition(const LayerRect &rect, const int &x_offset, const int &y_offset) {
+  LayerRect res;
+
+  if (!IsValid(rect)) {
+    return LayerRect();
+  }
+
+  res.left = rect.left + FLOAT(x_offset);
+  res.top = rect.top + FLOAT(y_offset);
+  res.right = rect.right + FLOAT(x_offset);
+  res.bottom = rect.bottom + FLOAT(y_offset);
+
+  return res;
 }
 
-void NormalizeRect(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect) {
-  rect->left = ROUND_UP_ALIGN_UP(rect->left, align_x);
-  rect->right = ROUND_UP_ALIGN_DOWN(rect->right, align_x);
-  rect->top = ROUND_UP_ALIGN_UP(rect->top, align_y);
-  rect->bottom = ROUND_UP_ALIGN_DOWN(rect->bottom, align_y);
+// Not a geometrical rect deduction. Deducts rect2 from rect1 only if it results a single rect
+LayerRect Subtract(const LayerRect &rect1, const LayerRect &rect2) {
+  LayerRect res;
+
+  res = rect1;
+
+  if ((rect1.left == rect2.left) && (rect1.right == rect2.right)) {
+    if ((rect1.top == rect2.top) && (rect2.bottom <= rect1.bottom)) {
+      res.top = rect2.bottom;
+    } else if ((rect1.bottom == rect2.bottom) && (rect2.top >= rect1.top)) {
+      res.bottom = rect2.top;
+    }
+  } else if ((rect1.top == rect2.top) && (rect1.bottom == rect2.bottom)) {
+    if ((rect1.left == rect2.left) && (rect2.right <= rect1.right)) {
+      res.left = rect2.right;
+    } else if ((rect1.right == rect2.right) && (rect2.left >= rect1.left)) {
+      res.right = rect2.left;
+    }
+  }
+
+  return res;
+}
+
+LayerRect Union(const LayerRect &rect1, const LayerRect &rect2) {
+  LayerRect res;
+
+  if (!IsValid(rect1) && !IsValid(rect2)) {
+    return LayerRect();
+  }
+
+  if(!IsValid(rect1)){
+    return rect2;
+  }
+
+  if(!IsValid(rect2)){
+    return rect1;
+  }
+
+  res.left = MIN(rect1.left, rect2.left);
+  res.top = MIN(rect1.top, rect2.top);
+  res.right = MAX(rect1.right, rect2.right);
+  res.bottom = MAX(rect1.bottom, rect2.bottom);
+
+  return res;
 }
 
 }  // namespace sde
diff --git a/libgralloc/adreno_utils.h b/libgralloc/adreno_utils.h
index 78f49da..31f9d52 100644
--- a/libgralloc/adreno_utils.h
+++ b/libgralloc/adreno_utils.h
@@ -26,7 +26,7 @@
 typedef enum {
 
     ADRENO_PIXELFORMAT_UNKNOWN       = 0,
-    ADRENO_PIXELFORMAT_R8G8B8A8      = 27,
+    ADRENO_PIXELFORMAT_R8G8B8A8      = 28,
     ADRENO_PIXELFORMAT_R8G8B8A8_SRGB = 29,
     ADRENO_PIXELFORMAT_B5G6R5        = 85,
     ADRENO_PIXELFORMAT_B5G5R5A1      = 86,
@@ -37,6 +37,7 @@
     ADRENO_PIXELFORMAT_YUY2          = 107,
     ADRENO_PIXELFORMAT_B4G4R4A4      = 115,
     ADRENO_PIXELFORMAT_NV12_EXT      = 506,  // NV12 with non-std alignment and offsets
+    ADRENO_PIXELFORMAT_R8G8B8X8      = 507,  // GL_RGB8 (Internal)
     ADRENO_PIXELFORMAT_R8G8B8        = 508,  // GL_RGB8
     ADRENO_PIXELFORMAT_A1B5G5R5      = 519,  // GL_RGB5_A1
     ADRENO_PIXELFORMAT_R8G8B8X8_SRGB = 520,  // GL_SRGB8
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index 4f342db..e37cddd 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -49,6 +49,28 @@
 
 #define ASTC_BLOCK_SIZE 16
 
+#ifndef ION_FLAG_CP_PIXEL
+#define ION_FLAG_CP_PIXEL 0
+#endif
+
+#ifndef ION_FLAG_ALLOW_NON_CONTIG
+#define ION_FLAG_ALLOW_NON_CONTIG 0
+#endif
+
+#ifdef MASTER_SIDE_CP
+#define CP_HEAP_ID ION_SECURE_HEAP_ID
+/* Please Add the new SD ION Heap here */
+#define SD_HEAP_ID 0
+#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_CP_PIXEL)
+/* Please Add the new SD ION Flag here */
+#define ION_SD_FLAGS ION_SECURE
+#else // SLAVE_SIDE_CP
+#define CP_HEAP_ID ION_CP_MM_HEAP_ID
+#define SD_HEAP_ID CP_HEAP_ID
+#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_ALLOW_NON_CONTIG)
+#define ION_SD_FLAGS ION_SECURE
+#endif
+
 using namespace gralloc;
 using namespace qdutils;
 
@@ -97,6 +119,16 @@
         *(void **)&LINK_adreno_isUBWCSupportedByGpu =
                 ::dlsym(libadreno_utils, "isUBWCSupportedByGpu");
     }
+
+    // Check if the overriding property debug.gralloc.gfx_ubwc_disable
+    // that disables UBWC allocations for the graphics stack is set
+    gfx_ubwc_disable = 0;
+    char property[PROPERTY_VALUE_MAX];
+    property_get("debug.gralloc.gfx_ubwc_disable", property, "0");
+    if(!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
+       !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
+        gfx_ubwc_disable = 1;
+    }
 }
 
 AdrenoMemInfo::~AdrenoMemInfo()
@@ -271,7 +303,7 @@
 
 int AdrenoMemInfo::isUBWCSupportedByGPU(int format)
 {
-    if (libadreno_utils) {
+    if (!gfx_ubwc_disable && libadreno_utils) {
         if (LINK_adreno_isUBWCSupportedByGpu) {
             ADRENOPIXELFORMAT gpu_format = getGpuPixelFormat(format);
             return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
@@ -285,6 +317,8 @@
     switch (hal_format) {
         case HAL_PIXEL_FORMAT_RGBA_8888:
             return ADRENO_PIXELFORMAT_R8G8B8A8;
+        case HAL_PIXEL_FORMAT_RGBX_8888:
+            return ADRENO_PIXELFORMAT_R8G8B8X8;
         case HAL_PIXEL_FORMAT_RGB_565:
             return ADRENO_PIXELFORMAT_B5G6R5;
         case HAL_PIXEL_FORMAT_sRGB_A_8888:
@@ -334,13 +368,17 @@
 
     if(usage & GRALLOC_USAGE_PROTECTED) {
         if (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP) {
-            ionHeapId |= ION_HEAP(ION_CP_MM_HEAP_ID);
-            ionFlags |= ION_SECURE;
-#ifdef ION_FLAG_ALLOW_NON_CONTIG
-            if (!(usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY)) {
-                ionFlags |= ION_FLAG_ALLOW_NON_CONTIG;
+            if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
+                ionHeapId = ION_HEAP(SD_HEAP_ID);
+                /*
+                 * There is currently no flag in ION for Secure Display
+                 * VM. Please add it to the define once available.
+                */
+                ionFlags |= ION_SD_FLAGS;
+            } else {
+                ionHeapId = ION_HEAP(CP_HEAP_ID);
+                ionFlags |= ION_CP_FLAGS;
             }
-#endif
         } else {
             // for targets/OEMs which do not need HW level protection
             // do not set ion secure flag & MM heap. Fallback to system heap.
@@ -767,6 +805,7 @@
     {
         case HAL_PIXEL_FORMAT_RGB_565:
         case HAL_PIXEL_FORMAT_RGBA_8888:
+        case HAL_PIXEL_FORMAT_RGBX_8888:
         case HAL_PIXEL_FORMAT_sRGB_A_8888:
         case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
         case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
@@ -873,6 +912,7 @@
             size += getUBwcMetaBufferSize(width, height, 2);
             break;
         case HAL_PIXEL_FORMAT_RGBA_8888:
+        case HAL_PIXEL_FORMAT_RGBX_8888:
         case HAL_PIXEL_FORMAT_sRGB_A_8888:
             size = alignedw * alignedh * 4;
             size += getUBwcMetaBufferSize(width, height, 4);
@@ -888,3 +928,38 @@
     }
     return size;
 }
+
+int getRgbDataAddress(private_handle_t* hnd, void* rgb_data)
+{
+    int err = 0;
+
+    // This api is for RGB* formats
+    if (hnd->format > HAL_PIXEL_FORMAT_sRGB_X_8888) {
+        return -EINVAL;
+    }
+
+    // linear buffer
+    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)) {
+        rgb_data = (void*)hnd->base;
+        return err;
+    }
+
+    unsigned int meta_size = 0;
+    switch (hnd->format) {
+        case HAL_PIXEL_FORMAT_RGB_565:
+            meta_size = getUBwcMetaBufferSize(hnd->width, hnd->height, 2);
+            break;
+        case HAL_PIXEL_FORMAT_RGBA_8888:
+        case HAL_PIXEL_FORMAT_RGBX_8888:
+        case HAL_PIXEL_FORMAT_sRGB_A_8888:
+            meta_size = getUBwcMetaBufferSize(hnd->width, hnd->height, 4);
+            break;
+        default:
+            ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, hnd->format);
+            err = -EINVAL;
+            break;
+    }
+
+    rgb_data = (void*)(hnd->base + meta_size);
+    return err;
+}
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index 9be93d6..0fd6e3b 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -26,10 +26,19 @@
 #include "memalloc.h"
 #include "alloc_controller.h"
 #include <qdMetaData.h>
+#include <linux/msm_ion.h>
 
 using namespace gralloc;
 
+#define SZ_2M 0x200000
 #define SZ_1M 0x100000
+#define SZ_4K 0x1000
+
+#ifdef MASTER_SIDE_CP
+#define SECURE_ALIGN SZ_4K
+#else
+#define SECURE_ALIGN SZ_1M
+#endif
 
 gpu_context_t::gpu_context_t(const private_module_t* module,
                              IAllocController* alloc_ctrl ) :
@@ -64,10 +73,14 @@
     else
         data.align = getpagesize();
 
-    /* force 1MB alignment selectively for secure buffers, MDP5 onwards */
     if ((usage & GRALLOC_USAGE_PROTECTED) &&
         (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP)) {
-        data.align = ALIGN((int) data.align, SZ_1M);
+            if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
+                /* The alignment here reflects qsee mmu V7L/V8L requirement */
+                data.align = SZ_2M;
+            } else {
+                data.align = SECURE_ALIGN;
+            }
         size = ALIGN(size, data.align);
     }
 
@@ -142,8 +155,8 @@
             flags |= private_handle_t::PRIV_FLAGS_TILE_RENDERED;
         }
 
-        if (AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format) &&
-            isUBwcEnabled(format, usage)) {
+        if (isUBwcEnabled(format, usage) &&
+            AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format)) {
             flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
         }
 
@@ -295,6 +308,25 @@
             grallocFormat = HAL_PIXEL_FORMAT_RGBA_8888;
     }
 
+    bool useFbMem = false;
+    char property[PROPERTY_VALUE_MAX];
+    char isUBWC[PROPERTY_VALUE_MAX];
+    if (usage & GRALLOC_USAGE_HW_FB) {
+        if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
+            (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
+            (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
+            useFbMem = true;
+        } else {
+            if (property_get("debug.gralloc.enable_fb_ubwc", isUBWC, NULL) > 0){
+                if ((!strncmp(isUBWC, "1", PROPERTY_VALUE_MAX)) ||
+                    (!strncasecmp(isUBWC, "true", PROPERTY_VALUE_MAX))) {
+                    // Allocate UBWC aligned framebuffer
+                    usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+                }
+            }
+        }
+    }
+
     getGrallocInformationFromFormat(grallocFormat, &bufferType);
     size = getBufferSizeAndDimensions(w, h, grallocFormat, usage, alignedw,
                    alignedh);
@@ -303,15 +335,6 @@
         return -EINVAL;
     size = (bufferSize >= size)? bufferSize : size;
 
-    bool useFbMem = false;
-    char property[PROPERTY_VALUE_MAX];
-    if((usage & GRALLOC_USAGE_HW_FB) &&
-       (property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
-       (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
-        (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
-        useFbMem = true;
-    }
-
     int err = 0;
     if(useFbMem) {
         err = gralloc_alloc_framebuffer(usage, pHandle);
diff --git a/libgralloc/gr.h b/libgralloc/gr.h
index 5ee0cf8..98b4eec 100644
--- a/libgralloc/gr.h
+++ b/libgralloc/gr.h
@@ -71,6 +71,7 @@
 int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage);
 void free_buffer(private_handle_t *hnd);
 int getYUVPlaneInfo(private_handle_t* pHnd, struct android_ycbcr* ycbcr);
+int getRgbDataAddress(private_handle_t* pHnd, void* rgb_data);
 
 // To query if UBWC is enabled, based on format and usage flags
 bool isUBwcEnabled(int format, int usage);
@@ -148,6 +149,8 @@
     ADRENOPIXELFORMAT getGpuPixelFormat(int hal_format);
 
     private:
+        // Overriding flag to disable UBWC alloc for graphics stack
+        int  gfx_ubwc_disable;
         // Pointer to the padding library.
         void *libadreno_utils;
 
diff --git a/libgralloc/gralloc_priv.h b/libgralloc/gralloc_priv.h
index 676c3bc..6998296 100755
--- a/libgralloc/gralloc_priv.h
+++ b/libgralloc/gralloc_priv.h
@@ -85,6 +85,7 @@
 #define GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO 7
 #define GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO 8
 #define GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG 9
+#define GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS 10
 
 /* OEM specific HAL formats */
 
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
index 8b38952..4a1b2cd 100644
--- a/libgralloc/mapper.cpp
+++ b/libgralloc/mapper.cpp
@@ -328,18 +328,20 @@
                 native_handle_t** handle = va_arg(args, native_handle_t**);
                 private_handle_t* hnd = (private_handle_t*)native_handle_create(
                     private_handle_t::sNumFds, private_handle_t::sNumInts());
-                hnd->magic = private_handle_t::sMagic;
-                hnd->fd = fd;
-                hnd->flags =  private_handle_t::PRIV_FLAGS_USES_ION;
-                hnd->size = size;
-                hnd->offset = offset;
-                hnd->base = uint64_t(base) + offset;
-                hnd->gpuaddr = 0;
-                hnd->width = width;
-                hnd->height = height;
-                hnd->format = format;
-                *handle = (native_handle_t *)hnd;
-                res = 0;
+                if (hnd) {
+                  hnd->magic = private_handle_t::sMagic;
+                  hnd->fd = fd;
+                  hnd->flags =  private_handle_t::PRIV_FLAGS_USES_ION;
+                  hnd->size = size;
+                  hnd->offset = offset;
+                  hnd->base = uint64_t(base) + offset;
+                  hnd->gpuaddr = 0;
+                  hnd->width = width;
+                  hnd->height = height;
+                  hnd->format = format;
+                  *handle = (native_handle_t *)hnd;
+                  res = 0;
+                }
                 break;
 
             }
@@ -455,6 +457,15 @@
                 res = 0;
             } break;
 
+        case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS:
+            {
+                private_handle_t* hnd = va_arg(args, private_handle_t*);
+                void* rgb_data = va_arg(args, void*);
+                if (!private_handle_t::validate(hnd)) {
+                    res = getRgbDataAddress(hnd, rgb_data);
+                }
+            } break;
+
         default:
             break;
     }
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 7423c29..093b950 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -284,8 +284,9 @@
 
     if (!ctx->mBootAnimCompleted)
         processBootAnimCompleted(ctx);
-    if (LIKELY(list && list->numHwLayers > 1) && ctx->dpyAttr[dpy].connected &&
-            (ctx->dpyAttr[dpy].isActive ||
+    if (LIKELY(list && (list->numHwLayers > 1 ||
+                    ctx->mMDP.version < qdutils::MDP_V4_0)) &&
+        ctx->dpyAttr[dpy].connected && (ctx->dpyAttr[dpy].isActive ||
              ctx->mHDMIDisplay->isHDMIPrimaryDisplay())
             && !ctx->dpyAttr[dpy].isPause) {
 
@@ -623,7 +624,8 @@
             supported |= HWC_DISPLAY_VIRTUAL_BIT;
             if(!(qdutils::MDPVersion::getInstance().is8x26() ||
                         qdutils::MDPVersion::getInstance().is8x16() ||
-                        qdutils::MDPVersion::getInstance().is8x39()))
+                        qdutils::MDPVersion::getInstance().is8x39() ||
+                        qdutils::MDPVersion::getInstance().is8x52()))
                 supported |= HWC_DISPLAY_EXTERNAL_BIT;
         }
         value[0] = supported;
diff --git a/libhwcomposer/hwc_copybit.cpp b/libhwcomposer/hwc_copybit.cpp
index d7b6278..00bd643 100644
--- a/libhwcomposer/hwc_copybit.cpp
+++ b/libhwcomposer/hwc_copybit.cpp
@@ -562,17 +562,13 @@
     mDirtyLayerIndex =  checkDirtyRect(ctx, list, dpy);
     ALOGD_IF (DEBUG_COPYBIT, "%s:Dirty Layer Index: %d",
                                        __FUNCTION__, mDirtyLayerIndex);
-    // repetitive frame will have mDirtyLayerIndex as NO_UPDATING_LAYER
-    if (mDirtyLayerIndex == NO_UPDATING_LAYER) {
-        ALOGD_IF (DEBUG_COPYBIT, "%s: No Updating Layers", __FUNCTION__);
-        return true;
-    }
 
     hwc_rect_t clearRegion = {0,0,0,0};
     mDirtyRect = list->hwLayers[last].displayFrame;
 
-    if (CBUtils::getuiClearRegion(list, clearRegion, layerProp,
-                                                       mDirtyLayerIndex)) {
+    if (mDirtyLayerIndex != NO_UPDATING_LAYER &&
+            CBUtils::getuiClearRegion(list, clearRegion, layerProp,
+                                                    mDirtyLayerIndex)) {
        int clear_w =  clearRegion.right -  clearRegion.left;
        int clear_h =  clearRegion.bottom - clearRegion.top;
        //mdp can't handle solid fill for one line
@@ -584,8 +580,13 @@
        }else
            clear(renderBuffer, clearRegion);
     }
-    if (mDirtyLayerIndex != -1)
-           mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
+    if (mDirtyLayerIndex != -1) {
+        if (mDirtyLayerIndex == NO_UPDATING_LAYER) {
+            mDirtyRect = clearRegion;
+        } else {
+            mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
+        }
+    }
 
     // numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag
     for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) {
@@ -1071,7 +1072,8 @@
     copybit->set_parameter(copybit, COPYBIT_DITHER,
                              (dst.format == HAL_PIXEL_FORMAT_RGB_565)?
                                              COPYBIT_ENABLE : COPYBIT_DISABLE);
-    copybit->set_parameter(copybit, COPYBIT_FG_LAYER, isFG ?
+    copybit->set_parameter(copybit, COPYBIT_FG_LAYER,
+                           (layer->blending == HWC_BLENDING_NONE || isFG ) ?
                                              COPYBIT_ENABLE : COPYBIT_DISABLE);
 
     copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,
@@ -1200,12 +1202,6 @@
 }
 
 void CopyBit::setReleaseFd(int fd) {
-    if(mRelFd[mCurRenderBufferIndex] >=0)
-        close(mRelFd[mCurRenderBufferIndex]);
-    mRelFd[mCurRenderBufferIndex] = dup(fd);
-}
-
-void CopyBit::setReleaseFdSync(int fd) {
     if (mRelFd[mCurRenderBufferIndex] >=0) {
         int ret = -1;
         ret = sync_wait(mRelFd[mCurRenderBufferIndex], 1000);
diff --git a/libhwcomposer/hwc_copybit.h b/libhwcomposer/hwc_copybit.h
index b67e1b8..993c790 100644
--- a/libhwcomposer/hwc_copybit.h
+++ b/libhwcomposer/hwc_copybit.h
@@ -51,8 +51,6 @@
 
     void setReleaseFd(int fd);
 
-    void setReleaseFdSync(int fd);
-
     bool prepareOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list);
 
     int drawOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list);
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index ced2e84..e2c4677 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -178,10 +178,11 @@
 
     bool defaultPTOR = false;
     //Enable PTOR when "persist.hwc.ptor.enable" is not defined for
-    //8x16 and 8x39 targets by default
+    //Bear family targets by default
     if((property_get("persist.hwc.ptor.enable", property, NULL) <= 0) &&
             (qdutils::MDPVersion::getInstance().is8x16() ||
-                qdutils::MDPVersion::getInstance().is8x39())) {
+             qdutils::MDPVersion::getInstance().is8x39() ||
+             qdutils::MDPVersion::getInstance().is8x52())) {
         defaultPTOR = true;
     }
 
@@ -553,18 +554,15 @@
     if(!isEnabled()) {
         ALOGD_IF(isDebug(),"%s: MDP Comp. not enabled.", __FUNCTION__);
         ret = false;
-    } else if((qdutils::MDPVersion::getInstance().is8x26() ||
-               qdutils::MDPVersion::getInstance().is8x16() ||
-               qdutils::MDPVersion::getInstance().is8x39()) &&
-            ctx->mVideoTransFlag &&
-            isSecondaryConnected(ctx)) {
+    } else if(ctx->mVideoTransFlag && isSecondaryConnected(ctx)) {
         //1 Padding round to shift pipes across mixers
         ALOGD_IF(isDebug(),"%s: MDP Comp. video transition padding round",
                 __FUNCTION__);
         ret = false;
     } else if((qdutils::MDPVersion::getInstance().is8x26() ||
                qdutils::MDPVersion::getInstance().is8x16() ||
-               qdutils::MDPVersion::getInstance().is8x39()) &&
+               qdutils::MDPVersion::getInstance().is8x39() ||
+               qdutils::MDPVersion::getInstance().is8x52()) &&
               !mDpy && isSecondaryAnimating(ctx) &&
               isYuvPresent(ctx,HWC_DISPLAY_VIRTUAL)) {
         ALOGD_IF(isDebug(),"%s: Display animation in progress",
@@ -947,6 +945,15 @@
         }
     }
 
+    if(!mDpy && isSecondaryConnected(ctx) &&
+           (qdutils::MDPVersion::getInstance().is8x16() ||
+            qdutils::MDPVersion::getInstance().is8x26() ||
+            qdutils::MDPVersion::getInstance().is8x39()) &&
+           isYuvPresent(ctx, HWC_DISPLAY_VIRTUAL)) {
+        ALOGD_IF(isDebug(), "%s: YUV layer present on secondary", __FUNCTION__);
+        return false;
+    }
+
     mCurrentFrame.fbCount = 0;
     memcpy(&mCurrentFrame.isFBComposed, &mCurrentFrame.drop,
            sizeof(mCurrentFrame.isFBComposed));
@@ -1005,6 +1012,15 @@
         }
     }
 
+    if(!mDpy && isSecondaryConnected(ctx) &&
+           (qdutils::MDPVersion::getInstance().is8x16() ||
+            qdutils::MDPVersion::getInstance().is8x26() ||
+            qdutils::MDPVersion::getInstance().is8x39()) &&
+           isYuvPresent(ctx, HWC_DISPLAY_VIRTUAL)) {
+        ALOGD_IF(isDebug(), "%s: YUV layer present on secondary", __FUNCTION__);
+        return false;
+    }
+
     /* We cannot use this composition mode, if:
      1. A below layer needs scaling.
      2. Overlap is not peripheral to display.
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index 5ceaa6d..79235ff 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -554,7 +554,37 @@
     }
 }
 
-//Helper to roundoff the refreshrates
+uint32_t getRefreshRate(hwc_context_t* ctx, uint32_t requestedRefreshRate) {
+
+    qdutils::MDPVersion& mdpHw = qdutils::MDPVersion::getInstance();
+    int dpy = HWC_DISPLAY_PRIMARY;
+    uint32_t defaultRefreshRate = ctx->dpyAttr[dpy].refreshRate;
+    uint32_t rate = defaultRefreshRate;
+
+    if(!requestedRefreshRate)
+        return defaultRefreshRate;
+
+    uint32_t maxNumIterations =
+            (uint32_t)ceil(
+                    (float)mdpHw.getMaxFpsSupported()/
+                    (float)requestedRefreshRate);
+
+    for(uint32_t i = 1; i <= maxNumIterations; i++) {
+        rate = roundOff(i * requestedRefreshRate);
+        if(rate < mdpHw.getMinFpsSupported()) {
+            continue;
+        } else if((rate >= mdpHw.getMinFpsSupported() &&
+                   rate <= mdpHw.getMaxFpsSupported())) {
+            break;
+        } else {
+            rate = defaultRefreshRate;
+            break;
+        }
+    }
+    return rate;
+}
+
+//Helper to roundoff the refreshrates to the std refresh-rates
 uint32_t roundOff(uint32_t refreshRate) {
     int count =  (int) (sizeof(stdRefreshRates)/sizeof(stdRefreshRates[0]));
     uint32_t rate = refreshRate;
@@ -1196,21 +1226,18 @@
 
 #ifdef DYNAMIC_FPS
         if (!dpy && mdpHw.isDynFpsSupported() && ctx->mUseMetaDataRefreshRate){
-            //dyn fps: get refreshrate from metadata
-            //Support multiple refresh rates if they are same
-            //else set to  default
+            /* Dyn fps: get refreshrate from metadata */
             MetaData_t *mdata = hnd ? (MetaData_t *)hnd->base_metadata : NULL;
             if (mdata && (mdata->operation & UPDATE_REFRESH_RATE)) {
                 // Valid refreshRate in metadata and within the range
-                uint32_t rate = roundOff(mdata->refreshrate);
-                if((rate >= mdpHw.getMinFpsSupported() &&
-                                rate <= mdpHw.getMaxFpsSupported())) {
-                    if (!refreshRate) {
-                        refreshRate = rate;
-                    } else if(refreshRate != rate) {
-                        // multiple refreshrate requests, set to default
-                        refreshRate = ctx->dpyAttr[dpy].refreshRate;
-                    }
+                uint32_t rate = getRefreshRate(ctx, mdata->refreshrate);
+                if (!refreshRate) {
+                    refreshRate = rate;
+                } else if(refreshRate != rate) {
+                    /* Support multiple refresh rates if they are same
+                     * else set to default.
+                     */
+                    refreshRate = ctx->dpyAttr[dpy].refreshRate;
                 }
             }
         }
@@ -1615,34 +1642,9 @@
     }
 }
 
-int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
-        int fd) {
+void hwc_sync_rotator(hwc_context_t *ctx, hwc_display_contents_1_t* list,
+        int dpy) {
     ATRACE_CALL();
-    int ret = 0;
-    int acquireFd[MAX_NUM_APP_LAYERS];
-    int count = 0;
-    int releaseFd = -1;
-    int retireFd = -1;
-    int fbFd = -1;
-    bool swapzero = false;
-
-    struct mdp_buf_sync data;
-    memset(&data, 0, sizeof(data));
-    data.acq_fen_fd = acquireFd;
-    data.rel_fen_fd = &releaseFd;
-    data.retire_fen_fd = &retireFd;
-    data.flags = MDP_BUF_SYNC_FLAG_RETIRE_FENCE;
-
-    char property[PROPERTY_VALUE_MAX];
-    if(property_get("debug.egl.swapinterval", property, "1") > 0) {
-        if(atoi(property) == 0)
-            swapzero = true;
-    }
-
-    bool isExtAnimating = false;
-    if(dpy)
-       isExtAnimating = ctx->listStats[dpy].isDisplayAnimating;
-
     //Send acquireFenceFds to rotator
     for(uint32_t i = 0; i < ctx->mLayerRotMap[dpy]->getCount(); i++) {
         int rotFd = ctx->mRotMgr->getRotDevFd();
@@ -1662,7 +1664,7 @@
             rotData.acq_fen_fd_cnt = 1; //1 ioctl call per rot session
         }
         int ret = 0;
-        if(LIKELY(!swapzero) and (not ctx->mLayerRotMap[dpy]->isRotCached(i)))
+        if(not ctx->mLayerRotMap[dpy]->isRotCached(i))
             ret = ioctl(rotFd, MSMFB_BUFFER_SYNC, &rotData);
 
         if(ret < 0) {
@@ -1680,58 +1682,61 @@
                     rotReleaseFd;
         }
     }
+}
+
+int hwc_sync_mdss(hwc_context_t *ctx, hwc_display_contents_1_t *list, int dpy,
+        bool isExtAnimating, int fd) {
+    ATRACE_CALL();
+    int ret = 0;
+    int acquireFd[MAX_NUM_APP_LAYERS];
+    int count = 0;
+    int releaseFd = -1;
+    int retireFd = -1;
+    int fbFd = ctx->dpyAttr[dpy].fd;
+
+    struct mdp_buf_sync data;
+    memset(&data, 0, sizeof(data));
+    data.acq_fen_fd = acquireFd;
+    data.rel_fen_fd = &releaseFd;
+    data.retire_fen_fd = &retireFd;
+    data.flags = MDP_BUF_SYNC_FLAG_RETIRE_FENCE;
 
     //Accumulate acquireFenceFds for MDP Overlays
     if(list->outbufAcquireFenceFd >= 0) {
         //Writeback output buffer
-        if(LIKELY(!swapzero) )
-            acquireFd[count++] = list->outbufAcquireFenceFd;
+        acquireFd[count++] = list->outbufAcquireFenceFd;
     }
 
     for(uint32_t i = 0; i < list->numHwLayers; i++) {
         if(((isAbcInUse(ctx)== true ) ||
           (list->hwLayers[i].compositionType == HWC_OVERLAY)) &&
                         list->hwLayers[i].acquireFenceFd >= 0) {
-            if(LIKELY(!swapzero) ) {
-                // if ABC is enabled for more than one layer.
-                // renderBufIndexforABC will work as FB.Hence
-                // set the acquireFD from fd - which is coming from copybit
-                if(fd >= 0 && (isAbcInUse(ctx) == true)) {
-                    if(ctx->listStats[dpy].renderBufIndexforABC ==(int32_t)i)
-                        acquireFd[count++] = fd;
-                    else
-                        continue;
-                } else
-                    acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
-            }
+            // if ABC is enabled for more than one layer.
+            // renderBufIndexforABC will work as FB.Hence
+            // set the acquireFD from fd - which is coming from copybit
+            if(fd >= 0 && (isAbcInUse(ctx) == true)) {
+                if(ctx->listStats[dpy].renderBufIndexforABC ==(int32_t)i)
+                    acquireFd[count++] = fd;
+                else
+                    continue;
+            } else
+                acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
         }
         if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
-            if(LIKELY(!swapzero) ) {
-                if(fd >= 0) {
-                    //set the acquireFD from fd - which is coming from c2d
-                    acquireFd[count++] = fd;
-                    // Buffer sync IOCTL should be async when using c2d fence is
-                    // used
-                    data.flags &= ~MDP_BUF_SYNC_FLAG_WAIT;
-                } else if(list->hwLayers[i].acquireFenceFd >= 0)
-                    acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
-            }
+            if(fd >= 0) {
+                //set the acquireFD from fd - which is coming from c2d
+                acquireFd[count++] = fd;
+                // Buffer sync IOCTL should be async when using c2d fence
+                data.flags &= ~MDP_BUF_SYNC_FLAG_WAIT;
+            } else if(list->hwLayers[i].acquireFenceFd >= 0)
+                acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
         }
     }
 
-    if ((fd >= 0) && !dpy && ctx->mPtorInfo.isActive()) {
-        // Acquire c2d fence of Overlap render buffer
-        if(LIKELY(!swapzero) )
-            acquireFd[count++] = fd;
-    }
-
     data.acq_fen_fd_cnt = count;
-    fbFd = ctx->dpyAttr[dpy].fd;
 
     //Waits for acquire fences, returns a release fence
-    if(LIKELY(!swapzero)) {
-        ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data);
-    }
+    ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data);
 
     if(ret < 0) {
         ALOGE("%s: ioctl MSMFB_BUFFER_SYNC failed, err=%s",
@@ -1752,9 +1757,7 @@
 #endif
            list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
             //Populate releaseFenceFds.
-            if(UNLIKELY(swapzero)) {
-                list->hwLayers[i].releaseFenceFd = -1;
-            } else if(isExtAnimating) {
+            if(isExtAnimating) {
                 // Release all the app layer fds immediately,
                 // if animation is in progress.
                 list->hwLayers[i].releaseFenceFd = -1;
@@ -1781,16 +1784,11 @@
         }
     }
 
-    if(fd >= 0) {
-        close(fd);
-        fd = -1;
-    }
-
     if (ctx->mCopyBit[dpy]) {
-        if (!dpy && ctx->mPtorInfo.isActive())
-            ctx->mCopyBit[dpy]->setReleaseFdSync(releaseFd);
-        else
+        if((!dpy && ctx->mPtorInfo.isActive()) or
+           ctx->mMDP.version < qdutils::MDP_V4_0) {
             ctx->mCopyBit[dpy]->setReleaseFd(releaseFd);
+        }
     }
 
     //Signals when MDP finishes reading rotator buffers.
@@ -1798,11 +1796,59 @@
     close(releaseFd);
     releaseFd = -1;
 
-    if(UNLIKELY(swapzero)) {
-        list->retireFenceFd = -1;
-    } else {
-        list->retireFenceFd = retireFd;
+    list->retireFenceFd = retireFd;
+
+    return ret;
+}
+
+void hwc_sync_sz(hwc_context_t* ctx, hwc_display_contents_1_t* list, int dpy) {
+    ATRACE_CALL();
+    for(uint32_t i = 0; i < list->numHwLayers; i++) {
+        list->hwLayers[i].releaseFenceFd = -1;
     }
+
+    if (ctx->mCopyBit[dpy]) {
+        if((!dpy && ctx->mPtorInfo.isActive()) or
+           ctx->mMDP.version < qdutils::MDP_V4_0) {
+            ctx->mCopyBit[dpy]->setReleaseFd(-1);
+        }
+    }
+
+    ctx->mLayerRotMap[dpy]->setReleaseFd(-1);
+
+    list->retireFenceFd = -1;
+}
+
+int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
+        int fd) {
+    ATRACE_CALL();
+    int ret = 0;
+
+    bool isExtAnimating = false;
+    if(dpy)
+        isExtAnimating = ctx->listStats[dpy].isDisplayAnimating;
+
+    bool swapzero = false;
+    char property[PROPERTY_VALUE_MAX];
+    if(property_get("debug.egl.swapinterval", property, "1") > 0) {
+        if(atoi(property) == 0)
+            swapzero = true;
+    }
+
+    if(swapzero) {
+        hwc_sync_sz(ctx, list, dpy);
+    } else {
+        hwc_sync_rotator(ctx, list, dpy);
+        ret = hwc_sync_mdss(ctx, list, dpy,
+                            isExtAnimating, fd);
+    }
+
+    if(fd >= 0) {
+        close(fd);
+        fd = -1;
+    }
+
+
     return ret;
 }
 
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index 59056b6..4849baf 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -353,6 +353,8 @@
 void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
                                 hwc_rect_t& inRect, hwc_rect_t& outRect);
 
+uint32_t getRefreshRate(hwc_context_t* ctx, uint32_t requestedRefreshRate);
+
 uint32_t roundOff(uint32_t refreshRate);
 
 void setRefreshRate(hwc_context_t *ctx, int dpy, uint32_t refreshRate);
@@ -396,6 +398,17 @@
 //Close acquireFenceFds of all layers of incoming list
 void closeAcquireFds(hwc_display_contents_1_t* list);
 
+//Sync point impl if swapinterval is set to 0
+void hwc_sync_sz(hwc_context_t* ctx, hwc_display_contents_1_t* list, int dpy);
+
+//Sync point impl for rotator
+void hwc_sync_rotator(hwc_context_t *ctx, hwc_display_contents_1_t* list,
+        int dpy);
+
+//Sync point impl for mdss
+int hwc_sync_mdss(hwc_context_t *ctx, hwc_display_contents_1_t *list, int dpy,
+        bool isExtAnimating, int fd);
+
 //Sync point impl.
 int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
         int fd);
diff --git a/liboverlay/overlay.cpp b/liboverlay/overlay.cpp
index b7c7fcc..da24382 100644
--- a/liboverlay/overlay.cpp
+++ b/liboverlay/overlay.cpp
@@ -149,10 +149,10 @@
         return getPipe_8x16(pipeSpecs);
     } else if(MDPVersion::getInstance().is8x39()) {
         return getPipe_8x39(pipeSpecs);
+    } else if(MDPVersion::getInstance().is8x52()) {
+        return getPipe_8x52(pipeSpecs);
     } else if(MDPVersion::getInstance().is8994()) {
         return getPipe_8994(pipeSpecs);
-    } else if(MDPVersion::getInstance().is8992()) {
-        return getPipe_8992(pipeSpecs);
     }
 
     eDest dest = OV_INVALID;
@@ -247,19 +247,18 @@
     return getPipe_8x16(pipeSpecs);
 }
 
+utils::eDest Overlay::getPipe_8x52(const PipeSpecs& pipeSpecs) {
+    //8x16 & 8x52 has same number of pipes, pipe-types & scaling capabilities.
+    //Rely on 8x16 until we see a need to change.
+    return getPipe_8x16(pipeSpecs);
+}
+
 utils::eDest Overlay::getPipe_8994(const PipeSpecs& pipeSpecs) {
     //If DMA pipes need to be used in block mode for downscale, there could be
     //cases where consecutive rounds need separate modes, which cannot be
     //supported since we at least need 1 round in between where the DMA is
     //unused
     eDest dest = OV_INVALID;
-
-    // Reset format type to FORMAT_NONE to select the pipe irrespective of the
-    // format specifed by the client. This is required for the device where
-    // SMP starvation is unlikely, we need not keep track of formats
-    // programmed in the pipes to avoid potential pipe crunching.
-    resetPipeBookFormat(pipeSpecs.dpy);
-
     if(pipeSpecs.formatClass == FORMAT_YUV) {
         return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
     } else {
@@ -271,14 +270,9 @@
             dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
     }
-
     return dest;
 }
 
-utils::eDest Overlay::getPipe_8992(const PipeSpecs& pipeSpecs) {
-    return getPipe_8994(pipeSpecs);
-}
-
 void Overlay::endAllSessions() {
     for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
         if(mPipeBook[i].valid() && mPipeBook[i].mSession==PipeBook::START)
diff --git a/liboverlay/overlay.h b/liboverlay/overlay.h
index 49be930..affb4db 100644
--- a/liboverlay/overlay.h
+++ b/liboverlay/overlay.h
@@ -177,10 +177,8 @@
     utils::eDest getPipe_8x26(const PipeSpecs& pipeSpecs);
     utils::eDest getPipe_8x16(const PipeSpecs& pipeSpecs);
     utils::eDest getPipe_8x39(const PipeSpecs& pipeSpecs);
+    utils::eDest getPipe_8x52(const PipeSpecs& pipeSpecs);
     utils::eDest getPipe_8994(const PipeSpecs& pipeSpecs);
-    utils::eDest getPipe_8992(const PipeSpecs& pipeSpecs);
-
-    void resetPipeBookFormat(const int &dpy);
 
     /* Returns the handle to libscale.so's programScale function */
     static int (*getFnProgramScale())(struct mdp_overlay_list *);
@@ -344,7 +342,8 @@
 inline bool Overlay::isUIScalingOnExternalSupported() {
     if(qdutils::MDPVersion::getInstance().is8x26() or
        qdutils::MDPVersion::getInstance().is8x16() or
-       qdutils::MDPVersion::getInstance().is8x39()) {
+       qdutils::MDPVersion::getInstance().is8x39() or
+       qdutils::MDPVersion::getInstance().is8x52()) {
         return false;
     }
     return true;
@@ -446,14 +445,6 @@
     return "Invalid";
 }
 
-inline void Overlay::resetPipeBookFormat(const int &dpy) {
-    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
-        if (mPipeBook[i].mDisplay == dpy) {
-            mPipeBook[i].mFormatType = FORMAT_NONE;
-        }
-    }
-}
-
 }; // overlay
 
 #endif // OVERLAY_H
diff --git a/liboverlay/overlayMdp.cpp b/liboverlay/overlayMdp.cpp
index 828f4fc..95bdc23 100644
--- a/liboverlay/overlayMdp.cpp
+++ b/liboverlay/overlayMdp.cpp
@@ -399,7 +399,7 @@
     int errVal = mdp_wrapper::validateAndSet(fbFd, list);
     if(errVal) {
         /* No dump for failure due to insufficient resource */
-        if(errVal != E2BIG) {
+        if(errVal != E2BIG && errVal != EBADSLT) {
             //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
diff --git a/libqdutils/display_config.cpp b/libqdutils/display_config.cpp
index 350192d..0c62ffe 100644
--- a/libqdutils/display_config.cpp
+++ b/libqdutils/display_config.cpp
@@ -440,3 +440,12 @@
     ret = screenRefresh();
     return ret;
 }
+
+// ----------------------------------------------------------------------------
+// Native daemons needs to send enable partial update ack for PU to enable
+// ----------------------------------------------------------------------------
+extern "C" int setPartialUpdateState() {
+    int ret = 0;
+    ret = setPartialUpdate(IQService::ENABLE_PARTIAL_UPDATE);
+    return ret;
+}
diff --git a/libqdutils/mdp_version.cpp b/libqdutils/mdp_version.cpp
index c02e28d..f62f3d0 100644
--- a/libqdutils/mdp_version.cpp
+++ b/libqdutils/mdp_version.cpp
@@ -77,6 +77,15 @@
 #ifndef MDSS_MDP_HW_REV_110
 #define MDSS_MDP_HW_REV_110 0x100a0000 //8992
 #endif
+#ifndef MDSS_MDP_HW_REV_111
+#define MDSS_MDP_HW_REV_111 0x100b0000 //Unused or Next version
+#endif
+#ifndef MDSS_MDP_HW_REV_112
+#define MDSS_MDP_HW_REV_112 0x100c0000 // 8x52
+#endif
+#ifndef MDSS_MDP_HW_REV_113
+#define MDSS_MDP_HW_REV_113 0x100d0000 //Unused Next version
+#endif
 #ifndef MDSS_MDP_HW_REV_200
 #define MDSS_MDP_HW_REV_200 0x20000000 //8092
 #endif
@@ -516,5 +525,10 @@
             mMdpRev < MDSS_MDP_HW_REV_200));
 }
 
+bool MDPVersion::is8x52() {
+    return (mMdpRev >= MDSS_MDP_HW_REV_112 and
+            mMdpRev < MDSS_MDP_HW_REV_113);
+}
+
 }; //namespace qdutils
 
diff --git a/libqdutils/mdp_version.h b/libqdutils/mdp_version.h
index 6ebe558..25356f8 100644
--- a/libqdutils/mdp_version.h
+++ b/libqdutils/mdp_version.h
@@ -153,6 +153,7 @@
     bool is8994();
     bool is8x16();
     bool is8x39();
+    bool is8x52();
     bool is8992();
     bool updateSplitInfo();
 
diff --git a/libqservice/IQService.h b/libqservice/IQService.h
index 5054578..1f28cee 100644
--- a/libqservice/IQService.h
+++ b/libqservice/IQService.h
@@ -88,8 +88,8 @@
     };
 
     enum {
-        PREF_PARTIAL_UPDATE,
         PREF_POST_PROCESSING,
+        PREF_PARTIAL_UPDATE,
         ENABLE_PARTIAL_UPDATE,
     };