diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index eded50f..0ef0a9a 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -101,6 +101,7 @@
 MDPCapabilityInfo :: MDPCapabilityInfo() {
   qdutils::querySDEInfo(HAS_MACRO_TILE, &isMacroTileSupported);
   qdutils::querySDEInfo(HAS_UBWC, &isUBwcSupported);
+  qdutils::querySDEInfo(HAS_WB_UBWC, &isWBUBWCSupported);
 }
 
 //------------- AdrenoMemInfo-----------------------//
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index c1d7788..c62cec0 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -267,9 +267,13 @@
        format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
         if (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC)
             grallocFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
-        else if(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER)
-            grallocFormat = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; //NV12
-        else if((usage & GRALLOC_USAGE_HW_CAMERA_MASK)
+        else if(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
+            if(MDPCapabilityInfo::getInstance().isWBUBWCSupportedByMDP() &&
+               usage & GRALLOC_USAGE_HW_COMPOSER)
+              grallocFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
+            else
+              grallocFormat = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; //NV12
+        } else if((usage & GRALLOC_USAGE_HW_CAMERA_MASK)
                 == GRALLOC_USAGE_HW_CAMERA_ZSL)
             grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; //NV21 ZSL
         else if(usage & GRALLOC_USAGE_HW_CAMERA_READ)
diff --git a/libgralloc/gr.h b/libgralloc/gr.h
index 5fe1bdb..578240a 100644
--- a/libgralloc/gr.h
+++ b/libgralloc/gr.h
@@ -203,6 +203,7 @@
 {
     int isMacroTileSupported = 0;
     int isUBwcSupported = 0;
+    int isWBUBWCSupported = 0;
 
     public:
         MDPCapabilityInfo();
@@ -220,6 +221,13 @@
         *          0 : not supported
         */
         int isUBwcSupportedByMDP() { return isUBwcSupported; }
+        /*
+        * Function to return whether MDP WB block outputs UBWC format
+        *
+        * @return  1 : supported
+        *          0 : not supported
+        */
+        int isWBUBWCSupportedByMDP() { return isWBUBWCSupported; }
 };
 
 #endif /* GR_H_ */
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
index 142586b..24a0aa1 100644
--- a/libgralloc/mapper.cpp
+++ b/libgralloc/mapper.cpp
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,6 +55,27 @@
     return memalloc;
 }
 
+static int gralloc_map_metadata(buffer_handle_t handle) {
+    private_handle_t* hnd = (private_handle_t*)handle;
+    hnd->base_metadata = 0;
+    IMemAlloc* memalloc = getAllocator(hnd->flags) ;
+    void *mappedAddress = MAP_FAILED;
+    unsigned int size = 0;
+    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
+        mappedAddress = MAP_FAILED;
+        size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
+        int ret = memalloc->map_buffer(&mappedAddress, size,
+                                       hnd->offset_metadata, hnd->fd_metadata);
+        if(ret || mappedAddress == MAP_FAILED) {
+            ALOGE("Could not mmap metadata for handle %p, fd=%d (%s)",
+                  hnd, hnd->fd_metadata, strerror(errno));
+            return -errno;
+        }
+        hnd->base_metadata = uint64_t(mappedAddress) + hnd->offset_metadata;
+    }
+    return 0;
+}
+
 static int gralloc_map(gralloc_module_t const* module,
                        buffer_handle_t handle)
 {
@@ -68,7 +89,6 @@
     IMemAlloc* memalloc = getAllocator(hnd->flags) ;
     void *mappedAddress = MAP_FAILED;
     hnd->base = 0;
-    hnd->base_metadata = 0;
 
     // Dont map framebuffer and secure buffers
     if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) &&
@@ -83,23 +103,21 @@
         }
 
         hnd->base = uint64_t(mappedAddress) + hnd->offset;
+    } else {
+        // Cannot map secure buffers or framebuffers, but still need to map
+        // metadata for secure buffers.
+        // If mapping a secure buffers fails, the framework needs to get
+        // an error code.
+        err = -EINVAL;
     }
 
     //Allow mapping of metadata for all buffers including secure ones, but not
     //of framebuffer
-    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
-        mappedAddress = MAP_FAILED;
-        size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
-        err = memalloc->map_buffer(&mappedAddress, size,
-                                       hnd->offset_metadata, hnd->fd_metadata);
-        if(err || mappedAddress == MAP_FAILED) {
-            ALOGE("Could not mmap handle %p, fd=%d (%s)",
-                  handle, hnd->fd_metadata, strerror(errno));
-            return -errno;
-        }
-        hnd->base_metadata = uint64_t(mappedAddress) + hnd->offset_metadata;
+    int metadata_err = gralloc_map_metadata(handle);
+    if (!err) {
+        err = metadata_err;
     }
-    return 0;
+    return err;
 }
 
 static int gralloc_unmap(gralloc_module_t const* module,
@@ -152,21 +170,11 @@
     ATRACE_CALL();
     if (!module || private_handle_t::validate(handle) < 0)
         return -EINVAL;
-
-    /* NOTE: we need to initialize the buffer as not mapped/not locked
-     * because it shouldn't when this function is called the first time
-     * in a new process. Ideally these flags shouldn't be part of the
-     * handle, but instead maintained in the kernel or at least
-     * out-of-line
-     */
-
-    int err = gralloc_map(module, handle);
-    if (err) {
-        ALOGE("%s: gralloc_map failed", __FUNCTION__);
-        return err;
-    }
-
-    return 0;
+    // The base address received via IPC is invalid in this process
+    // Reset it to 0 here since it will be mapped in lock()
+    private_handle_t* hnd = (private_handle_t*)handle;
+    hnd->base = 0;
+    return gralloc_map_metadata(handle);
 }
 
 int gralloc_unregister_buffer(gralloc_module_t const* module,
diff --git a/libqdutils/qd_utils.cpp b/libqdutils/qd_utils.cpp
index 6453b58..43fb715 100644
--- a/libqdutils/qd_utils.cpp
+++ b/libqdutils/qd_utils.cpp
@@ -61,11 +61,12 @@
     case HAS_MACRO_TILE:
         featureName = "tile_format";
         break;
-
     case HAS_UBWC:
         featureName = "ubwc";
         break;
-
+    case HAS_WB_UBWC:
+        featureName = "wb_ubwc";
+        break;
     default:
         ALOGE("Invalid query type %d", type);
         return -EINVAL;
diff --git a/libqdutils/qd_utils.h b/libqdutils/qd_utils.h
index 0392e05..4722dcd 100644
--- a/libqdutils/qd_utils.h
+++ b/libqdutils/qd_utils.h
@@ -49,6 +49,7 @@
 enum HWQueryType {
     HAS_MACRO_TILE = 0,
     HAS_UBWC = 1,
+    HAS_WB_UBWC = 2
 };
 
 enum {
diff --git a/libqservice/IQService.h b/libqservice/IQService.h
index 49467db..d25a06d 100644
--- a/libqservice/IQService.h
+++ b/libqservice/IQService.h
@@ -73,6 +73,7 @@
         MIN_HDCP_ENCRYPTION_LEVEL_CHANGED = 31,
         GET_BW_TRANSACTION_STATUS = 32, //Client can query BW transaction status.
         SET_LAYER_MIXER_RESOLUTION = 33, // Enables client to set layer mixer resolution.
+        SET_COLOR_MODE = 34, // Overrides the QDCM mode on the display
         COMMAND_LIST_END = 400,
     };
 
diff --git a/sdm/libs/core/core_impl.cpp b/sdm/libs/core/core_impl.cpp
index da85c9e..66eb846 100644
--- a/sdm/libs/core/core_impl.cpp
+++ b/sdm/libs/core/core_impl.cpp
@@ -71,31 +71,25 @@
     goto CleanupOnError;
   }
 
-  hw_resource_ = new HWResourceInfo();
-  if (!hw_resource_) {
-    error = kErrorMemory;
-    goto CleanupOnError;
-  }
-
-  error = hw_info_intf_->GetHWResourceInfo(hw_resource_);
+  error = hw_info_intf_->GetHWResourceInfo(&hw_resource_);
   if (error != kErrorNone) {
     goto CleanupOnError;
   }
 
-  error = comp_mgr_.Init(*hw_resource_, extension_intf_, buffer_sync_handler_);
+  error = comp_mgr_.Init(hw_resource_, extension_intf_, 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_,
+  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_);
+  error = ColorManagerProxy::Init(hw_resource_);
   // if failed, doesn't affect display core functionalities.
   if (error != kErrorNone) {
     DLOGW("Unable creating color manager and continue without it.");
@@ -108,17 +102,13 @@
     HWInfoInterface::Destroy(hw_info_intf_);
   }
 
-  if (hw_resource_) {
-    delete hw_resource_;
-  }
-
   return error;
 }
 
 DisplayError CoreImpl::Deinit() {
   SCOPE_LOCK(locker_);
 
-  if (extension_intf_ && hw_resource_->hw_rot_info.num_rotator) {
+  if (extension_intf_ && hw_resource_.hw_rot_info.num_rotator) {
     extension_intf_->DestroyRotator(rotator_intf_);
   }
 
@@ -127,10 +117,6 @@
   comp_mgr_.Deinit();
   HWInfoInterface::Destroy(hw_info_intf_);
 
-  if (hw_resource_) {
-    delete hw_resource_;
-  }
-
   return kErrorNone;
 }
 
diff --git a/sdm/libs/core/core_impl.h b/sdm/libs/core/core_impl.h
index 2d0e2d2..c2e98c3 100644
--- a/sdm/libs/core/core_impl.h
+++ b/sdm/libs/core/core_impl.h
@@ -65,7 +65,7 @@
   Locker locker_;
   BufferAllocator *buffer_allocator_;
   BufferSyncHandler *buffer_sync_handler_;
-  HWResourceInfo *hw_resource_ = NULL;
+  HWResourceInfo hw_resource_;
   CompManager comp_mgr_;
   HWInfoInterface *hw_info_intf_ = NULL;
   RotatorInterface *rotator_intf_ = NULL;
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index dd6bfc0..3589680 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -49,6 +49,7 @@
 }
 
 DisplayError DisplayBase::Init() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   hw_panel_info_ = HWPanelInfo();
   hw_intf_->GetHWPanelInfo(&hw_panel_info_);
@@ -58,16 +59,14 @@
   hw_intf_->GetDisplayAttributes(active_index, &display_attributes_);
   fb_config_ = display_attributes_;
 
-  HWMixerAttributes mixer_attributes;
-  error = hw_intf_->GetMixerAttributes(&mixer_attributes);
+  error = hw_intf_->GetMixerAttributes(&mixer_attributes_);
   if (error != kErrorNone) {
     return error;
   }
-  mixer_attributes_ = mixer_attributes;
 
   // Override x_pixels and y_pixels of frame buffer with mixer width and height
-  fb_config_.x_pixels = mixer_attributes.width;
-  fb_config_.y_pixels = mixer_attributes.height;
+  fb_config_.x_pixels = mixer_attributes_.width;
+  fb_config_.y_pixels = mixer_attributes_.height;
 
   HWScaleLutInfo lut_info = {};
   error = comp_manager_->GetScaleLutConfig(&lut_info);
