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/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/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 1ca7c16..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;
   }
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index c445418..ae638e0 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -36,8 +36,7 @@
 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,
                                const HWPanelInfo &hw_panel_info, Handle *res_mgr_hnd);
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 be3b3a8..8725a7b 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -26,7 +26,7 @@
 #include <utils/debug.h>
 
 #include "display_base.h"
-#include "offline_ctrl.h"
+#include "rotator_ctrl.h"
 
 #define __CLASS__ "DisplayBase"
 
@@ -35,10 +35,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) {
 }
@@ -79,9 +79,11 @@
     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 +104,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 +141,13 @@
         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_);
+      }
+
       if (error == kErrorNone) {
         error = hw_intf_->Validate(&hw_layers_);
         if (error == kErrorNone) {
@@ -162,30 +172,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;
 }
 
@@ -406,10 +427,13 @@
     Layer &layer = hw_layers_.info.stack->layers[hw_layers_.info.index[i]];
     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;
+    HWRotateInfo &left_rotate = hw_rotator_session.hw_rotate_info[0];
+    HWRotateInfo &right_rotate = hw_rotator_session.hw_rotate_info[1];
 
     DumpImpl::AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i,
                            hw_layers_.info.index[i]);
@@ -458,5 +482,20 @@
   return (num_modes_ == 1) ? 0 : -1;
 }
 
+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;
+}
+
 }  // namespace sde
 
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 6d107a0..1edef9e 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();
@@ -61,6 +60,9 @@
   virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
   virtual DisplayError SetDisplayMode(uint32_t mode);
 
+ private:
+  bool IsRotationRequired(HWLayers *hw_layers);
+
  protected:
   // DumpImpl method
   void AppendDump(char *buffer, uint32_t length);
@@ -75,11 +77,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..1a96884 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -36,7 +36,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 1dcd05b..d6116fa 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() {
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index da84fe6..be422de 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -36,7 +36,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);
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..8e7a764 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -36,7 +36,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/fb/hw_device.cpp b/displayengine/libs/core/fb/hw_device.cpp
index 685d322..230092a 100644
--- a/displayengine/libs/core/fb/hw_device.cpp
+++ b/displayengine/libs/core/fb/hw_device.cpp
@@ -213,14 +213,15 @@
     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;
     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) {
@@ -276,8 +277,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,
@@ -309,11 +311,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;
@@ -330,13 +332,13 @@
   mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
   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;
     DLOGE("src rect: x = %d, y = %d, w = %d, h = %d",
@@ -365,13 +367,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) {
@@ -420,11 +423,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;
@@ -446,8 +449,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);
@@ -455,9 +459,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;
@@ -467,7 +471,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);
 
@@ -531,7 +535,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;
diff --git a/displayengine/libs/core/fb/hw_rotator.cpp b/displayengine/libs/core/fb/hw_rotator.cpp
index cc9caa5..cc9bd1a 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,64 +85,93 @@
   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;
@@ -156,8 +185,8 @@
           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 +194,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 +210,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 +223,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 +233,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;
 
@@ -243,7 +275,7 @@
 }
 
 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 +290,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 +302,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 +326,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..3b4eebe 100644
--- a/displayengine/libs/core/fb/hw_rotator.h
+++ b/displayengine/libs/core/fb/hw_rotator.h
@@ -44,15 +44,15 @@
   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);
 
   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/hw_interface.h b/displayengine/libs/core/hw_interface.h
index 09fb6a9..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 {
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 ecd8ef1..3cea3db 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -44,7 +44,8 @@
 
 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(layer.transform.rotation);
@@ -54,7 +55,7 @@
   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(layer.input_buffer->format, &align_x, &align_y);
 
@@ -79,21 +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 output_format;
+  LayerBufferFormat *output_format = &hw_rotator_session->output_buffer.format;
   SetRotatorOutputFormat(layer.input_buffer->format, is_opaque, rot90, (downscale > 1.0f),
-                         &output_format);
-  HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-  hw_buffer_info->buffer_config.format = output_format;
-  hw_buffer_info->buffer_config.width = UINT32(rotate->dst_roi.right);
-  hw_buffer_info->buffer_config.height = UINT32(rotate->dst_roi.bottom);
+                         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)++;
 }
 
