diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index 51dfa82..f62653a 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -233,6 +233,9 @@
         dst->fd_metadata, 0);
     if (base_dst == reinterpret_cast<void*>(MAP_FAILED)) {
         ALOGE("%s: dst mmap() failed: error is %s!", __func__, strerror(errno));
+        if(munmap(base_src, size))
+            ALOGE("%s: failed to unmap src ptr %p, err %d", __func__,
+                                             (void*)base_src, errno);
         return -1;
     }
 
diff --git a/sdm/include/core/display_interface.h b/sdm/include/core/display_interface.h
index ccaa0b5..416e01a 100644
--- a/sdm/include/core/display_interface.h
+++ b/sdm/include/core/display_interface.h
@@ -140,6 +140,7 @@
 struct DisplayConfigFixedInfo {
   bool underscan = false;   //!< If display support CE underscan.
   bool secure = false;      //!< If this display is capable of handling secure content.
+  bool is_cmdmode = false;  //!< If panel is command mode panel.
 };
 
 /*! @brief This structure defines configuration for variable properties of a display device.
@@ -597,10 +598,30 @@
 
   /*! @brief Method to query whether it is Primrary device.
 
-    @return \link Bool \endlink
+    @return true if this interface is primary.
   */
   virtual bool IsPrimaryDisplay() = 0;
 
+  /*! @brief Method to toggle composition types handling by SDM.
+
+    @details Client shall call this method to request SDM to enable/disable a specific type of
+    layer composition. If client disables a composition type, SDM will not handle any of the layer
+    composition using the disabled method in a draw cycle. On lack of resources to handle all
+    layers using other enabled composition methods, Prepare() will return an error.
+
+    Request to toggle composition type is applied from subsequent draw cycles.
+
+    Default state of all defined composition types is enabled.
+
+    @param[in] composition_type \link LayerComposition \endlink
+    @param[in] enable \link enable composition type \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa Prepare
+  */
+  virtual DisplayError SetCompositionState(LayerComposition composition_type, bool enable) = 0;
+
  protected:
   virtual ~DisplayInterface() { }
 };
diff --git a/sdm/include/core/layer_stack.h b/sdm/include/core/layer_stack.h
index 0fcab25..2741f71 100644
--- a/sdm/include/core/layer_stack.h
+++ b/sdm/include/core/layer_stack.h
@@ -102,10 +102,10 @@
   /* === List of composition types set by Client === */
   /* These composition types represent target buffer layers onto which GPU or Blit will draw if SDM
      decide to have some or all layers drawn by respective composition engine.
-     If client does not provide a target buffer layer, SDM will assume that respective composition
-     engine is not available and will not mark any layer for such a composition. If SDM is unable
-     to handle layers without support of such a composition engine, Prepare() call will return
-     failure.
+     Client must provide a target buffer layer, if respective composition type is not disabled by
+     an explicit call to SetCompositionState() method. If a composition type is not disabled,
+     providing a target buffer layer is optional. If SDM is unable to handle layers without support
+     of such a composition engine, Prepare() call will return failure.
   */
   kCompositionGPUTarget,    //!< This layer will hold result of composition for layers marked for
                             //!< GPU composition.
diff --git a/sdm/include/private/extension_interface.h b/sdm/include/private/extension_interface.h
index dea127e..fc32616 100644
--- a/sdm/include/private/extension_interface.h
+++ b/sdm/include/private/extension_interface.h
@@ -31,7 +31,6 @@
 #include "partial_update_interface.h"
 #include "strategy_interface.h"
 #include "resource_interface.h"
-#include "rotator_interface.h"
 
 namespace sdm {
 
@@ -68,15 +67,10 @@
 
   virtual DisplayError CreateResourceExtn(const HWResourceInfo &hw_resource_info,
                                           ResourceInterface **interface,
+                                          BufferAllocator *buffer_allocator,
                                           BufferSyncHandler *buffer_sync_handler) = 0;
   virtual DisplayError DestroyResourceExtn(ResourceInterface *interface) = 0;
 
-  virtual DisplayError CreateRotator(const HWRotatorInfo &hw_rot_info,
-                                     BufferAllocator *buffer_allocator,
-                                     BufferSyncHandler *buffer_sync_handler,
-                                     RotatorInterface **intf) = 0;
-  virtual DisplayError DestroyRotator(RotatorInterface *intf) = 0;
-
  protected:
   virtual ~ExtensionInterface() { }
 };