@@ -80,7 +79,7 @@
   }
 
   error = comp_manager_->RegisterDisplay(display_type_, display_attributes_, hw_panel_info_,
-                                         mixer_attributes, fb_config_, &display_comp_ctx_);
+                                         mixer_attributes_, fb_config_, &display_comp_ctx_);
   if (error != kErrorNone) {
     goto CleanupOnError;
   }
@@ -120,14 +119,11 @@
 }
 
 DisplayError DisplayBase::Deinit() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (rotator_intf_) {
     rotator_intf_->UnregisterDisplay(display_rotator_ctx_);
   }
 
-  if (color_modes_) {
-    delete[] color_modes_;
-  }
-
   if (color_mgr_) {
     delete color_mgr_;
     color_mgr_ = NULL;
@@ -198,7 +194,8 @@
 }
 
 DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  DisplayError error = kErrorNone;
 
   if (!active_) {
     return kErrorPermission;
@@ -208,19 +205,13 @@
     return kErrorParameters;
   }
 
-  return PrepareLocked(layer_stack);
-}
-
-DisplayError DisplayBase::PrepareLocked(LayerStack *layer_stack) {
-  DisplayError error = kErrorNone;
-
   error = ValidateGPUTarget(layer_stack);
   if (error != kErrorNone) {
     return error;
   }
 
   if (color_mgr_ && color_mgr_->NeedsPartialUpdateDisable()) {
-    DisablePartialUpdateOneFrameLocked();
+    DisablePartialUpdateOneFrame();
   }
 
   if (partial_update_control_ == false || disable_pu_one_frame_) {
@@ -272,7 +263,8 @@
 }
 
 DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  DisplayError error = kErrorNone;
 
   if (!active_) {
     pending_commit_ = false;
@@ -290,12 +282,6 @@
 
   pending_commit_ = false;
 
-  return CommitLocked(layer_stack);
-}
-
-DisplayError DisplayBase::CommitLocked(LayerStack *layer_stack) {
-  DisplayError error = kErrorNone;
-
   // Layer stack attributes has changed, need to Reconfigure, currently in use for Hybrid Comp
   if (layer_stack->flags.attributes_changed) {
     error = comp_manager_->ReConfigure(display_comp_ctx_, &hw_layers_);
@@ -349,6 +335,7 @@
 }
 
 DisplayError DisplayBase::Flush() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (!active_) {
@@ -378,6 +365,7 @@
 }
 
 DisplayError DisplayBase::GetDisplayState(DisplayState *state) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!state) {
     return kErrorParameters;
   }
@@ -387,10 +375,12 @@
 }
 
 DisplayError DisplayBase::GetNumVariableInfoConfigs(uint32_t *count) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetNumDisplayAttributes(count);
 }
 
 DisplayError DisplayBase::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   HWDisplayAttributes attrib;
   if (hw_intf_->GetDisplayAttributes(index, &attrib) == kErrorNone) {
     *variable_info = attrib;
@@ -401,10 +391,12 @@
 }
 
 DisplayError DisplayBase::GetActiveConfig(uint32_t *index) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetActiveConfig(index);
 }
 
 DisplayError DisplayBase::GetVSyncState(bool *enabled) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!enabled) {
     return kErrorParameters;
   }
@@ -414,11 +406,8 @@
   return kErrorNone;
 }
 
-bool DisplayBase::IsUnderscanSupported() {
-  return underscan_supported_;
-}
-
 DisplayError DisplayBase::SetDisplayState(DisplayState state) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   bool active = false;
 
@@ -481,11 +470,7 @@
 }
 
 DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
-  SCOPE_LOCK(locker_);
-  return SetActiveConfigLocked(index);
-}
-
-DisplayError DisplayBase::SetActiveConfigLocked(uint32_t index) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t active_index = 0;
 
@@ -503,12 +488,8 @@
   return ReconfigureDisplay();
 }
 
-DisplayError DisplayBase::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return SetActiveConfigLocked(variable_info);
-}
-
 DisplayError DisplayBase::SetMaxMixerStages(uint32_t max_mixer_stages) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   error = comp_manager_->SetMaxMixerStages(display_comp_ctx_, max_mixer_stages);
@@ -520,29 +501,8 @@
   return error;
 }
 
-DisplayError DisplayBase::ControlPartialUpdate(bool enable, uint32_t *pending) {
-  SCOPE_LOCK(locker_);
-  return ControlPartialUpdateLocked(enable, pending);
-}
-
-DisplayError DisplayBase::DisablePartialUpdateOneFrame() {
-  SCOPE_LOCK(locker_);
-  return DisablePartialUpdateOneFrameLocked();
-}
-
-DisplayError DisplayBase::SetDisplayMode(uint32_t mode) {
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayBase::SetPanelBrightness(int level) {
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayBase::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
-  return kErrorNotSupported;
-}
-
 void DisplayBase::AppendDump(char *buffer, uint32_t length) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   HWDisplayAttributes attrib;
   uint32_t active_index = 0;
   uint32_t num_modes = 0;
@@ -679,6 +639,7 @@
 }
 
 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++) {
@@ -708,6 +669,7 @@
 DisplayError DisplayBase::ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
                                                PPDisplayAPIPayload *out_payload,
                                                PPPendingParams *pending_action) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (color_mgr_)
     return color_mgr_->ColorSVCRequestRoute(in_payload, out_payload, pending_action);
   else
@@ -715,6 +677,7 @@
 }
 
 DisplayError DisplayBase::GetColorModeCount(uint32_t *mode_count) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!mode_count) {
     return kErrorParameters;
   }
@@ -736,6 +699,7 @@
 
 DisplayError DisplayBase::GetColorModes(uint32_t *mode_count,
                                         std::vector<std::string> *color_modes) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!mode_count || !color_modes) {
     return kErrorParameters;
   }
@@ -744,14 +708,15 @@
     return kErrorNotSupported;
   }
 
-  if (color_modes_ == NULL) {
-    color_modes_ = new SDEDisplayMode[num_color_modes_];
+  if (!color_modes_.size()) {
+    color_modes_.resize(num_color_modes_);
 
-    DisplayError error = color_mgr_->ColorMgrGetModes(&num_color_modes_, color_modes_);
+    DisplayError error = color_mgr_->ColorMgrGetModes(&num_color_modes_, color_modes_.data());
     if (error != kErrorNone) {
       DLOGE("Failed");
       return error;
     }
+
     for (uint32_t i = 0; i < num_color_modes_; i++) {
       DLOGV_IF(kTagQDCM, "Color Mode[%d]: Name = %s mode_id = %d", i, color_modes_[i].name,
                color_modes_[i].id);
@@ -769,6 +734,7 @@
 }
 
 DisplayError DisplayBase::SetColorMode(const std::string &color_mode) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!color_mgr_) {
     return kErrorNotSupported;
   }
@@ -782,10 +748,6 @@
   }
 
   SDEDisplayMode *sde_display_mode = it->second;
-  if (color_mode_ == sde_display_mode->id) {
-    DLOGV_IF(kTagQDCM, "Same mode requested");
-    return kErrorNone;
-  }
 
   DLOGV_IF(kTagQDCM, "Color Mode Name = %s corresponding mode_id = %d", sde_display_mode->name,
            sde_display_mode->id);
@@ -796,12 +758,11 @@
     return error;
   }
 
-  color_mode_ = sde_display_mode->id;
-
   return error;
 }
 
 DisplayError DisplayBase::SetColorTransform(const uint32_t length, const double *color_transform) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!color_mgr_) {
     return kErrorNotSupported;
   }
@@ -814,6 +775,7 @@
 }
 
 DisplayError DisplayBase::ApplyDefaultDisplayMode() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (color_mgr_)
     return color_mgr_->ApplyDefaultDisplayMode();
   else
@@ -821,6 +783,7 @@
 }
 
 DisplayError DisplayBase::SetCursorPosition(int x, int y) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (state_ != kStateOn) {
     return kErrorNotSupported;
   }
@@ -835,6 +798,7 @@
 
 DisplayError DisplayBase::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                               uint32_t *max_refresh_rate) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   // The min and max refresh rates will be same when the HWPanelInfo does not contain valid rates.
   // Usually for secondary displays, command mode panels
   HWDisplayAttributes display_attributes;
@@ -851,11 +815,8 @@
   return error;
 }
 
-DisplayError DisplayBase::GetPanelBrightness(int *level) {
-  return kErrorNotSupported;
-}
-
 DisplayError DisplayBase::SetVSyncState(bool enable) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   if (vsync_enable_ != enable) {
     error = hw_intf_->SetVSyncState(enable);
@@ -867,6 +828,7 @@
 }
 
 DisplayError DisplayBase::ReconfigureDisplay() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   HWDisplayAttributes display_attributes;
   HWMixerAttributes mixer_attributes;
@@ -905,7 +867,7 @@
   }
 
   if (mixer_attributes != mixer_attributes_) {
-    DisablePartialUpdateOneFrameLocked();
+    DisablePartialUpdateOneFrame();
   }
 
   display_attributes_ = display_attributes;
@@ -916,20 +878,12 @@
 }
 
 DisplayError DisplayBase::SetMixerResolution(uint32_t width, uint32_t height) {
-  SCOPE_LOCK(locker_);
-  return SetMixerResolutionLocked(width, height);
-}
-
-DisplayError DisplayBase::SetMixerResolutionLocked(uint32_t width, uint32_t height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return ReconfigureMixer(width, height);
 }
 
 DisplayError DisplayBase::GetMixerResolution(uint32_t *width, uint32_t *height) {
-  SCOPE_LOCK(locker_);
-  return GetMixerResolutionLocked(width, height);
-}
-
-DisplayError DisplayBase::GetMixerResolutionLocked(uint32_t *width, uint32_t *height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!width || !height) {
     return kErrorParameters;
   }
@@ -941,6 +895,7 @@
 }
 
 DisplayError DisplayBase::ReconfigureMixer(uint32_t width, uint32_t height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   HWMixerAttributes mixer_attributes;
@@ -957,6 +912,7 @@
 
 bool DisplayBase::NeedsMixerReconfiguration(LayerStack *layer_stack, uint32_t *new_mixer_width,
                                             uint32_t *new_mixer_height) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   uint32_t layer_count = UINT32(layer_stack->layers.size());
 
   uint32_t fb_width  = fb_config_.x_pixels;
@@ -1024,12 +980,7 @@
 }
 
 DisplayError DisplayBase::SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info) {
-  SCOPE_LOCK(locker_);
-  return SetFrameBufferConfigLocked(variable_info);
-}
-
-DisplayError DisplayBase::SetFrameBufferConfigLocked(
-                                   const DisplayConfigVariableInfo &variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   uint32_t width = variable_info.x_pixels;
   uint32_t height = variable_info.y_pixels;
 
@@ -1065,11 +1016,7 @@
 }
 
 DisplayError DisplayBase::GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return GetFrameBufferConfigLocked(variable_info);
-}
-
-DisplayError DisplayBase::GetFrameBufferConfigLocked(DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!variable_info) {
     return kErrorParameters;
   }
@@ -1080,17 +1027,13 @@
 }
 
 DisplayError DisplayBase::SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) {
-  SCOPE_LOCK(locker_);
-  return SetDetailEnhancerDataLocked(de_data);
-}
-
-DisplayError DisplayBase::SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = comp_manager_->SetDetailEnhancerData(display_comp_ctx_, de_data);
   if (error != kErrorNone) {
     return error;
   }
 
-  DisablePartialUpdateOneFrameLocked();
+  DisablePartialUpdateOneFrame();
 
   return kErrorNone;
 }
diff --git a/sdm/libs/core/display_base.h b/sdm/libs/core/display_base.h
index a9f1c3d..7fdb714 100644
--- a/sdm/libs/core/display_base.h
+++ b/sdm/libs/core/display_base.h
@@ -29,9 +29,9 @@
 #include <private/strategy_interface.h>
 #include <private/rotator_interface.h>
 #include <private/color_interface.h>
-#include <utils/locker.h>
 
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -42,10 +42,13 @@
 
 namespace sdm {
 
+using std::recursive_mutex;
+using std::lock_guard;
+
 class RotatorCtrl;
 class HWInfoInterface;
 
-class DisplayBase : public DisplayInterface {
+class DisplayBase : public DisplayInterface, DumpImpl {
  public:
   DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
               HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
@@ -54,8 +57,8 @@
   virtual ~DisplayBase() { }
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  DisplayError Prepare(LayerStack *layer_stack) final;
-  DisplayError Commit(LayerStack *layer_stack) final;
+  DisplayError Prepare(LayerStack *layer_stack);
+  DisplayError Commit(LayerStack *layer_stack);
   virtual DisplayError Flush();
   virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
@@ -63,15 +66,29 @@
   virtual DisplayError GetActiveConfig(uint32_t *index);
   virtual DisplayError GetVSyncState(bool *enabled);
   virtual DisplayError SetDisplayState(DisplayState state);
-  DisplayError SetActiveConfig(uint32_t index) final;
-  DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info) final;
+  virtual DisplayError SetActiveConfig(uint32_t index);
+  virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) final;
-  DisplayError DisablePartialUpdateOneFrame() final;
-  virtual DisplayError SetDisplayMode(uint32_t mode);
-  virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
-  virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
+  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError DisablePartialUpdateOneFrame() {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError SetDisplayMode(uint32_t mode) {
+    return kErrorNotSupported;
+  }
+  virtual bool IsUnderscanSupported() {
+    return false;
+  }
+  virtual DisplayError SetPanelBrightness(int level) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
                                             PPDisplayAPIPayload *out_payload,
                                             PPPendingParams *pending_action);
@@ -82,33 +99,18 @@
   virtual DisplayError ApplyDefaultDisplayMode(void);
   virtual DisplayError SetCursorPosition(int x, int y);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
-  virtual DisplayError GetPanelBrightness(int *level);
+  virtual DisplayError GetPanelBrightness(int *level) {
+    return kErrorNotSupported;
+  }
   virtual DisplayError SetVSyncState(bool enable);
-  DisplayError SetMixerResolution(uint32_t width, uint32_t height) final;
-  DisplayError GetMixerResolution(uint32_t *width, uint32_t *height) final;
-  DisplayError SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info) final;
-  DisplayError GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info) final;
-  DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) final;
+  virtual void SetIdleTimeoutMs(uint32_t timeout_ms) {}
+  virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height);
+  virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
+  virtual DisplayError SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info);
+  virtual DisplayError GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info);
+  virtual DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data);
 
  protected:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual DisplayError CommitLocked(LayerStack *layer_stack);
-  virtual DisplayError SetActiveConfigLocked(uint32_t index);
-  virtual DisplayError SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info) {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError ControlPartialUpdateLocked(bool enable, uint32_t *pending) {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError DisablePartialUpdateOneFrameLocked() {
-    return kErrorNotSupported;
-  }
-  virtual DisplayError SetMixerResolutionLocked(uint32_t width, uint32_t height);
-  virtual DisplayError GetMixerResolutionLocked(uint32_t *width, uint32_t *height);
-  virtual DisplayError SetFrameBufferConfigLocked(const DisplayConfigVariableInfo &variable_info);
-  virtual DisplayError GetFrameBufferConfigLocked(DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data);
-
   // DumpImpl method
   void AppendDump(char *buffer, uint32_t length);
 
@@ -120,8 +122,7 @@
                                  uint32_t *new_mixer_height);
   DisplayError ReconfigureMixer(uint32_t width, uint32_t height);
 
-
-  Locker locker_;
+  recursive_mutex recursive_mutex_;
   DisplayType display_type_;
   DisplayEventHandler *event_handler_ = NULL;
   HWDeviceType hw_device_type_;
@@ -138,7 +139,6 @@
   HWLayers hw_layers_;
   bool pending_commit_ = false;
   bool vsync_enable_ = false;
-  bool underscan_supported_ = false;
   uint32_t max_mixer_stages_ = 0;
   HWInfoInterface *hw_info_intf_ = NULL;
   ColorManagerProxy *color_mgr_ = NULL;  // each display object owns its ColorManagerProxy
@@ -146,8 +146,7 @@
   HWEventsInterface *hw_events_intf_ = NULL;
   bool disable_pu_one_frame_ = false;
   uint32_t num_color_modes_ = 0;
-  SDEDisplayMode *color_modes_ = NULL;
-  int32_t color_mode_ = 0;
+  std::vector<SDEDisplayMode> color_modes_;
   typedef std::map<std::string, SDEDisplayMode *> ColorModeMap;
   ColorModeMap color_mode_map_ = {};
   HWDisplayAttributes display_attributes_ = {};
diff --git a/sdm/libs/core/display_hdmi.cpp b/sdm/libs/core/display_hdmi.cpp
index a53995b..e09959f 100644
--- a/sdm/libs/core/display_hdmi.cpp
+++ b/sdm/libs/core/display_hdmi.cpp
@@ -26,6 +26,7 @@
 #include <utils/debug.h>
 #include <map>
 #include <utility>
+#include <vector>
 
 #include "display_hdmi.h"
 #include "hw_interface.h"
@@ -44,7 +45,7 @@
 }
 
 DisplayError DisplayHDMI::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWHDMI::Create(&hw_intf_, hw_info_intf_,
                                       DisplayBase::buffer_sync_handler_);
@@ -98,7 +99,7 @@
 }
 
 DisplayError DisplayHDMI::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWHDMI::Destroy(hw_intf_);
@@ -106,7 +107,8 @@
   return error;
 }
 
-DisplayError DisplayHDMI::PrepareLocked(LayerStack *layer_stack) {
+DisplayError DisplayHDMI::Prepare(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t new_mixer_width = 0;
   uint32_t new_mixer_height = 0;
@@ -122,64 +124,12 @@
 
   SetS3DMode(layer_stack);
 
-  return DisplayBase::PrepareLocked(layer_stack);
-}
-
-DisplayError DisplayHDMI::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayHDMI::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
-DisplayError DisplayHDMI::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetNumVariableInfoConfigs(count);
-}
-
-DisplayError DisplayHDMI::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetConfig(index, variable_info);
-}
-
-DisplayError DisplayHDMI::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetActiveConfig(index);
-}
-
-DisplayError DisplayHDMI::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
-
-DisplayError DisplayHDMI::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayState(state);
-}
-
-DisplayError DisplayHDMI::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetVSyncState(enable);
-}
-
-void DisplayHDMI::SetIdleTimeoutMs(uint32_t timeout_ms) { }
-
-DisplayError DisplayHDMI::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
-DisplayError DisplayHDMI::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayMode(mode);
+  return DisplayBase::Prepare(layer_stack);
 }
 
 DisplayError DisplayHDMI::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                               uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (hw_panel_info_.min_fps && hw_panel_info_.max_fps) {
@@ -193,7 +143,7 @@
 }
 
 DisplayError DisplayHDMI::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   if (!active_) {
     return kErrorPermission;
@@ -208,17 +158,12 @@
 }
 
 bool DisplayHDMI::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
-DisplayError DisplayHDMI::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetPanelBrightness(level);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  return underscan_supported_;
 }
 
 DisplayError DisplayHDMI::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->OnMinHdcpEncryptionLevelChange(min_enc_level);
 }
 
@@ -230,7 +175,7 @@
   hw_intf_->GetNumDisplayAttributes(&num_modes);
 
   // Get display attribute for each mode
-  HWDisplayAttributes *attrib = new HWDisplayAttributes[num_modes];
+  std::vector<HWDisplayAttributes> attrib(num_modes);
   for (index = 0; index < num_modes; index++) {
     hw_intf_->GetDisplayAttributes(index, &attrib[index]);
   }
@@ -265,7 +210,6 @@
     DLOGW("%s, could not support S3D mode from EDID info. S3D mode is %d",
           __FUNCTION__, s3d_mode);
   }
-  delete[] attrib;
 
   // Used for changing HDMI Resolution - override the best with user set config
   uint32_t user_config = UINT32(Debug::GetHDMIResolution());
@@ -313,16 +257,6 @@
   }
 }
 
-void DisplayHDMI::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
-DisplayError DisplayHDMI::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
-}
-
 void DisplayHDMI::SetS3DMode(LayerStack *layer_stack) {
   uint32_t s3d_layer_count = 0;
   HWS3DMode s3d_mode = kS3DModeNone;
diff --git a/sdm/libs/core/display_hdmi.h b/sdm/libs/core/display_hdmi.h
index b3ec9af..3a3c0dc 100644
--- a/sdm/libs/core/display_hdmi.h
+++ b/sdm/libs/core/display_hdmi.h
@@ -35,31 +35,18 @@
 
 class HWHDMIInterface;
 
-class DisplayHDMI : public DisplayBase, DumpImpl, HWEventHandler {
+class DisplayHDMI : public DisplayBase, HWEventHandler {
  public:
   DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
               BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
               RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
-  virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
-  virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
-  virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  virtual DisplayError SetDisplayMode(uint32_t mode);
+  virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
   virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
   virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
   virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
 
   // Implement the HWEventHandlers
   virtual DisplayError VSync(int64_t timestamp);
@@ -69,11 +56,11 @@
   virtual void CECMessage(char *message);
 
  private:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual uint32_t GetBestConfig(HWS3DMode s3d_mode);
-  virtual void GetScanSupport();
-  virtual void SetS3DMode(LayerStack *layer_stack);
+  uint32_t GetBestConfig(HWS3DMode s3d_mode);
+  void GetScanSupport();
+  void SetS3DMode(LayerStack *layer_stack);
 
+  bool underscan_supported_ = false;
   HWScanSupport scan_support_;
   std::map<LayerBufferS3DFormat, HWS3DMode> s3d_format_to_mode_;
   std::vector<const char *> event_list_ = {"vsync_event", "idle_notify", "cec/rd_msg",
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
index 41e4c29..ad1d3d6 100644
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -47,7 +47,7 @@
 }
 
 DisplayError DisplayPrimary::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWPrimary::Create(&hw_intf_, hw_info_intf_,
                                          DisplayBase::buffer_sync_handler_);
@@ -83,7 +83,7 @@
 }
 
 DisplayError DisplayPrimary::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWPrimary::Destroy(hw_intf_);
@@ -91,7 +91,8 @@
   return error;
 }
 
-DisplayError DisplayPrimary::PrepareLocked(LayerStack *layer_stack) {
+DisplayError DisplayPrimary::Prepare(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   uint32_t new_mixer_width = 0;
   uint32_t new_mixer_height = 0;
@@ -105,10 +106,11 @@
     }
   }
 
-  return DisplayBase::PrepareLocked(layer_stack);
+  return DisplayBase::Prepare(layer_stack);
 }
 
-DisplayError DisplayPrimary::CommitLocked(LayerStack *layer_stack) {
+DisplayError DisplayPrimary::Commit(LayerStack *layer_stack) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   // Enabling auto refresh is async and needs to happen before commit ioctl
@@ -118,7 +120,7 @@
 
   bool set_idle_timeout = comp_manager_->CanSetIdleTimeout(display_comp_ctx_);
 
-  error = DisplayBase::CommitLocked(layer_stack);
+  error = DisplayBase::Commit(layer_stack);
   if (error != kErrorNone) {
     return error;
   }
@@ -136,43 +138,8 @@
   return error;
 }
 
-DisplayError DisplayPrimary::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayPrimary::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
-DisplayError DisplayPrimary::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetNumVariableInfoConfigs(count);
-}
-
-DisplayError DisplayPrimary::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetConfig(index, variable_info);
-}
-
-DisplayError DisplayPrimary::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetActiveConfig(index);
-}
-
-DisplayError DisplayPrimary::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
-
-bool DisplayPrimary::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
 DisplayError DisplayPrimary::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   error = DisplayBase::SetDisplayState(state);
   if (error != kErrorNone) {
@@ -187,13 +154,8 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetVSyncState(enable);
-}
-
 void DisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   // Idle fallback feature is supported only for video mode panel.
   if (hw_panel_info_.mode == kModeVideo) {
@@ -202,13 +164,8 @@
   idle_timeout_ms_ = timeout_ms;
 }
 
-DisplayError DisplayPrimary::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
 DisplayError DisplayPrimary::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
   HWDisplayMode hw_display_mode = static_cast<HWDisplayMode>(mode);
   uint32_t pending = 0;
@@ -237,10 +194,10 @@
   }
 
   if (mode == kModeVideo) {
-    ControlPartialUpdateLocked(false /* enable */, &pending);
+    ControlPartialUpdate(false /* enable */, &pending);
     hw_intf_->SetIdleTimeoutMs(idle_timeout_ms_);
   } else if (mode == kModeCommand) {
-    ControlPartialUpdateLocked(true /* enable */, &pending);
+    ControlPartialUpdate(true /* enable */, &pending);
     hw_intf_->SetIdleTimeoutMs(0);
   }
 
@@ -248,13 +205,13 @@
 }
 
 DisplayError DisplayPrimary::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->SetPanelBrightness(level);
 }
 
 DisplayError DisplayPrimary::GetRefreshRateRange(uint32_t *min_refresh_rate,
                                                  uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   DisplayError error = kErrorNone;
 
   if (hw_panel_info_.min_fps && hw_panel_info_.max_fps) {
@@ -268,7 +225,7 @@
 }
 
 DisplayError DisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   if (!active_ || !hw_panel_info_.dynamic_fps) {
     return kErrorNotSupported;
@@ -287,11 +244,6 @@
   return DisplayBase::ReconfigureDisplay();
 }
 
-void DisplayPrimary::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
 DisplayError DisplayPrimary::VSync(int64_t timestamp) {
   if (vsync_enable_) {
     DisplayEventVSync vsync;
@@ -302,32 +254,23 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
-}
-
-DisplayError DisplayPrimary::Blank(bool blank) {
-  SCOPE_LOCK(locker_);
-  return kErrorNone;
-}
-
 void DisplayPrimary::IdleTimeout() {
   event_handler_->Refresh();
   comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
 }
 
 void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   comp_manager_->ProcessThermalEvent(display_comp_ctx_, thermal_level);
 }
 
 DisplayError DisplayPrimary::GetPanelBrightness(int *level) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   return hw_intf_->GetPanelBrightness(level);
 }
 
-DisplayError DisplayPrimary::ControlPartialUpdateLocked(bool enable, uint32_t *pending) {
+DisplayError DisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   if (!pending) {
     return kErrorParameters;
   }
@@ -355,7 +298,8 @@
   return kErrorNone;
 }
 
-DisplayError DisplayPrimary::DisablePartialUpdateOneFrameLocked() {
+DisplayError DisplayPrimary::DisablePartialUpdateOneFrame() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   disable_pu_one_frame_ = true;
 
   return kErrorNone;
diff --git a/sdm/libs/core/display_primary.h b/sdm/libs/core/display_primary.h
index 92e6c88..962f00c 100644
--- a/sdm/libs/core/display_primary.h
+++ b/sdm/libs/core/display_primary.h
@@ -34,45 +34,33 @@
 
 class HWPrimaryInterface;
 
-class DisplayPrimary : public DisplayBase, DumpImpl, HWEventHandler {
+class DisplayPrimary : public DisplayBase, HWEventHandler {
  public:
   DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
                  RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
-  virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
-  virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
+  virtual DisplayError Prepare(LayerStack *layer_stack);
+  virtual DisplayError Commit(LayerStack *layer_stack);
+  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending);
+  virtual DisplayError DisablePartialUpdateOneFrame();
   virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
   virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
   virtual DisplayError SetDisplayMode(uint32_t mode);
   virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
   virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
-  virtual bool IsUnderscanSupported();
   virtual DisplayError SetPanelBrightness(int level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
   virtual DisplayError GetPanelBrightness(int *level);
 
   // Implement the HWEventHandlers
   virtual DisplayError VSync(int64_t timestamp);
-  virtual DisplayError Blank(bool blank);
+  virtual DisplayError Blank(bool blank) { return kErrorNone; }
   virtual void IdleTimeout();
   virtual void ThermalEvent(int64_t thermal_level);
   virtual void CECMessage(char *message) { }
 
  private:
-  virtual DisplayError PrepareLocked(LayerStack *layer_stack);
-  virtual DisplayError CommitLocked(LayerStack *layer_stack);
-  virtual DisplayError ControlPartialUpdateLocked(bool enable, uint32_t *pending);
-  virtual DisplayError DisablePartialUpdateOneFrameLocked();
-
   uint32_t idle_timeout_ms_ = 0;
   std::vector<const char *> event_list_ = {"vsync_event", "show_blank_event", "idle_notify",
                                            "msm_fb_thermal_level", "thread_exit"};
diff --git a/sdm/libs/core/display_virtual.cpp b/sdm/libs/core/display_virtual.cpp
index cafb986..f835ea4 100644
--- a/sdm/libs/core/display_virtual.cpp
+++ b/sdm/libs/core/display_virtual.cpp
@@ -42,7 +42,7 @@
 }
 
 DisplayError DisplayVirtual::Init() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = HWVirtual::Create(&hw_intf_, hw_info_intf_,
                                          DisplayBase::buffer_sync_handler_);
@@ -61,7 +61,7 @@
 }
 
 DisplayError DisplayVirtual::Deinit() {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
   DisplayError error = DisplayBase::Deinit();
   HWVirtual::Destroy(hw_intf_);
@@ -69,112 +69,75 @@
   return error;
 }
 
-DisplayError DisplayVirtual::Flush() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::Flush();
-}
-
-DisplayError DisplayVirtual::GetDisplayState(DisplayState *state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetDisplayState(state);
-}
-
 DisplayError DisplayVirtual::GetNumVariableInfoConfigs(uint32_t *count) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *count = 1;
   return kErrorNone;
 }
 
 DisplayError DisplayVirtual::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *variable_info = display_attributes_;
   return kErrorNone;
 }
 
 DisplayError DisplayVirtual::GetActiveConfig(uint32_t *index) {
-  SCOPE_LOCK(locker_);
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
   *index = 0;
   return kErrorNone;
 }
 
-DisplayError DisplayVirtual::GetVSyncState(bool *enabled) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetVSyncState(enabled);
-}
+DisplayError DisplayVirtual::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
 
-bool DisplayVirtual::IsUnderscanSupported() {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::IsUnderscanSupported();
-}
-
-DisplayError DisplayVirtual::SetDisplayState(DisplayState state) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayState(state);
-}
-
-DisplayError DisplayVirtual::SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info) {
   if (!variable_info) {
     return kErrorParameters;
   }
 
-  display_attributes_.x_pixels = variable_info->x_pixels;
-  display_attributes_.y_pixels = variable_info->y_pixels;
-  display_attributes_.fps = variable_info->fps;
-
+  DisplayError error = kErrorNone;
+  HWDisplayAttributes display_attributes;
   HWMixerAttributes mixer_attributes;
-  mixer_attributes.width = variable_info->x_pixels;;
-  mixer_attributes.height = variable_info->y_pixels;
+  DisplayConfigVariableInfo fb_config = *variable_info;
+
+  display_attributes.x_pixels = variable_info->x_pixels;
+  display_attributes.y_pixels = variable_info->y_pixels;
+  display_attributes.fps = variable_info->fps;
+
+  if (display_attributes == display_attributes_) {
+    return kErrorNone;
+  }
+
+  error = hw_intf_->SetDisplayAttributes(display_attributes);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  error = hw_intf_->GetMixerAttributes(&mixer_attributes);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  // Override x_pixels and y_pixels of frame buffer with mixer width and height
+  fb_config.x_pixels = mixer_attributes.width;
+  fb_config.y_pixels = mixer_attributes.height;
+
   // if display is already connected, unregister display from composition manager and register
   // the display with new configuration.
   if (display_comp_ctx_) {
     comp_manager_->UnregisterDisplay(display_comp_ctx_);
   }
 
-  return comp_manager_->RegisterDisplay(display_type_, display_attributes_, hw_panel_info_,
-                                        mixer_attributes, fb_config_, &display_comp_ctx_);
-}
+  error = comp_manager_->RegisterDisplay(display_type_, display_attributes, hw_panel_info_,
+                                         mixer_attributes, fb_config, &display_comp_ctx_);
+  if (error != kErrorNone) {
+    return error;
+  }
 
-DisplayError DisplayVirtual::SetVSyncState(bool enable) {
-  SCOPE_LOCK(locker_);
-  return kErrorNotSupported;
-}
+  display_attributes_ = display_attributes;
+  mixer_attributes_ = mixer_attributes;
+  fb_config_ = fb_config;
 
-void DisplayVirtual::SetIdleTimeoutMs(uint32_t timeout_ms) { }
-
-DisplayError DisplayVirtual::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetMaxMixerStages(max_mixer_stages);
-}
-
-DisplayError DisplayVirtual::SetDisplayMode(uint32_t mode) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetDisplayMode(mode);
-}
-
-DisplayError DisplayVirtual::GetRefreshRateRange(uint32_t *min_refresh_rate,
-                                                 uint32_t *max_refresh_rate) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::GetRefreshRateRange(min_refresh_rate, max_refresh_rate);
-}
-
-DisplayError DisplayVirtual::SetRefreshRate(uint32_t refresh_rate) {
-  SCOPE_LOCK(locker_);
-  return kErrorNotSupported;
-}
-
-DisplayError DisplayVirtual::SetPanelBrightness(int level) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetPanelBrightness(level);
-}
-
-void DisplayVirtual::AppendDump(char *buffer, uint32_t length) {
-  SCOPE_LOCK(locker_);
-  DisplayBase::AppendDump(buffer, length);
-}
-
-DisplayError DisplayVirtual::SetCursorPosition(int x, int y) {
-  SCOPE_LOCK(locker_);
-  return DisplayBase::SetCursorPosition(x, y);
+  return kErrorNone;
 }
 
 }  // namespace sdm
diff --git a/sdm/libs/core/display_virtual.h b/sdm/libs/core/display_virtual.h
index 59334a7..69af7f0 100644
--- a/sdm/libs/core/display_virtual.h
+++ b/sdm/libs/core/display_virtual.h
@@ -33,43 +33,33 @@
 
 class HWVirtualInterface;
 
-class DisplayVirtual : public DisplayBase, DumpImpl {
+class DisplayVirtual : public DisplayBase {
  public:
   DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
                  BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
                  RotatorInterface *rotator_intf);
   virtual DisplayError Init();
   virtual DisplayError Deinit();
-  virtual DisplayError Flush();
-  virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
   virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
   virtual DisplayError GetActiveConfig(uint32_t *index);
-  virtual DisplayError GetVSyncState(bool *enabled);
-  virtual DisplayError SetDisplayState(DisplayState state);
-  virtual DisplayError SetVSyncState(bool enable);
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  virtual DisplayError SetDisplayMode(uint32_t mode);
-  virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
-  virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
-  virtual bool IsUnderscanSupported();
-  virtual DisplayError SetPanelBrightness(int level);
-  virtual void AppendDump(char *buffer, uint32_t length);
-  virtual DisplayError SetCursorPosition(int x, int y);
-
- private:
-  virtual DisplayError SetActiveConfigLocked(uint32_t index) {
+  virtual DisplayError SetActiveConfig(uint32_t index) {
     return kErrorNotSupported;
   }
-  virtual DisplayError SetActiveConfigLocked(DisplayConfigVariableInfo *variable_info);
-  virtual DisplayError SetMixerResolutionLocked(uint32_t width, uint32_t height) {
+  virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
+  virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height) {
     return kErrorNotSupported;
   }
-  virtual DisplayError GetMixerResolutionLocked(uint32_t *width, uint32_t *height) {
+  virtual DisplayError SetVSyncState(bool enable) {
     return kErrorNotSupported;
   }
-  virtual DisplayError SetDetailEnhancerDataLocked(const DisplayDetailEnhancerData &de_data) {
+  virtual DisplayError SetRefreshRate(uint32_t refresh_rate) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height) {
+    return kErrorNotSupported;
+  }
+  virtual DisplayError SetDetailEnhancerData(const DisplayDetailEnhancerData &de_data) {
     return kErrorNotSupported;
   }
 };
diff --git a/sdm/libs/core/fb/hw_device.cpp b/sdm/libs/core/fb/hw_device.cpp
index 6cdda2b..c707847 100644
--- a/sdm/libs/core/fb/hw_device.cpp
+++ b/sdm/libs/core/fb/hw_device.cpp
@@ -124,6 +124,10 @@
   return kErrorNone;
 }
 
+DisplayError HWDevice::SetDisplayAttributes(const HWDisplayAttributes &display_attributes) {
+  return kErrorNotSupported;
+}
+
 DisplayError HWDevice::GetConfigIndex(uint32_t mode, uint32_t *index) {
   return kErrorNone;
 }
@@ -950,7 +954,6 @@
 }
 
 void HWDevice::ResetDisplayParams() {
-  uint32_t dst_scalar_cnt = hw_resource_.hw_dest_scalar_info.count;
   memset(&mdp_disp_commit_, 0, sizeof(mdp_disp_commit_));
   memset(&mdp_in_layers_, 0, sizeof(mdp_in_layers_));
   memset(&mdp_out_layer_, 0, sizeof(mdp_out_layer_));
@@ -959,8 +962,8 @@
   memset(&pp_params_, 0, sizeof(pp_params_));
   memset(&igc_lut_data_, 0, sizeof(igc_lut_data_));
 
-  if (mdp_dest_scalar_data_) {
-    memset(mdp_dest_scalar_data_, 0, sizeof(mdp_dest_scalar_data_) * dst_scalar_cnt);
+  for (size_t i = 0; i < mdp_dest_scalar_data_.size(); i++) {
+    mdp_dest_scalar_data_[i] = {};
   }
 
   for (uint32_t i = 0; i < kMaxSDELayers * 2; i++) {
@@ -972,7 +975,7 @@
   mdp_disp_commit_.commit_v1.output_layer = &mdp_out_layer_;
   mdp_disp_commit_.commit_v1.release_fence = -1;
   mdp_disp_commit_.commit_v1.retire_fence = -1;
-  mdp_disp_commit_.commit_v1.dest_scaler = mdp_dest_scalar_data_;
+  mdp_disp_commit_.commit_v1.dest_scaler = mdp_dest_scalar_data_.data();
 }
 
 void HWDevice::SetCSC(LayerCSC source, mdp_color_space *color_space) {
diff --git a/sdm/libs/core/fb/hw_device.h b/sdm/libs/core/fb/hw_device.h
index 9f77f8f..40f4f63 100644
--- a/sdm/libs/core/fb/hw_device.h
+++ b/sdm/libs/core/fb/hw_device.h
@@ -29,6 +29,7 @@
 #include <linux/msm_mdp_ext.h>
 #include <linux/mdss_rotator.h>
 #include <pthread.h>
+#include <vector>
 
 #include "hw_interface.h"
 #include "hw_scale.h"
@@ -59,6 +60,7 @@
                                             HWDisplayAttributes *display_attributes);
   virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
+  virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes);
   virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
@@ -144,7 +146,7 @@
   bool synchronous_commit_;
   HWDisplayAttributes display_attributes_ = {};
   HWMixerAttributes mixer_attributes_ = {};
-  mdp_destination_scaler_data *mdp_dest_scalar_data_ = NULL;
+  std::vector<mdp_destination_scaler_data> mdp_dest_scalar_data_;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/core/fb/hw_events.cpp b/sdm/libs/core/fb/hw_events.cpp
index 5a656cc..5ae53a4 100644
--- a/sdm/libs/core/fb/hw_events.cpp
+++ b/sdm/libs/core/fb/hw_events.cpp
@@ -141,14 +141,14 @@
 }
 
 DisplayError HWEvents::Init(int fb_num, HWEventHandler *event_handler,
-                            std::vector<const char *> *event_list) {
+                            vector<const char *> *event_list) {
   if (!event_handler)
     return kErrorParameters;
 
   event_handler_ = event_handler;
   fb_num_ = fb_num;
   event_list_ = event_list;
-  poll_fds_ = new pollfd[event_list_->size()];
+  poll_fds_.resize(event_list_->size());
   event_thread_name_ += " - " + std::to_string(fb_num_);
 
   PopulateHWEventData();
@@ -178,10 +178,6 @@
     poll_fds_[i].fd = -1;
   }
 
-  delete [] poll_fds_;
-
-  poll_fds_ = 0;
-
   return kErrorNone;
 }
 
@@ -200,7 +196,7 @@
   setpriority(PRIO_PROCESS, 0, kThreadPriorityUrgent);
 
   while (!exit_threads_) {
-    int error = Sys::poll_(poll_fds_, UINT32(event_list_->size()), -1);
+    int error = Sys::poll_(poll_fds_.data(), UINT32(event_list_->size()), -1);
 
     if (error <= 0) {
       DLOGW("poll failed. error = %s", strerror(errno));
diff --git a/sdm/libs/core/fb/hw_events.h b/sdm/libs/core/fb/hw_events.h
old mode 100755
new mode 100644
index 5d7d23d..bcc5ef6
--- a/sdm/libs/core/fb/hw_events.h
+++ b/sdm/libs/core/fb/hw_events.h
@@ -36,10 +36,12 @@
 
 namespace sdm {
 
+using std::vector;
+
 class HWEvents : public HWEventsInterface {
  public:
   DisplayError Init(int fb_num, HWEventHandler *event_handler,
-                    std::vector<const char *> *event_list);
+                    vector<const char *> *event_list);
   DisplayError Deinit();
 
  private:
@@ -65,9 +67,9 @@
   pollfd InitializePollFd(HWEventData *event_data);
 
   HWEventHandler *event_handler_ = NULL;
-  std::vector<const char *> *event_list_ = NULL;
-  std::vector<HWEventData> event_data_list_ = {};
-  pollfd *poll_fds_ = NULL;
+  vector<const char *> *event_list_ = NULL;
+  vector<HWEventData> event_data_list_ = {};
+  vector<pollfd> poll_fds_;
   pthread_t event_thread_;
   std::string event_thread_name_ = "SDM_EventThread";
   bool exit_threads_ = false;
diff --git a/sdm/libs/core/fb/hw_hdmi.cpp b/sdm/libs/core/fb/hw_hdmi.cpp
index 6140d0f..d9116e6 100644
--- a/sdm/libs/core/fb/hw_hdmi.cpp
+++ b/sdm/libs/core/fb/hw_hdmi.cpp
@@ -120,10 +120,7 @@
     return error;
   }
 
-  uint32_t dest_scalar_count = hw_resource_.hw_dest_scalar_info.count;
-  if (dest_scalar_count) {
-    mdp_dest_scalar_data_ = new mdp_destination_scaler_data[dest_scalar_count];
-  }
+  mdp_dest_scalar_data_.resize(hw_resource_.hw_dest_scalar_info.count);
 
   error = ReadEDIDInfo();
   if (error != kErrorNone) {
@@ -136,13 +133,6 @@
     return kErrorHardware;
   }
 
-  // Mode look-up table for HDMI
-  supported_video_modes_ = new msm_hdmi_mode_timing_info[hdmi_mode_count_];
-  if (!supported_video_modes_) {
-    Deinit();
-    return kErrorMemory;
-  }
-
   error = ReadTimingInfo();
   if (error != kErrorNone) {
     Deinit();
@@ -166,18 +156,11 @@
 }
 
 DisplayError HWHDMI::Deinit() {
-  hdmi_mode_count_ = 0;
-  if (supported_video_modes_) {
-    delete[] supported_video_modes_;
-  }
-
-  delete [] mdp_dest_scalar_data_;
-
   return HWDevice::Deinit();
 }
 
 DisplayError HWHDMI::GetNumDisplayAttributes(uint32_t *count) {
-  *count = hdmi_mode_count_;
+  *count = UINT32(hdmi_modes_.size());
   if (*count <= 0) {
     return kErrorHardware;
   }
@@ -219,8 +202,14 @@
     char *ptr = edid_str;
     const uint32_t edid_count_max = 128;
     char *tokens[edid_count_max] = { NULL };
-    ParseLine(ptr, tokens, edid_count_max, &hdmi_mode_count_);
-    for (uint32_t i = 0; i < hdmi_mode_count_; i++) {
+    uint32_t hdmi_mode_count = 0;
+
+    ParseLine(ptr, tokens, edid_count_max, &hdmi_mode_count);
+
+    supported_video_modes_.resize(hdmi_mode_count);
+
+    hdmi_modes_.resize(hdmi_mode_count);
+    for (uint32_t i = 0; i < hdmi_mode_count; i++) {
       hdmi_modes_[i] = UINT32(atoi(tokens[i]));
     }
   }
@@ -232,13 +221,13 @@
                                           HWDisplayAttributes *display_attributes) {
   DTRACE_SCOPED();
 
-  if (index > hdmi_mode_count_) {
+  if (index >= hdmi_modes_.size()) {
     return kErrorNotSupported;
   }
 
   // Get the resolution info from the look up table
   msm_hdmi_mode_timing_info *timing_mode = &supported_video_modes_[0];
-  for (uint32_t i = 0; i < hdmi_mode_count_; i++) {
+  for (uint32_t i = 0; i < hdmi_modes_.size(); i++) {
     msm_hdmi_mode_timing_info *cur = &supported_video_modes_[i];
     if (cur->video_format == hdmi_modes_[index]) {
       timing_mode = cur;
@@ -274,7 +263,7 @@
 DisplayError HWHDMI::SetDisplayAttributes(uint32_t index) {
   DTRACE_SCOPED();
 
-  if (index > hdmi_mode_count_) {
+  if (index > hdmi_modes_.size()) {
     return kErrorNotSupported;
   }
 
@@ -291,7 +280,7 @@
         vscreeninfo.upper_margin, vscreeninfo.pixclock/1000000);
 
   msm_hdmi_mode_timing_info *timing_mode = &supported_video_modes_[0];
-  for (uint32_t i = 0; i < hdmi_mode_count_; i++) {
+  for (uint32_t i = 0; i < hdmi_modes_.size(); i++) {
     msm_hdmi_mode_timing_info *cur = &supported_video_modes_[i];
     if (cur->video_format == hdmi_modes_[index]) {
       timing_mode = cur;
@@ -345,7 +334,7 @@
 
 DisplayError HWHDMI::GetConfigIndex(uint32_t mode, uint32_t *index) {
   // Check if the mode is valid and return corresponding index
-  for (uint32_t i = 0; i < hdmi_mode_count_; i++) {
+  for (uint32_t i = 0; i < hdmi_modes_.size(); i++) {
     if (hdmi_modes_[i] == mode) {
       *index = i;
       DLOGI("Index = %d for config = %d", *index, mode);
@@ -371,7 +360,7 @@
 }
 
 DisplayError HWHDMI::GetVideoFormat(uint32_t config_index, uint32_t *video_format) {
-  if (config_index > hdmi_mode_count_) {
+  if (config_index > hdmi_modes_.size()) {
     return kErrorNotSupported;
   }
 
@@ -531,7 +520,7 @@
       break;
     }
 
-    while (info->video_format && size < kPageSize && config_index < hdmi_mode_count_) {
+    while (info->video_format && size < kPageSize && config_index < hdmi_modes_.size()) {
       supported_video_modes_[config_index] = *info;
       size += sizeof(msm_hdmi_mode_timing_info);
 
@@ -601,7 +590,7 @@
   char edid_s3d_path[kMaxStringLength] = {'\0'};
   snprintf(edid_s3d_path, sizeof(edid_s3d_path), "%s%d/edid_3d_modes", fb_path_, fb_node_index_);
 
-  if (index > hdmi_mode_count_) {
+  if (index > hdmi_modes_.size()) {
     return kErrorNotSupported;
   }
 
diff --git a/sdm/libs/core/fb/hw_hdmi.h b/sdm/libs/core/fb/hw_hdmi.h
index 2845708..d2bd658 100644
--- a/sdm/libs/core/fb/hw_hdmi.h
+++ b/sdm/libs/core/fb/hw_hdmi.h
@@ -33,6 +33,8 @@
 
 namespace sdm {
 
+using std::vector;
+
 class HWHDMI : public HWDevice {
  public:
   static DisplayError Create(HWInterface **intf, HWInfoInterface *hw_info_intf,
@@ -85,14 +87,13 @@
   bool IsSupportedS3DMode(HWS3DMode s3d_mode);
   void UpdateMixerAttributes();
 
-  uint32_t hdmi_mode_count_;
-  uint32_t hdmi_modes_[256];
+  vector<uint32_t> hdmi_modes_;
   // Holds the hdmi timing information. Ex: resolution, fps etc.,
-  msm_hdmi_mode_timing_info *supported_video_modes_;
+  vector<msm_hdmi_mode_timing_info> supported_video_modes_;
   HWScanInfo hw_scan_info_;
   uint32_t active_config_index_;
   std::map<HWS3DMode, msm_hdmi_s3d_mode> s3d_mode_sdm_to_mdp_;
-  std::vector<HWS3DMode> supported_s3d_modes_;
+  vector<HWS3DMode> supported_s3d_modes_;
   int active_mdp_s3d_mode_ = HDMI_S3D_NONE;
   uint32_t frame_rate_ = 0;
 };
diff --git a/sdm/libs/core/fb/hw_info.cpp b/sdm/libs/core/fb/hw_info.cpp
index 77d3b6a..dc01e39 100644
--- a/sdm/libs/core/fb/hw_info.cpp
+++ b/sdm/libs/core/fb/hw_info.cpp
@@ -522,8 +522,10 @@
     DLOGI("First display is internal display");
   }
 
+  fs.close();
   fs.open("/sys/devices/virtual/graphics/fb0/connected", fstream::in);
   if (!fs.is_open()) {
+    // If fb0 is for a DSI/connected panel, then connected node will not exist.
     hw_disp_info->is_connected = true;
   } else {
     if (!Sys::getline_(fs, line)) {
diff --git a/sdm/libs/core/fb/hw_primary.cpp b/sdm/libs/core/fb/hw_primary.cpp
index d17f670..09e7f80 100644
--- a/sdm/libs/core/fb/hw_primary.cpp
+++ b/sdm/libs/core/fb/hw_primary.cpp
@@ -102,10 +102,7 @@
     return error;
   }
 
-  uint32_t dest_scalar_count = hw_resource_.hw_dest_scalar_info.count;
-  if (dest_scalar_count) {
-    mdp_dest_scalar_data_ = new mdp_destination_scaler_data[dest_scalar_count];
-  }
+  mdp_dest_scalar_data_.resize(hw_resource_.hw_dest_scalar_info.count);
 
   error = PopulateDisplayAttributes();
   if (error != kErrorNone) {
@@ -192,8 +189,6 @@
 }
 
 DisplayError HWPrimary::Deinit() {
-  delete [] mdp_dest_scalar_data_;
-
   return HWDevice::Deinit();
 }
 
diff --git a/sdm/libs/core/fb/hw_virtual.cpp b/sdm/libs/core/fb/hw_virtual.cpp
index 662c458..d297efa 100644
--- a/sdm/libs/core/fb/hw_virtual.cpp
+++ b/sdm/libs/core/fb/hw_virtual.cpp
@@ -74,5 +74,32 @@
   return HWDevice::Validate(hw_layers);
 }
 
+DisplayError HWVirtual::GetMixerAttributes(HWMixerAttributes *mixer_attributes) {
+  if (!mixer_attributes) {
+    return kErrorParameters;
+  }
+
+  mixer_attributes->width = display_attributes_.x_pixels;
+  mixer_attributes->height = display_attributes_.y_pixels;
+  mixer_attributes_.split_left = display_attributes_.is_device_split ?
+      (display_attributes_.x_pixels / 2) : mixer_attributes_.width;
+
+  return kErrorNone;
+}
+
+DisplayError HWVirtual::SetDisplayAttributes(const HWDisplayAttributes &display_attributes) {
+  if (display_attributes.x_pixels == 0 || display_attributes.y_pixels == 0) {
+    return kErrorParameters;
+  }
+
+  display_attributes_ = display_attributes;
+
+  if (display_attributes_.x_pixels > hw_resource_.max_mixer_width) {
+    display_attributes_.is_device_split = true;
+  }
+
+  return kErrorNone;
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/fb/hw_virtual.h b/sdm/libs/core/fb/hw_virtual.h
index 5ecec34..c083127 100644
--- a/sdm/libs/core/fb/hw_virtual.h
+++ b/sdm/libs/core/fb/hw_virtual.h
@@ -38,9 +38,8 @@
   virtual DisplayError SetMixerAttributes(const HWMixerAttributes &mixer_attributes) {
     return kErrorNotSupported;
   }
-  virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes) {
-    return kErrorNotSupported;
-  }
+  virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes);
+  virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes);
 
  protected:
   HWVirtual(BufferSyncHandler *buffer_sync_handler, HWInfoInterface *hw_info_intf);
diff --git a/sdm/libs/core/hw_interface.h b/sdm/libs/core/hw_interface.h
index 0ff5126..56a1513 100644
--- a/sdm/libs/core/hw_interface.h
+++ b/sdm/libs/core/hw_interface.h
@@ -70,6 +70,7 @@
                                             HWDisplayAttributes *display_attributes) = 0;
   virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info) = 0;
   virtual DisplayError SetDisplayAttributes(uint32_t index) = 0;
+  virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes) = 0;
   virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index) = 0;
   virtual DisplayError PowerOn() = 0;
   virtual DisplayError PowerOff() = 0;
diff --git a/sdm/libs/core/resource_default.cpp b/sdm/libs/core/resource_default.cpp
index c5907be..4fc3ce4 100644
--- a/sdm/libs/core/resource_default.cpp
+++ b/sdm/libs/core/resource_default.cpp
@@ -47,7 +47,7 @@
     return kErrorParameters;
   }
 
-  src_pipes_ = new SourcePipe[num_pipe_];
+  src_pipes_.resize(num_pipe_);
   hw_res_info_ = hw_res_info;
 
   // Priority order of pipes: VIG, RGB, DMA
@@ -100,7 +100,6 @@
 }
 
 DisplayError ResourceDefault::Deinit() {
-  delete[] src_pipes_;
   return kErrorNone;
 }
 
diff --git a/sdm/libs/core/resource_default.h b/sdm/libs/core/resource_default.h
index b57ce94..79e7dcd 100644
--- a/sdm/libs/core/resource_default.h
+++ b/sdm/libs/core/resource_default.h
@@ -28,6 +28,7 @@
 #include <core/display_interface.h>
 #include <private/resource_interface.h>
 #include <utils/locker.h>
+#include <vector>
 
 #include "hw_interface.h"
 
@@ -132,7 +133,7 @@
   Locker locker_;
   HWResourceInfo hw_res_info_;
   HWBlockContext hw_block_ctx_[kHWBlockMax];
-  SourcePipe *src_pipes_ = NULL;
+  std::vector<SourcePipe> src_pipes_;
   uint32_t num_pipe_ = 0;
 };
 
diff --git a/sdm/libs/hwc/hwc_display_primary.cpp b/sdm/libs/hwc/hwc_display_primary.cpp
index f92ab43..f4775b1 100644
--- a/sdm/libs/hwc/hwc_display_primary.cpp
+++ b/sdm/libs/hwc/hwc_display_primary.cpp
@@ -86,15 +86,11 @@
                                      hwc_procs_t const **hwc_procs,
                                      qService::QService *qservice)
   : HWCDisplay(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY, true, qservice,
-               DISPLAY_CLASS_PRIMARY), buffer_allocator_(buffer_allocator), cpu_hint_(NULL) {
+               DISPLAY_CLASS_PRIMARY), buffer_allocator_(buffer_allocator) {
 }
 
 int HWCDisplayPrimary::Init() {
-  cpu_hint_ = new CPUHint();
-  if (cpu_hint_->Init(static_cast<HWCDebugHandler*>(HWCDebugHandler::Get())) != kErrorNone) {
-    delete cpu_hint_;
-    cpu_hint_ = NULL;
-  }
+  cpu_hint_.Init(static_cast<HWCDebugHandler*>(HWCDebugHandler::Get()));
 
   use_metadata_refresh_rate_ = true;
   int disable_metadata_dynfps = 0;
@@ -289,14 +285,10 @@
 }
 
 void HWCDisplayPrimary::ToggleCPUHint(bool set) {
-  if (!cpu_hint_) {
-    return;
-  }
-
   if (set) {
-    cpu_hint_->Set();
+    cpu_hint_.Set();
   } else {
-    cpu_hint_->Reset();
+    cpu_hint_.Reset();
   }
 }
 
diff --git a/sdm/libs/hwc/hwc_display_primary.h b/sdm/libs/hwc/hwc_display_primary.h
index 81e510f..f25a877 100644
--- a/sdm/libs/hwc/hwc_display_primary.h
+++ b/sdm/libs/hwc/hwc_display_primary.h
@@ -74,7 +74,7 @@
   DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
 
   BufferAllocator *buffer_allocator_ = nullptr;
-  CPUHint *cpu_hint_ = nullptr;
+  CPUHint cpu_hint_;
   bool handle_idle_timeout_ = false;
 
   // Primary output buffer configuration
diff --git a/sdm/libs/hwc/hwc_display_virtual.cpp b/sdm/libs/hwc/hwc_display_virtual.cpp
index 1363839..25cd6fc 100644
--- a/sdm/libs/hwc/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc/hwc_display_virtual.cpp
@@ -171,6 +171,8 @@
     return status;
   }
 
+  CommitOutputBufferParams(content_list);
+
   status = HWCDisplay::CommitLayerStack(content_list);
   if (status) {
     return status;
@@ -259,14 +261,9 @@
 }
 
 int HWCDisplayVirtual::SetOutputBuffer(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
   const private_handle_t *output_handle =
         static_cast<const private_handle_t *>(content_list->outbuf);
 
-  // Fill output buffer parameters (width, height, format, plane information, fence)
-  output_buffer_->acquire_fence_fd = content_list->outbufAcquireFenceFd;
-
   if (output_handle) {
     int output_handle_format = output_handle->format;
 
@@ -293,16 +290,26 @@
     if (output_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) {
       output_buffer_->flags.secure = 1;
     }
+  }
 
+  layer_stack_.output_buffer = output_buffer_;
+
+  return 0;
+}
+
+void HWCDisplayVirtual::CommitOutputBufferParams(hwc_display_contents_1_t *content_list) {
+  const private_handle_t *output_handle =
+        static_cast<const private_handle_t *>(content_list->outbuf);
+
+  // Fill output buffer parameters (width, height, format, plane information, fence)
+  output_buffer_->acquire_fence_fd = content_list->outbufAcquireFenceFd;
+
+  if (output_handle) {
     // ToDo: Need to extend for non-RGB formats
     output_buffer_->planes[0].fd = output_handle->fd;
     output_buffer_->planes[0].offset = output_handle->offset;
     output_buffer_->planes[0].stride = UINT32(output_handle->width);
   }
-
-  layer_stack_.output_buffer = output_buffer_;
-
-  return status;
 }
 
 void HWCDisplayVirtual::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
diff --git a/sdm/libs/hwc/hwc_display_virtual.h b/sdm/libs/hwc/hwc_display_virtual.h
index c383809..77e16d5 100644
--- a/sdm/libs/hwc/hwc_display_virtual.h
+++ b/sdm/libs/hwc/hwc_display_virtual.h
@@ -44,11 +44,11 @@
   virtual int Commit(hwc_display_contents_1_t *content_list);
   virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type);
 
-  int SetOutputSliceFromMetadata(hwc_display_contents_1_t *content_list);
-
  private:
   HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
   int SetOutputBuffer(hwc_display_contents_1_t *content_list);
+  int SetOutputSliceFromMetadata(hwc_display_contents_1_t *content_list);
+  void CommitOutputBufferParams(hwc_display_contents_1_t *content_list);
 
   bool dump_output_layer_ = false;
   LayerBuffer *output_buffer_ = NULL;
diff --git a/sdm/libs/hwc/hwc_session.cpp b/sdm/libs/hwc/hwc_session.cpp
index 8a6787a..95da143 100644
--- a/sdm/libs/hwc/hwc_session.cpp
+++ b/sdm/libs/hwc/hwc_session.cpp
@@ -129,20 +129,8 @@
     return -EINVAL;
   }
 
-  buffer_allocator_ = new HWCBufferAllocator();
-  if (buffer_allocator_ == NULL) {
-    DLOGE("Display core initialization failed due to no memory");
-    return -ENOMEM;
-  }
-
-  buffer_sync_handler_ = new HWCBufferSyncHandler();
-  if (buffer_sync_handler_ == NULL) {
-    DLOGE("Display core initialization failed due to no memory");
-    return -ENOMEM;
-  }
-
-  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), buffer_allocator_,
-                                                 buffer_sync_handler_, &core_intf_);
+  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
+                                                 &buffer_sync_handler_, &core_intf_);
   if (error != kErrorNone) {
     DLOGE("Display core initialization failed. Error = %d", error);
     return -EINVAL;
@@ -169,12 +157,12 @@
       }
     } else {
       // Create and power on primary display
-      status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
+      status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
                                          &hwc_display_[HWC_DISPLAY_PRIMARY]);
     }
   } else {
     // Create and power on primary display
-    status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
+    status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
                                        &hwc_display_[HWC_DISPLAY_PRIMARY]);
   }
 
diff --git a/sdm/libs/hwc/hwc_session.h b/sdm/libs/hwc/hwc_session.h
index 2bdae2b..2a732b2 100644
--- a/sdm/libs/hwc/hwc_session.h
+++ b/sdm/libs/hwc/hwc_session.h
@@ -133,8 +133,8 @@
   pthread_t uevent_thread_;
   bool uevent_thread_exit_ = false;
   const char *uevent_thread_name_ = "HWC_UeventThread";
-  HWCBufferAllocator *buffer_allocator_ = NULL;
-  HWCBufferSyncHandler *buffer_sync_handler_ = NULL;
+  HWCBufferAllocator buffer_allocator_;
+  HWCBufferSyncHandler buffer_sync_handler_;
   HWCColorManager *color_mgr_ = NULL;
   bool reset_panel_ = false;
   bool secure_display_active_ = false;
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index dec10c1..1f0bd55 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -76,7 +76,7 @@
 }
 
 HWC2::Error HWCColorMode::GetColorModes(uint32_t *out_num_modes,
-                                        int32_t /*android_color_mode_t*/ *out_modes) {
+                                        android_color_mode_t *out_modes) {
   auto it = color_mode_transform_map_.begin();
   for (auto i = 0; it != color_mode_transform_map_.end(); it++, i++) {
     out_modes[i] = it->first;
@@ -86,7 +86,7 @@
   return HWC2::Error::None;
 }
 
-HWC2::Error HWCColorMode::SetColorMode(int32_t /*android_color_mode_t*/ mode) {
+HWC2::Error HWCColorMode::SetColorMode(android_color_mode_t mode) {
   // first mode in 2D matrix is the mode (identity)
   auto status = HandleColorModeTransform(mode, current_color_transform_, color_matrix_);
   if (status != HWC2::Error::None) {
@@ -112,7 +112,7 @@
   return status;
 }
 
-HWC2::Error HWCColorMode::HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
+HWC2::Error HWCColorMode::HandleColorModeTransform(android_color_mode_t mode,
                                                    android_color_transform_t hint,
                                                    const double *matrix) {
   android_color_transform_t transform_hint = hint;
@@ -130,19 +130,23 @@
     transform_hint = HAL_COLOR_TRANSFORM_IDENTITY;
   }
 
-  color_mode_transform = color_mode_transform_map_[mode][transform_hint];
-  DisplayError error = display_intf_->SetColorMode(color_mode_transform);
-  if (error != kErrorNone) {
-    DLOGE("Failed to set color_mode  = %d transform_hint = %d", mode, hint);
-    // TODO(user): make use client composition
-    return HWC2::Error::Unsupported;
+  // if the mode count is 1, then only native mode is supported, so just apply matrix w/o
+  // setting mode
+  if (color_mode_transform_map_.size() > 1U) {
+    color_mode_transform = color_mode_transform_map_[mode][transform_hint];
+    DisplayError error = display_intf_->SetColorMode(color_mode_transform);
+    if (error != kErrorNone) {
+      DLOGE("Failed to set color_mode  = %d transform_hint = %d", mode, hint);
+      // failure to force client composition
+      return HWC2::Error::Unsupported;
+    }
   }
 
   if (use_matrix) {
     DisplayError error = display_intf_->SetColorTransform(kColorTransformMatrixCount, matrix);
     if (error != kErrorNone) {
       DLOGE("Failed to set Color Transform Matrix");
-      // TODO(user): make use client composition
+      // failure to force client composition
       return HWC2::Error::Unsupported;
     }
   }
@@ -161,7 +165,7 @@
   DisplayError error = display_intf_->GetColorModeCount(&color_mode_count);
   if (error != kErrorNone || (color_mode_count == 0)) {
     DLOGW("GetColorModeCount failed, use native color mode");
-    PopulateTransform(0, "native_identity");
+    PopulateTransform(HAL_COLOR_MODE_NATIVE, "native_identity");
     return;
   }
 
@@ -173,24 +177,24 @@
   for (uint32_t i = 0; i < color_mode_count; i++) {
     std::string &mode_string = color_modes.at(i);
     DLOGI("Color Mode[%d] = %s", i, mode_string.c_str());
-    if (mode_string.find("native") != std::string::npos) {
-      // TODO(user): replace numbers(0,1..) with android_color_mode_t
-      PopulateTransform(0, mode_string);
-    } else if (mode_string.find("srgb") != std::string::npos) {
-      PopulateTransform(1, mode_string);
-    } else if (mode_string.find("adobe") != std::string::npos) {
-      PopulateTransform(2, mode_string);
-    } else if (mode_string.find("dci3") != std::string::npos) {
-      PopulateTransform(3, mode_string);
+    if (mode_string.find("hal_native") != std::string::npos) {
+      PopulateTransform(HAL_COLOR_MODE_NATIVE, mode_string);
+    } else if (mode_string.find("hal_srgb") != std::string::npos) {
+      PopulateTransform(HAL_COLOR_MODE_SRGB, mode_string);
+    } else if (mode_string.find("hal_adobe") != std::string::npos) {
+      PopulateTransform(HAL_COLOR_MODE_ADOBE_RGB, mode_string);
+    } else if (mode_string.find("hal_dci_p3") != std::string::npos) {
+      PopulateTransform(HAL_COLOR_MODE_DCI_P3, mode_string);
     }
   }
 }
 
-void HWCColorMode::PopulateTransform(const int32_t &mode, const std::string &color_transform) {
+void HWCColorMode::PopulateTransform(const android_color_mode_t &mode,
+                                     const std::string &color_transform) {
   // TODO(user): Check the substring from QDCM
   if (color_transform.find("identity") != std::string::npos) {
     color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_IDENTITY] = color_transform;
-  } else if (color_transform.find("artitrary") != std::string::npos) {
+  } else if (color_transform.find("arbitrary") != std::string::npos) {
     // no color mode for arbitrary
   } else if (color_transform.find("inverse") != std::string::npos) {
     color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_VALUE_INVERSE] = color_transform;
@@ -507,9 +511,9 @@
   }
 }
 
-HWC2::Error HWCDisplay::GetColorModes(uint32_t *out_num_modes, int32_t *out_modes) {
+HWC2::Error HWCDisplay::GetColorModes(uint32_t *out_num_modes, android_color_mode_t *out_modes) {
   if (out_modes) {
-    out_modes[0] = 0;  // TODO(user): Change to android_color_mode_t
+    out_modes[0] = HAL_COLOR_MODE_NATIVE;
   }
   *out_num_modes = 1;
 
diff --git a/sdm/libs/hwc2/hwc_display.h b/sdm/libs/hwc2/hwc_display.h
index 69a2dea..277514d 100644
--- a/sdm/libs/hwc2/hwc_display.h
+++ b/sdm/libs/hwc2/hwc_display.h
@@ -55,17 +55,17 @@
   HWC2::Error Init();
   HWC2::Error DeInit();
   uint32_t GetColorModeCount();
-  HWC2::Error GetColorModes(uint32_t *out_num_modes, int32_t /*android_color_mode_t*/ *out_modes);
-  HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode);
+  HWC2::Error GetColorModes(uint32_t *out_num_modes, android_color_mode_t *out_modes);
+  HWC2::Error SetColorMode(android_color_mode_t mode);
   HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint);
 
  private:
   static const uint32_t kColorTransformMatrixCount = 16;
 
-  HWC2::Error HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
+  HWC2::Error HandleColorModeTransform(android_color_mode_t mode,
                                        android_color_transform_t hint, const double *matrix);
   void PopulateColorModes();
-  void PopulateTransform(const int32_t &mode, const std::string &color_mode);
+  void PopulateTransform(const android_color_mode_t &mode, const std::string &color_mode);
   template <class T>
   void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) {
     for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) {
@@ -74,11 +74,10 @@
   }
 
   DisplayInterface *display_intf_ = NULL;
-  int32_t current_color_mode_ = 0;  // android_color_mode_t
+  android_color_mode_t current_color_mode_ = HAL_COLOR_MODE_NATIVE;
   android_color_transform_t current_color_transform_ = HAL_COLOR_TRANSFORM_IDENTITY;
   typedef std::map<android_color_transform_t, std::string> TransformMap;
-  // TODO(user): change int32_t to android_color_mode_t when defined
-  std::map<int32_t, TransformMap> color_mode_transform_map_ = {};
+  std::map<android_color_mode_t, TransformMap> color_mode_transform_map_ = {};
   double color_matrix_[kColorTransformMatrixCount] = {0};
 };
 
@@ -142,13 +141,13 @@
   virtual HWC2::Error SetActiveConfig(hwc2_config_t config);
   virtual HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
                                       int32_t dataspace, hwc_region_t damage);
-  virtual HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode) {
+  virtual HWC2::Error SetColorMode(android_color_mode_t mode) {
     return HWC2::Error::Unsupported;
   }
   virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint) {
     return HWC2::Error::Unsupported;
   }
-  virtual HWC2::Error HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
+  virtual HWC2::Error HandleColorModeTransform(android_color_mode_t mode,
                                                android_color_transform_t hint,
                                                const double *matrix) {
     return HWC2::Error::Unsupported;
@@ -158,7 +157,7 @@
                                           int32_t *out_value);
   virtual HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height, int32_t format,
                                              int32_t dataspace);
-  virtual HWC2::Error GetColorModes(uint32_t *outNumModes, int32_t *outModes);
+  virtual HWC2::Error GetColorModes(uint32_t *outNumModes, android_color_mode_t *outModes);
   virtual HWC2::Error GetChangedCompositionTypes(uint32_t *out_num_elements,
                                                  hwc2_layer_t *out_layers, int32_t *out_types);
   virtual HWC2::Error GetDisplayRequests(int32_t *out_display_requests, uint32_t *out_num_elements,
diff --git a/sdm/libs/hwc2/hwc_display_primary.cpp b/sdm/libs/hwc2/hwc_display_primary.cpp
index bd1cc54..56ff335 100644
--- a/sdm/libs/hwc2/hwc_display_primary.cpp
+++ b/sdm/libs/hwc2/hwc_display_primary.cpp
@@ -232,7 +232,7 @@
 }
 
 HWC2::Error HWCDisplayPrimary::GetColorModes(uint32_t *out_num_modes,
-                                             int32_t /*android_color_mode_t*/ *out_modes) {
+                                             android_color_mode_t *out_modes) {
   if (out_modes == nullptr) {
     *out_num_modes = color_mode_->GetColorModeCount();
   } else {
@@ -242,7 +242,7 @@
   return HWC2::Error::None;
 }
 
-HWC2::Error HWCDisplayPrimary::SetColorMode(int32_t /*android_color_mode_t*/ mode) {
+HWC2::Error HWCDisplayPrimary::SetColorMode(android_color_mode_t mode) {
   auto status = color_mode_->SetColorMode(mode);
   if (status != HWC2::Error::None) {
     DLOGE("failed for mode = %d", mode);
diff --git a/sdm/libs/hwc2/hwc_display_primary.h b/sdm/libs/hwc2/hwc_display_primary.h
index 41b0c9f..32d265e 100644
--- a/sdm/libs/hwc2/hwc_display_primary.h
+++ b/sdm/libs/hwc2/hwc_display_primary.h
@@ -54,8 +54,8 @@
   virtual int Init();
   virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests);
   virtual HWC2::Error Present(int32_t *out_retire_fence);
-  virtual HWC2::Error GetColorModes(uint32_t *out_num_modes, int32_t *out_modes);
-  virtual HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode);
+  virtual HWC2::Error GetColorModes(uint32_t *out_num_modes, android_color_mode_t *out_modes);
+  virtual HWC2::Error SetColorMode(android_color_mode_t mode);
   virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint);
   virtual int Perform(uint32_t operation, ...);
   virtual void SetSecureDisplay(bool secure_display_active);
diff --git a/sdm/libs/hwc2/hwc_session.cpp b/sdm/libs/hwc2/hwc_session.cpp
index e892d26..9344ed6 100644
--- a/sdm/libs/hwc2/hwc_session.cpp
+++ b/sdm/libs/hwc2/hwc_session.cpp
@@ -94,20 +94,8 @@
     return -EINVAL;
   }
 
-  buffer_allocator_ = new HWCBufferAllocator();
-  if (buffer_allocator_ == NULL) {
-    DLOGE("Display core initialization failed due to no memory");
-    return -ENOMEM;
-  }
-
-  buffer_sync_handler_ = new HWCBufferSyncHandler();
-  if (buffer_sync_handler_ == NULL) {
-    DLOGE("Display core initialization failed due to no memory");
-    return -ENOMEM;
-  }
-
-  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), buffer_allocator_,
-                                                 buffer_sync_handler_, &core_intf_);
+  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
+                                                 &buffer_sync_handler_, &core_intf_);
   if (error != kErrorNone) {
     DLOGE("Display core initialization failed. Error = %d", error);
     return -EINVAL;
@@ -125,7 +113,7 @@
                                         &hwc_display_[HWC_DISPLAY_PRIMARY]);
   } else {
     // Create and power on primary display
-    status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &callbacks_, qservice_,
+    status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &callbacks_, qservice_,
                                        &hwc_display_[HWC_DISPLAY_PRIMARY]);
   }
 
@@ -319,7 +307,8 @@
 }
 
 static int32_t GetColorModes(hwc2_device_t *device, hwc2_display_t display, uint32_t *out_num_modes,
-                             int32_t /*android_color_mode_t*/ *out_modes) {
+                             int32_t /*android_color_mode_t*/ *int_out_modes) {
+  auto out_modes = reinterpret_cast<android_color_mode_t *>(int_out_modes);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::GetColorModes, out_num_modes,
                                          out_modes);
 }
@@ -435,7 +424,8 @@
 }
 
 int32_t HWCSession::SetColorMode(hwc2_device_t *device, hwc2_display_t display,
-                                 int32_t /*android_color_mode_t*/ mode) {
+                                 int32_t /*android_color_mode_t*/ int_mode) {
+  auto mode = static_cast<android_color_mode_t>(int_mode);
   SEQUENCE_WAIT_SCOPE_LOCK(locker_);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
 }
@@ -843,9 +833,13 @@
       status = GetBWTransactionStatus(input_parcel, output_parcel);
       break;
 
-  case qService::IQService::SET_LAYER_MIXER_RESOLUTION:
-    status = SetMixerResolution(input_parcel);
-    break;
+    case qService::IQService::SET_LAYER_MIXER_RESOLUTION:
+      status = SetMixerResolution(input_parcel);
+      break;
+
+    case qService::IQService::SET_COLOR_MODE:
+      status = SetColorModeOverride(input_parcel);
+      break;
 
     default:
       DLOGW("QService command = %d is not supported", command);
@@ -1210,6 +1204,16 @@
   return 0;
 }
 
+android::status_t HWCSession::SetColorModeOverride(const android::Parcel *input_parcel) {
+  auto display = static_cast<hwc2_display_t >(input_parcel->readInt32());
+  auto mode = static_cast<android_color_mode_t>(input_parcel->readInt32());
+  auto device = static_cast<hwc2_device_t *>(this);
+  auto err = CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
+  if (err != HWC2_ERROR_NONE)
+    return -EINVAL;
+  return 0;
+}
+
 void HWCSession::DynamicDebug(const android::Parcel *input_parcel) {
   int type = input_parcel->readInt32();
   bool enable = (input_parcel->readInt32() > 0);
diff --git a/sdm/libs/hwc2/hwc_session.h b/sdm/libs/hwc2/hwc_session.h
index 63cce84..ce3e27f 100644
--- a/sdm/libs/hwc2/hwc_session.h
+++ b/sdm/libs/hwc2/hwc_session.h
@@ -102,7 +102,7 @@
   static int32_t ValidateDisplay(hwc2_device_t *device, hwc2_display_t display,
                                  uint32_t *out_num_types, uint32_t *out_num_requests);
   static int32_t SetColorMode(hwc2_device_t *device, hwc2_display_t display,
-                              int32_t /*android_color_mode_t*/ mode);
+                              int32_t /*android_color_mode_t*/ int_mode);
   static int32_t SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
                                    const float *matrix, int32_t /*android_color_transform_t*/ hint);
 
@@ -166,6 +166,8 @@
                                            android::Parcel *output_parcel);
   android::status_t SetMixerResolution(const android::Parcel *input_parcel);
 
+  android::status_t SetColorModeOverride(const android::Parcel *input_parcel);
+
   static Locker locker_;
   CoreInterface *core_intf_ = NULL;
   HWCDisplay *hwc_display_[HWC_NUM_DISPLAY_TYPES] = {NULL};
@@ -173,8 +175,8 @@
   pthread_t uevent_thread_;
   bool uevent_thread_exit_ = false;
   const char *uevent_thread_name_ = "HWC_UeventThread";
-  HWCBufferAllocator *buffer_allocator_ = NULL;
-  HWCBufferSyncHandler *buffer_sync_handler_ = NULL;
+  HWCBufferAllocator buffer_allocator_;
+  HWCBufferSyncHandler buffer_sync_handler_;
   HWCColorManager *color_mgr_ = NULL;
   bool reset_panel_ = false;
   bool secure_display_active_ = false;