@@ -254,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 rot90 = IsRotationNeeded(transform.rotation);
 
     if (!CalculateCropRects(scissor, layer.transform, &src_rect, &dst_rect)) {
       layer_config->Reset();
@@ -274,12 +274,11 @@
 
     // 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) {
+    if (rot90 || UINT32(rot_scale) != 1) {
       RotationConfig(layer, rot_scale, &src_rect, layer_config, rotate_count);
       // rotator will take care of flipping, reset tranform
       transform = LayerTransform();
@@ -306,10 +305,10 @@
              i, layer_config->left_pipe.valid);
     Log(kTagResources, "input layer src_rect", layer.src_rect);
     Log(kTagResources, "input layer dst_rect", layer.dst_rect);
-    for (uint32_t k = 0; k < layer_config->num_rotate; k++) {
+    for (uint32_t k = 0; k < hw_rotator_session->hw_block_count; k++) {
       DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rot_scale);
-      Log(kTagResources, "rotate src", layer_config->rotates[k].src_roi);
-      Log(kTagResources, "rotate dst", layer_config->rotates[k].dst_roi);
+      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);
     }
 
     Log(kTagResources, "cropped src_rect", src_rect);
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index 4101fc8..08b055b 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -39,19 +39,12 @@
     buffer_allocator_(NULL), buffer_sync_handler_(NULL) {
 }
 
-DisplayError ResManager::Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
-                              BufferSyncHandler *buffer_sync_handler) {
+DisplayError ResManager::Init(const HWResourceInfo &hw_res_info) {
   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 error = kErrorNone;
 
   num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
@@ -173,13 +166,6 @@
   }
 
   display_resource_ctx->hw_panel_info_ = hw_panel_info;
-  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;
-  }
-
   hw_block_ctx_[hw_block_id].is_in_use = true;
 
   display_resource_ctx->display_attributes = attributes;
@@ -315,6 +301,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
@@ -322,8 +309,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;
@@ -406,12 +393,6 @@
     goto CleanupOnError;
   }
 
-  error = AllocRotatorBuffer(display_ctx, hw_layers);
-  if (error != kErrorNone) {
-    DLOGV_IF(kTagResources, "Rotator buffer allocation failed");
-    goto CleanupOnError;
-  }
-
   return kErrorNone;
 
 CleanupOnError:
@@ -662,84 +643,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;
 }
@@ -799,35 +704,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;
 }
 
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index 1653c0a..a127645 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -31,15 +31,13 @@
 
 #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,
                                const HWPanelInfo &hw_panel_info, Handle *display_ctx);