diff --git a/sdm/include/private/partial_update_interface.h b/sdm/include/private/partial_update_interface.h
index 3159b56..b753587 100644
--- a/sdm/include/private/partial_update_interface.h
+++ b/sdm/include/private/partial_update_interface.h
@@ -33,10 +33,17 @@
 
 namespace sdm {
 
+struct PUConstraints {
+  bool enable = true;             //!< If this is set, PU will be enabled or it will be disabled
+  bool enable_cursor_pu = false;  //!< If this is set, PU will consider cursor layer in the layer
+                                   //!< stack for cursor partial update
+};
+
 class PartialUpdateInterface {
  public:
+  virtual DisplayError Start(const PUConstraints &pu_constraints) = 0;
   virtual DisplayError GenerateROI(HWLayersInfo *hw_layers_info) = 0;
-  virtual void ControlPartialUpdate(bool enable) = 0;
+  virtual DisplayError Stop() = 0;
 
  protected:
   virtual ~PartialUpdateInterface() { }
diff --git a/sdm/include/private/resource_interface.h b/sdm/include/private/resource_interface.h
index 6115112..3f34e91 100644
--- a/sdm/include/private/resource_interface.h
+++ b/sdm/include/private/resource_interface.h
@@ -44,8 +44,9 @@
                                           const HWMixerAttributes &mixer_attributes) = 0;
   virtual DisplayError Start(Handle display_ctx) = 0;
   virtual DisplayError Stop(Handle display_ctx) = 0;
-  virtual DisplayError Acquire(Handle display_ctx, HWLayers *hw_layers) = 0;
+  virtual DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers) = 0;
+  virtual DisplayError Commit(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual void Purge(Handle display_ctx) = 0;
   virtual DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages) = 0;
diff --git a/sdm/include/private/rotator_interface.h b/sdm/include/private/rotator_interface.h
deleted file mode 100644
index 5432ac2..0000000
--- a/sdm/include/private/rotator_interface.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-* Copyright (c) 2015, The Linux Foundation. All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without modification, are permitted
-* provided that the following conditions are met:
-*    * Redistributions of source code must retain the above copyright notice, this list of
-*      conditions and the following disclaimer.
-*    * Redistributions in binary form must reproduce the above copyright notice, this list of
-*      conditions and the following disclaimer in the documentation and/or other materials provided
-*      with the distribution.
-*    * Neither the name of The Linux Foundation nor the names of its contributors may be used to
-*      endorse or promote products derived from this software without specific prior written
-*      permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-* NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef __ROTATOR_INTERFACE_H__
-#define __ROTATOR_INTERFACE_H__
-
-#include <core/display_interface.h>
-#include <core/buffer_allocator.h>
-#include <core/buffer_sync_handler.h>
-
-#include "hw_info_types.h"
-
-namespace sdm {
-
-class RotatorInterface {
- public:
-  virtual DisplayError RegisterDisplay(DisplayType type, Handle *display_ctx) = 0;
-  virtual void UnregisterDisplay(Handle display_ctx) = 0;
-  virtual DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers) = 0;
-  virtual DisplayError Commit(Handle display_ctx, HWLayers *hw_layers) = 0;
-  virtual DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers) = 0;
-  virtual DisplayError Purge(Handle display_ctx) = 0;
-
- protected:
-  virtual ~RotatorInterface() { }
-};
-
-}  // namespace sdm
-
-#endif  // __ROTATOR_INTERFACE_H__
-
diff --git a/sdm/include/private/strategy_interface.h b/sdm/include/private/strategy_interface.h
index f2bfe23..188c540 100644
--- a/sdm/include/private/strategy_interface.h
+++ b/sdm/include/private/strategy_interface.h
@@ -51,6 +51,7 @@
   virtual DisplayError Reconfigure(HWDisplayMode mode, HWS3DMode s3d_mode,
                                    const HWMixerAttributes &mixer_attributes,
                                    const DisplayConfigVariableInfo &fb_config) = 0;
+  virtual DisplayError SetCompositionState(LayerComposition composition_type, bool enable) = 0;
 
  protected:
   virtual ~StrategyInterface() { }
diff --git a/sdm/libs/core/Android.mk b/sdm/libs/core/Android.mk
index de314ba..f97ff33 100644
--- a/sdm/libs/core/Android.mk
+++ b/sdm/libs/core/Android.mk
@@ -53,6 +53,5 @@
                                  $(SDM_HEADER_PATH)/private/hw_info_types.h \
                                  $(SDM_HEADER_PATH)/private/partial_update_interface.h \
                                  $(SDM_HEADER_PATH)/private/resource_interface.h \
-                                 $(SDM_HEADER_PATH)/private/rotator_interface.h \
                                  $(SDM_HEADER_PATH)/private/strategy_interface.h
 include $(BUILD_COPY_HEADERS)
diff --git a/sdm/libs/core/comp_manager.cpp b/sdm/libs/core/comp_manager.cpp
index 0b66320..b98c74e 100644
--- a/sdm/libs/core/comp_manager.cpp
+++ b/sdm/libs/core/comp_manager.cpp
@@ -35,16 +35,17 @@
 
 DisplayError CompManager::Init(const HWResourceInfo &hw_res_info,
                                ExtensionInterface *extension_intf,
+                               BufferAllocator *buffer_allocator,
                                BufferSyncHandler *buffer_sync_handler) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
 
   if (extension_intf) {
-    error = extension_intf->CreateResourceExtn(hw_res_info, &resource_intf_, buffer_sync_handler);
+    error = extension_intf->CreateResourceExtn(hw_res_info, &resource_intf_, buffer_allocator,
+                                               buffer_sync_handler);
   } else {
-    resource_intf_ = &resource_default_;
-    error = resource_default_.Init(hw_res_info);
+    error = ResourceDefault::CreateResourceDefault(hw_res_info, &resource_intf_);
   }
 
   if (error != kErrorNone) {
@@ -63,7 +64,7 @@
   if (extension_intf_) {
     extension_intf_->DestroyResourceExtn(resource_intf_);
   } else {
-    resource_default_.Deinit();
+    ResourceDefault::DestroyResourceDefault(resource_intf_);
   }
 
   return kErrorNone;
@@ -127,11 +128,11 @@
   return kErrorNone;
 }
 
-DisplayError CompManager::UnregisterDisplay(Handle comp_handle) {
+DisplayError CompManager::UnregisterDisplay(Handle display_ctx) {
   SCOPE_LOCK(locker_);
 
   DisplayCompositionContext *display_comp_ctx =
-                             reinterpret_cast<DisplayCompositionContext *>(comp_handle);
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
 
   if (!display_comp_ctx) {
     return kErrorParameters;
@@ -220,6 +221,9 @@
     constraints->safe_mode = true;
   }
 
+  // Set use_cursor constraint to Strategy
+  constraints->use_cursor = display_comp_ctx->valid_cursor;
+
   // Avoid idle fallback, if there is only one app layer.
   // TODO(user): App layer count will change for hybrid composition
   uint32_t app_layer_count = UINT32(hw_layers->info.stack->layers.size()) - 1;
@@ -227,18 +231,19 @@
     // Handle the idle timeout by falling back
     constraints->safe_mode = true;
   }
-
-  if (SupportLayerAsCursor(comp_handle, hw_layers)) {
-    constraints->use_cursor = true;
-  }
 }
 
 void CompManager::PrePrepare(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
   DisplayCompositionContext *display_comp_ctx =
                              reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+  display_comp_ctx->valid_cursor = SupportLayerAsCursor(display_comp_ctx, hw_layers);
+
+  // pu constraints
+  display_comp_ctx->pu_constraints.enable_cursor_pu = display_comp_ctx->valid_cursor;
+
   display_comp_ctx->strategy->Start(&hw_layers->info, &display_comp_ctx->max_strategies,
-                                    display_comp_ctx->partial_update_enable);
+                                    display_comp_ctx->pu_constraints);
   display_comp_ctx->remaining_strategies = display_comp_ctx->max_strategies;
 }
 
@@ -267,8 +272,8 @@
     }
 
     if (!exit) {
-      error = resource_intf_->Acquire(display_resource_ctx, hw_layers);
-      // Exit if successfully allocated resource, else try next strategy.
+      error = resource_intf_->Prepare(display_resource_ctx, hw_layers);
+      // Exit if successfully prepared resource, else try next strategy.
       exit = (error == kErrorNone);
     }
   }
@@ -299,6 +304,15 @@
   return kErrorNone;
 }
 
+DisplayError CompManager::Commit(Handle display_ctx, HWLayers *hw_layers) {
+  SCOPE_LOCK(locker_);
+
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+
+  return resource_intf_->Commit(display_comp_ctx->display_resource_ctx, hw_layers);
+}
+
 DisplayError CompManager::ReConfigure(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
 
@@ -308,7 +322,7 @@
 
   DisplayError error = kErrorUndefined;
   resource_intf_->Start(display_resource_ctx);
-  error = resource_intf_->Acquire(display_resource_ctx, hw_layers);
+  error = resource_intf_->Prepare(display_resource_ctx, hw_layers);
 
   if (error != kErrorNone) {
     DLOGE("Reconfigure failed for display = %d", display_comp_ctx->display_type);
@@ -402,7 +416,7 @@
 
   DisplayCompositionContext *display_comp_ctx =
                              reinterpret_cast<DisplayCompositionContext *>(display_ctx);
-  display_comp_ctx->partial_update_enable = enable;
+  display_comp_ctx->pu_constraints.enable = enable;
 }
 
 void CompManager::AppendDump(char *buffer, uint32_t length) {
@@ -492,5 +506,14 @@
   return resource_intf_->SetDetailEnhancerData(display_comp_ctx->display_resource_ctx, de_data);
 }
 
-}  // namespace sdm
+DisplayError CompManager::SetCompositionState(Handle display_ctx,
+                                              LayerComposition composition_type, bool enable) {
+  SCOPE_LOCK(locker_);
 
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+
+  return display_comp_ctx->strategy->SetCompositionState(composition_type, enable);
+}
+
+}  // namespace sdm
diff --git a/sdm/libs/core/comp_manager.h b/sdm/libs/core/comp_manager.h
index 688010c..86554b9 100644
--- a/sdm/libs/core/comp_manager.h
+++ b/sdm/libs/core/comp_manager.h
@@ -40,19 +40,20 @@
 class CompManager : public DumpImpl {
  public:
   DisplayError Init(const HWResourceInfo &hw_res_info_, ExtensionInterface *extension_intf,
-                  BufferSyncHandler *buffer_sync_handler);
+                    BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
   DisplayError Deinit();
   DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &display_attributes,
                                const HWPanelInfo &hw_panel_info,
                                const HWMixerAttributes &mixer_attributes,
-                               const DisplayConfigVariableInfo &fb_config, Handle *res_mgr_hnd);
-  DisplayError UnregisterDisplay(Handle res_mgr_hnd);
+                               const DisplayConfigVariableInfo &fb_config, Handle *display_ctx);
+  DisplayError UnregisterDisplay(Handle display_ctx);
   DisplayError ReconfigureDisplay(Handle display_ctx, const HWDisplayAttributes &display_attributes,
                                   const HWPanelInfo &hw_panel_info,
                                   const HWMixerAttributes &mixer_attributes,
                                   const DisplayConfigVariableInfo &fb_config);
   void PrePrepare(Handle display_ctx, HWLayers *hw_layers);
   DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
+  DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
   DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers);
   DisplayError ReConfigure(Handle display_ctx, HWLayers *hw_layers);
   DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
@@ -68,6 +69,8 @@
   DisplayError SetMaxBandwidthMode(HWBwModes mode);
   DisplayError GetScaleLutConfig(HWScaleLutInfo *lut_info);
   DisplayError SetDetailEnhancerData(Handle display_ctx, const DisplayDetailEnhancerData &de_data);
+  DisplayError SetCompositionState(Handle display_ctx, LayerComposition composition_type,
+                                   bool enable);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
@@ -86,15 +89,15 @@
     uint32_t remaining_strategies = 0;
     bool idle_fallback = false;
     bool fallback_ = false;
-    uint32_t partial_update_enable = true;
     // Using primary panel flag of hw panel to configure Constraints. We do not need other hw
     // panel parameters for now.
     bool is_primary_panel = false;
+    bool valid_cursor = false;
+    PUConstraints pu_constraints = {};
   };
 
   Locker locker_;
   ResourceInterface *resource_intf_ = NULL;
-  ResourceDefault resource_default_;
   std::bitset<kDisplayMax> registered_displays_;  // Bit mask of registered displays
   std::bitset<kDisplayMax> configured_displays_;  // Bit mask of sucessfully configured displays
   bool safe_mode_ = false;              // Flag to notify all displays to be in resource crunch
diff --git a/sdm/libs/core/core_impl.cpp b/sdm/libs/core/core_impl.cpp
index 66eb846..5976176 100644
--- a/sdm/libs/core/core_impl.cpp
+++ b/sdm/libs/core/core_impl.cpp
@@ -76,19 +76,11 @@
     goto CleanupOnError;
   }
 
-  error = comp_mgr_.Init(hw_resource_, extension_intf_, buffer_sync_handler_);
+  error = comp_mgr_.Init(hw_resource_, extension_intf_, buffer_allocator_, buffer_sync_handler_);
   if (error != kErrorNone) {
     goto CleanupOnError;
   }
 
-  if (extension_intf_ && hw_resource_.hw_rot_info.num_rotator) {
-    error = extension_intf_->CreateRotator(hw_resource_.hw_rot_info, buffer_allocator_,
-                                           buffer_sync_handler_, &rotator_intf_);
-    if (error != kErrorNone) {
-      DLOGW("rotation is not supported");
-    }
-  }
-
   error = ColorManagerProxy::Init(hw_resource_);
   // if failed, doesn't affect display core functionalities.
   if (error != kErrorNone) {
@@ -108,10 +100,6 @@
 DisplayError CoreImpl::Deinit() {
   SCOPE_LOCK(locker_);
 
-  if (extension_intf_ && hw_resource_.hw_rot_info.num_rotator) {
-    extension_intf_->DestroyRotator(rotator_intf_);
-  }
-
   ColorManagerProxy::Deinit();
 
   comp_mgr_.Deinit();
@@ -133,15 +121,15 @@
   switch (type) {
   case kPrimary:
     display_base = new DisplayPrimary(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                      &comp_mgr_, rotator_intf_);
+                                      &comp_mgr_);
     break;
   case kHDMI:
     display_base = new DisplayHDMI(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                   &comp_mgr_, rotator_intf_);
+                                   &comp_mgr_);
     break;
   case kVirtual:
     display_base = new DisplayVirtual(event_handler, hw_info_intf_, buffer_sync_handler_,
-                                      &comp_mgr_, rotator_intf_);
+                                      &comp_mgr_);
     break;
   default:
     DLOGE("Spurious display type %d", type);
diff --git a/sdm/libs/core/core_impl.h b/sdm/libs/core/core_impl.h
index c2e98c3..459495d 100644
--- a/sdm/libs/core/core_impl.h
+++ b/sdm/libs/core/core_impl.h
@@ -38,9 +38,6 @@
 
 namespace sdm {
 
-class HWInfoInterface;
-class RotatorCtrl;
-
 class CoreImpl : public CoreInterface {
  public:
   // This class implements display core interface revision 1.0.
@@ -63,12 +60,11 @@
 
  protected:
   Locker locker_;
-  BufferAllocator *buffer_allocator_;
-  BufferSyncHandler *buffer_sync_handler_;
+  BufferAllocator *buffer_allocator_ = NULL;
+  BufferSyncHandler *buffer_sync_handler_ = NULL;
   HWResourceInfo hw_resource_;
   CompManager comp_mgr_;
   HWInfoInterface *hw_info_intf_ = NULL;
-  RotatorInterface *rotator_intf_ = NULL;
   DynLib extension_lib_;
   ExtensionInterface *extension_intf_ = NULL;
   CreateExtensionInterface create_extension_intf_ = NULL;
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index d7036e3..efd408d 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -41,11 +41,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, RotatorInterface *rotator_intf,
-                         HWInfoInterface *hw_info_intf)
+                         CompManager *comp_manager, HWInfoInterface *hw_info_intf)
   : display_type_(display_type), event_handler_(event_handler), hw_device_type_(hw_device_type),
     buffer_sync_handler_(buffer_sync_handler), comp_manager_(comp_manager),
-    rotator_intf_(rotator_intf), hw_info_intf_(hw_info_intf) {
+    hw_info_intf_(hw_info_intf) {
 }
 
 DisplayError DisplayBase::Init() {
@@ -90,13 +89,6 @@
     goto CleanupOnError;
   }
 
-  if (rotator_intf_) {
-    error = rotator_intf_->RegisterDisplay(display_type_, &display_rotator_ctx_);
-    if (error != kErrorNone) {
-      goto CleanupOnError;
-    }
-  }
-
   if (hw_info_intf_) {
     HWResourceInfo hw_resource_info = HWResourceInfo();
     hw_info_intf_->GetHWResourceInfo(&hw_resource_info);
@@ -126,9 +118,6 @@
 
 DisplayError DisplayBase::Deinit() {
   lock_guard<recursive_mutex> obj(recursive_mutex_);
-  if (rotator_intf_) {
-    rotator_intf_->UnregisterDisplay(display_rotator_ctx_);
-  }
 
   if (color_mgr_) {
     delete color_mgr_;
@@ -243,29 +232,15 @@
       break;
     }
 
-    if (IsRotationRequired(&hw_layers_)) {
-      if (!rotator_intf_) {
-        continue;
-      }
-      error = rotator_intf_->Prepare(display_rotator_ctx_, &hw_layers_);
-    } else {
-      // Release all the previous rotator sessions.
-      if (rotator_intf_) {
-        error = rotator_intf_->Purge(display_rotator_ctx_);
-      }
-    }
-
+    error = hw_intf_->Validate(&hw_layers_);
     if (error == kErrorNone) {
-      error = hw_intf_->Validate(&hw_layers_);
-      if (error == kErrorNone) {
-        // Strategy is successful now, wait for Commit().
-        pending_commit_ = true;
-        break;
-      }
-      if (error == kErrorShutDown) {
-        comp_manager_->PostPrepare(display_comp_ctx_, &hw_layers_);
-        return error;
-      }
+      // Strategy is successful now, wait for Commit().
+      pending_commit_ = true;
+      break;
+    }
+    if (error == kErrorShutDown) {
+      comp_manager_->PostPrepare(display_comp_ctx_, &hw_layers_);
+      return error;
     }
   }
 
@@ -307,8 +282,7 @@
     }
   }
 
-  if (rotator_intf_ && IsRotationRequired(&hw_layers_)) {
-    error = rotator_intf_->Commit(display_rotator_ctx_, &hw_layers_);
+  if (comp_manager_->Commit(display_comp_ctx_, &hw_layers_)) {
     if (error != kErrorNone) {
       return error;
     }
@@ -327,13 +301,6 @@
     return error;
   }
 
-  if (rotator_intf_ && IsRotationRequired(&hw_layers_)) {
-    error = rotator_intf_->PostCommit(display_rotator_ctx_, &hw_layers_);
-    if (error != kErrorNone) {
-      return error;
-    }
-  }
-
   if (partial_update_control_) {
     comp_manager_->ControlPartialUpdate(display_comp_ctx_, true /* enable */);
   }
@@ -357,17 +324,7 @@
   hw_layers_.info.count = 0;
   error = hw_intf_->Flush();
   if (error == kErrorNone) {
-    // Release all the rotator sessions.
-    if (rotator_intf_) {
-      error = rotator_intf_->Purge(display_rotator_ctx_);
-      if (error != kErrorNone) {
-        DLOGE("Rotator purge failed for display %d", display_type_);
-        return error;
-      }
-    }
-
     comp_manager_->Purge(display_comp_ctx_);
-
     pending_commit_ = false;
   } else {
     DLOGW("Unable to flush display = %d", display_type_);
@@ -402,6 +359,13 @@
   return kErrorNotSupported;
 }
 
+DisplayError DisplayBase::GetConfig(DisplayConfigFixedInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  variable_info->is_cmdmode = (hw_panel_info_.mode == kModeCommand);
+
+  return kErrorNone;
+}
+
 DisplayError DisplayBase::GetActiveConfig(uint32_t *index) {
   lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetActiveConfig(index);
@@ -435,17 +399,7 @@
     hw_layers_.info.count = 0;
     error = hw_intf_->Flush();
     if (error == kErrorNone) {
-      // Release all the rotator sessions.
-      if (rotator_intf_) {
-        error = rotator_intf_->Purge(display_rotator_ctx_);
-        if (error != kErrorNone) {
-          DLOGE("Rotator purge failed for display %d", display_type_);
-          return error;
-        }
-      }
-
       comp_manager_->Purge(display_comp_ctx_);
-
       error = hw_intf_->PowerOff();
     }
     break;
@@ -660,21 +614,6 @@
   }
 }
 
-bool DisplayBase::IsRotationRequired(HWLayers *hw_layers) {
-  lock_guard<recursive_mutex> obj(recursive_mutex_);
-  HWLayersInfo &layer_info = hw_layers->info;
-
-  for (uint32_t i = 0; i < layer_info.count; i++) {
-    HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
-
-    if (hw_rotator_session->hw_block_count) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 const char * DisplayBase::GetName(const LayerComposition &composition) {
   switch (composition) {
   case kCompositionGPU:         return "GPU";
@@ -1126,4 +1065,10 @@
   return hw_panel_info_.is_primary_panel;
 }
 
+DisplayError DisplayBase::SetCompositionState(LayerComposition composition_type, bool enable) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+
+  return comp_manager_->SetCompositionState(display_comp_ctx_, composition_type, enable);
+}
+
 }  // namespace sdm
diff --git a/sdm/libs/core/display_base.h b/sdm/libs/core/display_base.h
index 43c5280..ae1171d 100644
--- a/sdm/libs/core/display_base.h
+++ b/sdm/libs/core/display_base.h
@@ -27,7 +27,6 @@
 
 #include <core/display_interface.h>
 #include <private/strategy_interface.h>
-#include <private/rotator_interface.h>
 #include <private/color_interface.h>
 
 #include <map>
@@ -45,15 +44,11 @@
 using std::recursive_mutex;
 using std::lock_guard;
 
-class RotatorCtrl;
-class HWInfoInterface;
-
 class DisplayBase : public DisplayInterface, DumpImpl {
  public:
   DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
               HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
-              CompManager *comp_manager, RotatorInterface *rotator_intf,
-              HWInfoInterface *hw_info_intf);
+              CompManager *comp_manager, HWInfoInterface *hw_info_intf);
   virtual ~DisplayBase() { }
   virtual DisplayError Init();
   virtual DisplayError Deinit();
@@ -63,6 +58,7 @@
   virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
   virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
+  virtual DisplayError GetConfig(DisplayConfigFixedInfo *variable_info);
   virtual DisplayError GetActiveConfig(uint32_t *index);
   virtual DisplayError GetVSyncState(bool *enabled);
   virtual DisplayError SetDisplayState(DisplayState state);
@@ -111,6 +107,7 @@
   virtual DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data);
   virtual DisplayError GetDisplayPort(DisplayPort *port);
   virtual bool IsPrimaryDisplay();
+  virtual DisplayError SetCompositionState(LayerComposition composition_type, bool enable);
 
  protected:
   DisplayError BuildLayerStackStats(LayerStack *layer_stack);
@@ -119,7 +116,6 @@
   // DumpImpl method
   void AppendDump(char *buffer, uint32_t length);
 
-  bool IsRotationRequired(HWLayers *hw_layers);
   const char *GetName(const LayerComposition &composition);
   DisplayError ReconfigureDisplay();
   bool NeedsMixerReconfiguration(LayerStack *layer_stack, uint32_t *new_mixer_width,
@@ -135,12 +131,10 @@
   HWPanelInfo hw_panel_info_;
   BufferSyncHandler *buffer_sync_handler_ = NULL;
   CompManager *comp_manager_ = NULL;
-  RotatorInterface *rotator_intf_ = NULL;
   DisplayState state_ = kStateOff;
   bool active_ = false;
   Handle hw_device_ = 0;
   Handle display_comp_ctx_ = 0;
-  Handle display_rotator_ctx_ = 0;
   HWLayers hw_layers_;
   bool pending_commit_ = false;
   bool vsync_enable_ = false;
@@ -159,12 +153,6 @@
   DisplayConfigVariableInfo fb_config_ = {};
   uint32_t req_mixer_width_ = 0;
   uint32_t req_mixer_height_ = 0;
-
- private:
-  // Unused
-  virtual DisplayError GetConfig(DisplayConfigFixedInfo *variable_info) {
-    return kErrorNone;
-  }
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/core/display_hdmi.cpp b/sdm/libs/core/display_hdmi.cpp
index 3c3d9f4..a577348 100644
--- a/sdm/libs/core/display_hdmi.cpp
+++ b/sdm/libs/core/display_hdmi.cpp
@@ -37,10 +37,9 @@
 namespace sdm {
 
 DisplayHDMI::DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-                         BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                         RotatorInterface *rotator_intf)
+                         BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager)
   : DisplayBase(kHDMI, event_handler, kDeviceHDMI, buffer_sync_handler, comp_manager,
-                rotator_intf, hw_info_intf) {
+                hw_info_intf) {
 }
 
 DisplayError DisplayHDMI::Init() {
diff --git a/sdm/libs/core/display_hdmi.h b/sdm/libs/core/display_hdmi.h
index 091cdc3..868b141 100644
--- a/sdm/libs/core/display_hdmi.h
+++ b/sdm/libs/core/display_hdmi.h
@@ -38,8 +38,7 @@
 class DisplayHDMI : public DisplayBase, HWEventHandler {
  public:
   DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-              BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-              RotatorInterface *rotator_intf);
+              BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager);
   virtual DisplayError Init();
   virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
index e8689ea..cb0884c 100644
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -39,10 +39,9 @@
 namespace sdm {
 
 DisplayPrimary::DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-                               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                               RotatorInterface *rotator_intf)
+                               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager)
   : DisplayBase(kPrimary, event_handler, kDevicePrimary, buffer_sync_handler, comp_manager,
-                rotator_intf, hw_info_intf) {
+                hw_info_intf) {
 }
 
 DisplayError DisplayPrimary::Init() {
diff --git a/sdm/libs/core/display_primary.h b/sdm/libs/core/display_primary.h
index 7a03005..a6b8b4c 100644
--- a/sdm/libs/core/display_primary.h
+++ b/sdm/libs/core/display_primary.h
@@ -37,8 +37,7 @@
 class DisplayPrimary : public DisplayBase, HWEventHandler {
  public:
   DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-                 BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                 RotatorInterface *rotator_intf);
+                 BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager);
   virtual DisplayError Init();
   virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError Commit(LayerStack *layer_stack);
diff --git a/sdm/libs/core/display_virtual.cpp b/sdm/libs/core/display_virtual.cpp
index 6beea5c..04922c4 100644
--- a/sdm/libs/core/display_virtual.cpp
+++ b/sdm/libs/core/display_virtual.cpp
@@ -34,10 +34,9 @@
 namespace sdm {
 
 DisplayVirtual::DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-                               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                               RotatorInterface *rotator_intf)
+                               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager)
   : DisplayBase(kVirtual, event_handler, kDeviceVirtual, buffer_sync_handler, comp_manager,
-                rotator_intf, hw_info_intf) {
+                hw_info_intf) {
 }
 
 DisplayError DisplayVirtual::Init() {
diff --git a/sdm/libs/core/display_virtual.h b/sdm/libs/core/display_virtual.h
index d6ce915..3cc2e24 100644
--- a/sdm/libs/core/display_virtual.h
+++ b/sdm/libs/core/display_virtual.h
@@ -36,8 +36,7 @@
 class DisplayVirtual : public DisplayBase {
  public:
   DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
-                 BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
-                 RotatorInterface *rotator_intf);
+                 BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager);
   virtual DisplayError Init();
   virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
diff --git a/sdm/libs/core/fb/hw_primary.cpp b/sdm/libs/core/fb/hw_primary.cpp
index f3c7639..3dfa4dd 100644
--- a/sdm/libs/core/fb/hw_primary.cpp
+++ b/sdm/libs/core/fb/hw_primary.cpp
@@ -332,6 +332,8 @@
     return kErrorHardware;
   }
 
+  auto_refresh_ = false;
+
   return kErrorNone;
 }
 
diff --git a/sdm/libs/core/resource_default.cpp b/sdm/libs/core/resource_default.cpp
index 4fc3ce4..54a6658 100644
--- a/sdm/libs/core/resource_default.cpp
+++ b/sdm/libs/core/resource_default.cpp
@@ -37,10 +37,42 @@
 
 namespace sdm {
 
-DisplayError ResourceDefault::Init(const HWResourceInfo &hw_res_info) {
+DisplayError ResourceDefault::CreateResourceDefault(const HWResourceInfo &hw_resource_info,
+                                                    ResourceInterface **resource_intf) {
   DisplayError error = kErrorNone;
 
-  num_pipe_ = hw_res_info.num_vig_pipe + hw_res_info.num_rgb_pipe + hw_res_info.num_dma_pipe;
+  ResourceDefault *resource_default = new ResourceDefault(hw_resource_info);
+  if (!resource_default) {
+    return kErrorNone;
+  }
+
+  error = resource_default->Init();
+  if (error != kErrorNone) {
+    delete resource_default;
+  }
+
+  *resource_intf = resource_default;
+
+  return kErrorNone;
+}
+
+DisplayError ResourceDefault::DestroyResourceDefault(ResourceInterface *resource_intf) {
+  ResourceDefault *resource_default = static_cast<ResourceDefault *>(resource_intf);
+
+  resource_default->Deinit();
+  delete resource_default;
+
+  return kErrorNone;
+}
+
+ResourceDefault::ResourceDefault(const HWResourceInfo &hw_res_info)
+  : hw_res_info_(hw_res_info) {
+}
+
+DisplayError ResourceDefault::Init() {
+  DisplayError error = kErrorNone;
+
+  num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
 
   if (!num_pipe_) {
     DLOGE("Number of H/W pipes is Zero!");
@@ -48,7 +80,6 @@
   }
 
   src_pipes_.resize(num_pipe_);
-  hw_res_info_ = hw_res_info;
 
   // Priority order of pipes: VIG, RGB, DMA
   uint32_t vig_index = 0;
@@ -187,7 +218,7 @@
   return kErrorNone;
 }
 
-DisplayError ResourceDefault::Acquire(Handle display_ctx, HWLayers *hw_layers) {
+DisplayError ResourceDefault::Prepare(Handle display_ctx, HWLayers *hw_layers) {
   DisplayResourceContext *display_resource_ctx =
                           reinterpret_cast<DisplayResourceContext *>(display_ctx);
 
@@ -297,6 +328,12 @@
   return kErrorNone;
 }
 
+DisplayError ResourceDefault::Commit(Handle display_ctx, HWLayers *hw_layers) {
+  SCOPE_LOCK(locker_);
+
+  return kErrorNone;
+}
+
 DisplayError ResourceDefault::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
   DisplayResourceContext *display_resource_ctx =
diff --git a/sdm/libs/core/resource_default.h b/sdm/libs/core/resource_default.h
index 79e7dcd..9f08155 100644
--- a/sdm/libs/core/resource_default.h
+++ b/sdm/libs/core/resource_default.h
@@ -36,8 +36,9 @@
 
 class ResourceDefault : public ResourceInterface {
  public:
-  DisplayError Init(const HWResourceInfo &hw_resource_info);
-  DisplayError Deinit();
+  static DisplayError CreateResourceDefault(const HWResourceInfo &hw_resource_info,
+                                            ResourceInterface **resource_intf);
+  static DisplayError DestroyResourceDefault(ResourceInterface *resource_intf);
   virtual DisplayError RegisterDisplay(DisplayType type,
                                        const HWDisplayAttributes &display_attributes,
                                        const HWPanelInfo &hw_panel_info,
@@ -50,8 +51,9 @@
                                           const HWMixerAttributes &mixer_attributes);
   virtual DisplayError Start(Handle display_ctx);
   virtual DisplayError Stop(Handle display_ctx);
-  virtual DisplayError Acquire(Handle display_ctx, HWLayers *hw_layers);
+  virtual DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
   virtual DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers);
+  virtual DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
   virtual DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
   virtual void Purge(Handle display_ctx);
   virtual DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
@@ -102,6 +104,9 @@
     HWBlockContext() : is_in_use(false) { }
   };
 
+  explicit ResourceDefault(const HWResourceInfo &hw_res_info);
+  DisplayError Init();
+  DisplayError Deinit();
   uint32_t NextPipe(PipeType pipe_type, HWBlockType hw_block_id);
   uint32_t SearchPipe(HWBlockType hw_block_id, SourcePipe *src_pipes, uint32_t num_pipe);
   uint32_t GetPipe(HWBlockType hw_block_id, bool need_scale);
diff --git a/sdm/libs/core/strategy.cpp b/sdm/libs/core/strategy.cpp
index 1734b9c..1b99f1f 100644
--- a/sdm/libs/core/strategy.cpp
+++ b/sdm/libs/core/strategy.cpp
@@ -75,15 +75,20 @@
 }
 
 DisplayError Strategy::Start(HWLayersInfo *hw_layers_info, uint32_t *max_attempts,
-                             bool partial_update_enable) {
+                             const PUConstraints &pu_constraints) {
   DisplayError error = kErrorNone;
 
   hw_layers_info_ = hw_layers_info;
   extn_start_success_ = false;
   tried_default_ = false;
 
+  if (!disable_gpu_comp_ && !hw_layers_info_->gpu_target_index) {
+    DLOGE("GPU composition is enabled and GPU target buffer not provided.");
+    return kErrorNotSupported;
+  }
+
   if (partial_update_intf_) {
-    partial_update_intf_->ControlPartialUpdate(partial_update_enable);
+    partial_update_intf_->Start(pu_constraints);
   }
   GenerateROI();
 
@@ -118,8 +123,8 @@
     }
   }
 
-  // Default composition is not possible if GPU composition is not supported.
-  if (!hw_layers_info_->gpu_target_index) {
+  // Do not fallback to GPU if GPU comp is disabled.
+  if (disable_gpu_comp_) {
     return kErrorNotSupported;
   }
 
@@ -224,4 +229,18 @@
   return kErrorNone;
 }
 
+DisplayError Strategy::SetCompositionState(LayerComposition composition_type, bool enable) {
+  DLOGI("composition type = %d, enable = %d", composition_type, enable);
+
+  if (composition_type == kCompositionGPU) {
+    disable_gpu_comp_ = !enable;
+  }
+
+  if (strategy_intf_) {
+    return strategy_intf_->SetCompositionState(composition_type, enable);
+  }
+
+  return kErrorNone;
+}
+
 }  // namespace sdm
diff --git a/sdm/libs/core/strategy.h b/sdm/libs/core/strategy.h
index 8b4b6f4..3fadd0d 100644
--- a/sdm/libs/core/strategy.h
+++ b/sdm/libs/core/strategy.h
@@ -41,13 +41,14 @@
   DisplayError Deinit();
 
   DisplayError Start(HWLayersInfo *hw_layers_info, uint32_t *max_attempts,
-                     bool partial_update_enable);
+                     const PUConstraints &pu_constraints);
   DisplayError GetNextStrategy(StrategyConstraints *constraints);
   DisplayError Stop();
   DisplayError Reconfigure(const HWPanelInfo &hw_panel_info,
                            const HWDisplayAttributes &hw_display_attributes,
                            const HWMixerAttributes &mixer_attributes,
                            const DisplayConfigVariableInfo &fb_config);
+  DisplayError SetCompositionState(LayerComposition composition_type, bool enable);
 
  private:
   void GenerateROI();
@@ -64,6 +65,7 @@
   DisplayConfigVariableInfo fb_config_ = {};
   bool extn_start_success_ = false;
   bool tried_default_ = false;
+  bool disable_gpu_comp_ = false;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_display_primary.cpp b/sdm/libs/hwc/hwc_display_primary.cpp
index bf2d384..783f322 100644
--- a/sdm/libs/hwc/hwc_display_primary.cpp
+++ b/sdm/libs/hwc/hwc_display_primary.cpp
@@ -304,8 +304,15 @@
            secure_display_active);
     secure_display_active_ = secure_display_active;
     skip_prepare_ = true;
+
+    // Avoid flush for command mode panels
+    DisplayConfigFixedInfo display_config;
+    display_intf_->GetConfig(&display_config);
+    if (display_config.is_cmdmode) {
+      DLOGI("Avoid flush for command mode panel");
+      skip_prepare_ = false;
+    }
   }
-  return;
 }
 
 void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) {