@@ -117,7 +115,6 @@
 
   struct DisplayResourceContext {
     HWDisplayAttributes display_attributes;
-    BufferManager *buffer_manager;
     DisplayType display_type;
     HWBlockType hw_block_id;
     HWPanelInfo hw_panel_info_;
@@ -129,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 {
@@ -203,7 +193,6 @@
                               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, const bool &is_opaque,
                               const bool &rot90, const bool &downscale,
                               LayerBufferFormat *output_format);
diff --git a/displayengine/libs/core/rotator_ctrl.cpp b/displayengine/libs/core/rotator_ctrl.cpp
new file mode 100644
index 0000000..701006c
--- /dev/null
+++ b/displayengine/libs/core/rotator_ctrl.cpp
@@ -0,0 +1,233 @@
+/*
+* 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) {
+  DisplaRotatorContext *disp_rotator_ctx = new DisplaRotatorContext();
+  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) {
+  DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+  delete disp_rotator_ctx;
+  disp_rotator_ctx = NULL;
+}
+
+
+DisplayError RotatorCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayError error = kErrorNone;
+
+  DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+  error = PrepareSessions(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;
+
+  DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+  error = GetOutputBuffers(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;
+  DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+  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(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::PrepareSessions(HWLayers *hw_layers) {
+  HWLayersInfo &hw_layer_info = hw_layers->info;
+  DisplayError error = kErrorNone;
+
+  session_manager_->Start();
+
+  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(hw_rotator_session);
+    if (error != kErrorNone) {
+      return error;
+    }
+  }
+
+  session_manager_->Stop();
+
+  return kErrorNone;
+}
+
+DisplayError RotatorCtrl::GetOutputBuffers(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]];
+    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+    if (!hw_rotator_session->hw_block_count) {
+      continue;
+    }
+
+    error = session_manager_->GetNextBuffer(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 76%
rename from displayengine/libs/core/offline_ctrl.h
rename to displayengine/libs/core/rotator_ctrl.h
index 1525bb8..083f4ca 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,43 @@
 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);
 
  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 DisplaRotatorContext {
+    DisplayType display_type;
+
+    DisplaRotatorContext() : display_type(kPrimary) { }
+  };
+
+  DisplayError PrepareSessions(HWLayers *hw_layers);
+  DisplayError GetOutputBuffers(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..c81e343 100644
--- a/displayengine/libs/core/scalar_helper.cpp
+++ b/displayengine/libs/core/scalar_helper.cpp
@@ -137,6 +137,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 +153,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..f87bf10
--- /dev/null
+++ b/displayengine/libs/core/session_manager.cpp
@@ -0,0 +1,351 @@
+/*
+* 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() {
+  uint32_t session_count = 0;
+  uint32_t ready_session_count = 0;
+
+  // Change the state of acquired session to kSessionReady
+  while ((ready_session_count < active_session_count_) && (session_count < kMaxSessionCount)) {
+    if (session_list_[session_count].state == kSessionReleased) {
+      session_count++;
+      continue;
+    }
+
+    session_list_[session_count++].state = kSessionReady;
+    ready_session_count++;
+  }
+}
+
+DisplayError SessionManager::OpenSession(HWRotatorSession *hw_rotator_session) {
+  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 ready_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 &&
+       ready_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) {
+      continue;
+    }
+
+    if (input_config == hw_session_config) {
+      session_list_[session_count].state = kSessionAcquired;
+      acquired_session = session_count;
+      break;
+    }
+
+    ready_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;
+    active_session_count_++;
+
+    DLOGV_IF(kTagRotator, "Acquire new session Output: width = %d, height = %d, format = %d, " \
+             "session_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);
+
+    return kErrorNone;
+  }
+
+  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;
+  hw_rotator_session->session_id = acquired_session;
+
+  DLOGV_IF(kTagRotator, "Acquire existing session Output: width = %d, height = %d, format = %d, " \
+           "session_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);
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::GetNextBuffer(HWRotatorSession *hw_rotator_session) {
+  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);
+    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];
+
+  DLOGI_IF(kTagRotator, "Output: width = %d, height = %d, format = %d, stride %d, " \
+           "curr_index = %d, offset %d, fd %d, session_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, hw_rotator_session->session_id);
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::Stop() {
+  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) {
+      error = ReleaseSession(&session_list_[session_id]);
+      if (error != kErrorNone) {
+        return error;
+      }
+      active_session_count_--;
+
+      DLOGI_IF(kTagRotator, "session_id = %d, active_session_count = %d", session_id,
+               active_session_count_);
+    }
+    session_id++;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError SessionManager::SetReleaseFd(HWRotatorSession *hw_rotator_session) {
+  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);
+    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", session_id,
+           curr_index, hw_rotator_session->output_buffer.release_fence_fd);
+
+  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;
+
+  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/buffer_manager.h b/displayengine/libs/core/session_manager.h
similarity index 60%
rename from displayengine/libs/core/buffer_manager.h
rename to displayengine/libs/core/session_manager.h
index 29bcd03..b27ba8b 100644
--- a/displayengine/libs/core/buffer_manager.h
+++ b/displayengine/libs/core/session_manager.h
@@ -27,8 +27,8 @@
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __BUFFER_MANAGER_H__
-#define __BUFFER_MANAGER_H__
+#ifndef __SESSION_MANAGER_H__
+#define __SESSION_MANAGER_H__
 
 #include <utils/locker.h>
 #include <core/buffer_allocator.h>
@@ -36,47 +36,52 @@
 
 namespace sde {
 
-class BufferManager {
+class HWRotatorInterface;
+
+class SessionManager {
  public:
-  BufferManager(BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
+  SessionManager(HWRotatorInterface *hw_intf, 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);
+  DisplayError Stop();
+  DisplayError OpenSession(HWRotatorSession *hw_rotator_session);
+  DisplayError GetNextBuffer(HWRotatorSession *hw_rotator_session);
+  DisplayError SetReleaseFd(HWRotatorSession *hw_rotator_session);
 
  private:
-  static const uint32_t kMaxBufferSlotCount = 32;
+  // TODO(user): Read from hw capability instead of hardcoding
+  static const int kMaxSessionCount = 32;
 
-  enum kBufferSlotState {
-    kBufferSlotFree     = 0,
-    kBufferSlotReady    = 1,
-    kBufferSlotAcquired = 2,
+  enum SessionState {
+    kSessionReleased = 0,
+    kSessionReady    = 1,
+    kSessionAcquired = 2,
   };
 
-  struct BufferSlot {
-    HWBufferInfo hw_buffer_info;
-    kBufferSlotState state;
+  struct Session {
+    HWRotatorSession hw_rotator_session;
+    BufferInfo buffer_info;
+    SessionState 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();
+    Session() : state(kSessionReleased), release_fd(NULL), offset(NULL), curr_index(0) { }
   };
 
-  DisplayError FreeBufferSlot(uint32_t index);
+  DisplayError AcquireSession(HWRotatorSession *hw_rotator_session, Session *session);
+  DisplayError ReleaseSession(Session *session);
 
-  BufferSlot buffer_slot_[kMaxBufferSlotCount];
+  Session session_list_[kMaxSessionCount];
+  HWRotatorInterface *hw_rotator_intf_;
   BufferAllocator *buffer_allocator_;
   BufferSyncHandler *buffer_sync_handler_;
-  uint32_t num_used_slot_;
+  uint32_t active_session_count_;           // number of sessions in ready/acquired state.
 };
 
 }  // namespace sde
 
-#endif  // __BUFFER_MANAGER_H__
+#endif  // __SESSION_MANAGER_H__
 
 
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_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: