diff --git a/sdm/include/core/display_interface.h b/sdm/include/core/display_interface.h
index b8e2a9e..142d2c6 100644
--- a/sdm/include/core/display_interface.h
+++ b/sdm/include/core/display_interface.h
@@ -137,8 +137,9 @@
 
 /*! @brief This enum represents the events received by Display HAL. */
 enum DisplayEvent {
-  kIdleTimeout,    // Event triggered by Idle Timer.
-  kThermalEvent,   // Event triggered by Thermal.
+  kIdleTimeout,        // Event triggered by Idle Timer.
+  kThermalEvent,       // Event triggered by Thermal.
+  kIdlePowerCollapse,  // Event triggered by Idle Power Collapse.
 };
 
 /*! @brief This structure defines configuration for fixed properties of a display device.
diff --git a/sdm/include/private/color_params.h b/sdm/include/private/color_params.h
index fdab206..2cfb99e 100644
--- a/sdm/include/private/color_params.h
+++ b/sdm/include/private/color_params.h
@@ -297,6 +297,7 @@
   static const int kGamutTableNum = 4;
   static const int kGamutScaleoffTableNum = 3;
   static const int kGamutTableSize = 1229;
+  static const int kGamutTableCoarse13Size = 550;
   static const int kGamutTableCoarseSize = 32;
   static const int kGamutScaleoffSize = 16;
   uint32_t mode;
diff --git a/sdm/include/private/hw_info_types.h b/sdm/include/private/hw_info_types.h
index 5d19952..b6c4690 100644
--- a/sdm/include/private/hw_info_types.h
+++ b/sdm/include/private/hw_info_types.h
@@ -109,6 +109,19 @@
   kOneShotMode,     // Mode to enable AVR feature for particular frame.
 };
 
+enum HWTopology {
+  kUnknown,
+  kSingleLM,
+  kSingleLMDSC,
+  kDualLM,
+  kDualLMDSC,
+  kDualLMMerge,
+  kDualLMMergeDSC,
+  kDualLMDSCMerge,
+  kPPSplit,
+};
+
+
 typedef std::map<HWSubBlockType, std::vector<LayerBufferFormat>> FormatsMap;
 typedef std::map<LayerBufferFormat, float> CompRatioMap;
 
@@ -557,6 +570,8 @@
   uint32_t h_total = 0;        //!< Total width of panel (hActive + hFP + hBP + hPulseWidth)
   uint32_t v_total = 0;        //!< Total height of panel (vActive + vFP + vBP + vPulseWidth)
   std::bitset<32> s3d_config;  //!< Stores the bit mask of S3D modes
+  uint32_t clock_khz = 0;      //!< Stores the pixel clock of panel in khz
+  HWTopology topology = kUnknown;  //!< Stores the topology information.
 
   void Reset() { *this = HWDisplayAttributes(); }
 
@@ -572,7 +587,10 @@
             (v_back_porch != display_attributes.v_back_porch) ||
             (v_pulse_width != display_attributes.v_pulse_width) ||
             (h_total != display_attributes.h_total) ||
-            (is_yuv != display_attributes.is_yuv));
+            (is_yuv != display_attributes.is_yuv) ||
+            (s3d_config != display_attributes.s3d_config) ||
+            (clock_khz != display_attributes.clock_khz) ||
+            (topology != display_attributes.topology));
   }
 
   bool operator ==(const HWDisplayAttributes &display_attributes) {
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index 1037b7d..1ffe862 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -307,10 +307,9 @@
 
   CommitLayerParams(layer_stack);
 
-  if (comp_manager_->Commit(display_comp_ctx_, &hw_layers_)) {
-    if (error != kErrorNone) {
-      return error;
-    }
+  error = comp_manager_->Commit(display_comp_ctx_, &hw_layers_);
+  if (error != kErrorNone) {
+    return error;
   }
 
   // check if feature list cache is dirty and pending.
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
index 64a0bcc..8f3d6f0 100644
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -280,10 +280,15 @@
 }
 
 void DisplayPrimary::IdleTimeout() {
-  handle_idle_timeout_ = true;
-  event_handler_->Refresh();
-  comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
-  event_handler_->HandleEvent(kIdleTimeout);
+  if (hw_panel_info_.mode == kModeCommand) {
+    IdlePowerCollapse();
+  } else {
+    event_handler_->HandleEvent(kIdleTimeout);
+    handle_idle_timeout_ = true;
+    event_handler_->Refresh();
+    lock_guard<recursive_mutex> obj(recursive_mutex_);
+    comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
+  }
 }
 
 void DisplayPrimary::PingPongTimeout() {
@@ -292,12 +297,13 @@
 }
 
 void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
+  event_handler_->HandleEvent(kThermalEvent);
   lock_guard<recursive_mutex> obj(recursive_mutex_);
   comp_manager_->ProcessThermalEvent(display_comp_ctx_, thermal_level);
-  event_handler_->HandleEvent(kThermalEvent);
 }
 
 void DisplayPrimary::IdlePowerCollapse() {
+  event_handler_->HandleEvent(kIdlePowerCollapse);
   lock_guard<recursive_mutex> obj(recursive_mutex_);
   comp_manager_->ProcessIdlePowerCollapse(display_comp_ctx_);
 }
diff --git a/sdm/libs/core/drm/hw_device_drm.cpp b/sdm/libs/core/drm/hw_device_drm.cpp
index 8ee52ba..bd09a38 100644
--- a/sdm/libs/core/drm/hw_device_drm.cpp
+++ b/sdm/libs/core/drm/hw_device_drm.cpp
@@ -411,7 +411,6 @@
   uint32_t mm_width = 0;
   uint32_t mm_height = 0;
   DRMTopology topology = DRMTopology::SINGLE_LM;
-  bool dual_display = false;
 
   if (default_mode_) {
     DRMResMgr *res_mgr = nullptr;
@@ -451,14 +450,11 @@
   display_attributes_[index].v_back_porch = mode.vtotal - mode.vsync_end;
   display_attributes_[index].v_total = mode.vtotal;
   display_attributes_[index].h_total = mode.htotal;
-  uint32_t h_blanking = mode.htotal - mode.hdisplay;
   display_attributes_[index].is_device_split =
       (topology == DRMTopology::DUAL_LM || topology == DRMTopology::DUAL_LM_MERGE ||
        topology == DRMTopology::DUAL_LM_MERGE_DSC || topology == DRMTopology::DUAL_LM_DSC ||
        topology == DRMTopology::DUAL_LM_DSCMERGE);
-  dual_display = (topology == DRMTopology::DUAL_LM || topology == DRMTopology::DUAL_LM_DSC ||
-       topology == DRMTopology::PPSPLIT);
-  display_attributes_[index].h_total += dual_display ? h_blanking : 0;
+  display_attributes_[index].clock_khz = mode.clock;
 
   // If driver doesn't return panel width/height information, default to 320 dpi
   if (INT(mm_width) <= 0 || INT(mm_height) <= 0) {
@@ -469,15 +465,17 @@
 
   display_attributes_[index].x_dpi = (FLOAT(mode.hdisplay) * 25.4f) / FLOAT(mm_width);
   display_attributes_[index].y_dpi = (FLOAT(mode.vdisplay) * 25.4f) / FLOAT(mm_height);
+  SetTopology(topology, &display_attributes_[index].topology);
 
   DLOGI("Display attributes[%d]: WxH: %dx%d, DPI: %fx%f, FPS: %d, LM_SPLIT: %d, V_BACK_PORCH: %d," \
-        " V_FRONT_PORCH: %d, V_PULSE_WIDTH: %d, V_TOTAL: %d, H_TOTAL: %d, TOPOLOGY: %d", index,
-        display_attributes_[index].x_pixels, display_attributes_[index].y_pixels,
+        " V_FRONT_PORCH: %d, V_PULSE_WIDTH: %d, V_TOTAL: %d, H_TOTAL: %d, CLK: %dKHZ, TOPOLOGY: %d",
+        index, display_attributes_[index].x_pixels, display_attributes_[index].y_pixels,
         display_attributes_[index].x_dpi, display_attributes_[index].y_dpi,
         display_attributes_[index].fps, display_attributes_[index].is_device_split,
         display_attributes_[index].v_back_porch, display_attributes_[index].v_front_porch,
         display_attributes_[index].v_pulse_width, display_attributes_[index].v_total,
-        display_attributes_[index].h_total, topology);
+        display_attributes_[index].h_total, display_attributes_[index].clock_khz,
+        display_attributes_[index].topology);
 
   return kErrorNone;
 }
@@ -1395,4 +1393,18 @@
   }
 }
 
+void HWDeviceDRM::SetTopology(sde_drm::DRMTopology drm_topology, HWTopology *hw_topology) {
+  switch (drm_topology) {
+    case DRMTopology::SINGLE_LM:          *hw_topology = kSingleLM;        break;
+    case DRMTopology::SINGLE_LM_DSC:      *hw_topology = kSingleLMDSC;     break;
+    case DRMTopology::DUAL_LM:            *hw_topology = kDualLM;          break;
+    case DRMTopology::DUAL_LM_DSC:        *hw_topology = kDualLMDSC;       break;
+    case DRMTopology::DUAL_LM_MERGE:      *hw_topology = kDualLMMerge;     break;
+    case DRMTopology::DUAL_LM_MERGE_DSC:  *hw_topology = kDualLMMergeDSC;  break;
+    case DRMTopology::DUAL_LM_DSCMERGE:   *hw_topology = kDualLMDSCMerge;  break;
+    case DRMTopology::PPSPLIT:            *hw_topology = kPPSplit;         break;
+    default:                              *hw_topology = kUnknown;         break;
+  }
+}
+
 }  // namespace sdm
diff --git a/sdm/libs/core/drm/hw_device_drm.h b/sdm/libs/core/drm/hw_device_drm.h
index 883d605..cc17668 100644
--- a/sdm/libs/core/drm/hw_device_drm.h
+++ b/sdm/libs/core/drm/hw_device_drm.h
@@ -133,6 +133,7 @@
                        sde_drm::DRMSecurityLevel *security_level);
   bool IsResolutionSwitchEnabled() const { return resolution_switch_enabled_; }
   void UpdatePanelSplitInfo();
+  void SetTopology(sde_drm::DRMTopology drm_topology, HWTopology *hw_topology);
 
   class Registry {
    public:
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index 2541ec3..723148b 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -40,6 +40,7 @@
 #include "hwc_display.h"
 #include "hwc_debugger.h"
 #include "hwc_tonemapper.h"
+#include "hwc_session.h"
 
 #ifndef USE_GRALLOC1
 #include <gr.h>
@@ -952,6 +953,8 @@
   switch (event) {
     case kIdleTimeout:
     case kThermalEvent:
+    case kIdlePowerCollapse:
+      HWCSession::WaitForSequence(id_);
       validated_.reset();
       break;
     default:
diff --git a/sdm/libs/hwc2/hwc_session.cpp b/sdm/libs/hwc2/hwc_session.cpp
index 2039a46..89de074 100644
--- a/sdm/libs/hwc2/hwc_session.cpp
+++ b/sdm/libs/hwc2/hwc_session.cpp
@@ -70,7 +70,7 @@
 namespace sdm {
 
 static HWCUEvent g_hwc_uevent_;
-Locker HWCSession::locker_;
+Locker HWCSession::locker_[HWC_NUM_DISPLAY_TYPES];
 
 void HWCUEvent::UEventThread(HWCUEvent *hwc_uevent) {
   const char *uevent_thread_name = "HWC_UeventThread";
@@ -135,6 +135,8 @@
 }
 
 int HWCSession::Init() {
+  SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
+
   int status = -EINVAL;
   const char *qservice_name = "display.qservice";
 
@@ -224,6 +226,10 @@
 }
 
 int HWCSession::Deinit() {
+  Locker::SequenceCancelScopeLock lock_v(locker_[HWC_DISPLAY_VIRTUAL]);
+  Locker::SequenceCancelScopeLock lock_e(locker_[HWC_DISPLAY_EXTERNAL]);
+  Locker::SequenceCancelScopeLock lock_p(locker_[HWC_DISPLAY_PRIMARY]);
+
   HWCDisplay *primary_display = hwc_display_[HWC_DISPLAY_PRIMARY];
   if (primary_display) {
     if (hdmi_is_primary_) {
@@ -249,8 +255,6 @@
 }
 
 int HWCSession::Open(const hw_module_t *module, const char *name, hw_device_t **device) {
-  SCOPE_LOCK(locker_);
-
   if (!module || !name || !device) {
     DLOGE("Invalid parameters.");
     return -EINVAL;
@@ -275,8 +279,6 @@
 }
 
 int HWCSession::Close(hw_device_t *device) {
-  SCOPE_LOCK(locker_);
-
   if (!device) {
     return -EINVAL;
   }
@@ -317,20 +319,20 @@
 // Defined in the same order as in the HWC2 header
 
 int32_t HWCSession::AcceptDisplayChanges(hwc2_device_t *device, hwc2_display_t display) {
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[display]);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::AcceptDisplayChanges);
 }
 
 int32_t HWCSession::CreateLayer(hwc2_device_t *device, hwc2_display_t display,
                                 hwc2_layer_t *out_layer_id) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
   return CallDisplayFunction(device, display, &HWCDisplay::CreateLayer, out_layer_id);
 }
 
 int32_t HWCSession::CreateVirtualDisplay(hwc2_device_t *device, uint32_t width, uint32_t height,
                                          int32_t *format, hwc2_display_t *out_display_id) {
   // TODO(user): Handle concurrency with HDMI
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[HWC_DISPLAY_VIRTUAL]);
   if (!device) {
     return HWC2_ERROR_BAD_DISPLAY;
   }
@@ -349,16 +351,16 @@
 
 int32_t HWCSession::DestroyLayer(hwc2_device_t *device, hwc2_display_t display,
                                  hwc2_layer_t layer) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
   return CallDisplayFunction(device, display, &HWCDisplay::DestroyLayer, layer);
 }
 
 int32_t HWCSession::DestroyVirtualDisplay(hwc2_device_t *device, hwc2_display_t display) {
-  SCOPE_LOCK(locker_);
   if (!device || display != HWC_DISPLAY_VIRTUAL) {
     return HWC2_ERROR_BAD_DISPLAY;
   }
 
+  SCOPE_LOCK(locker_[display]);
   DLOGI("Destroying virtual display id:%" PRIu64, display);
   auto *hwc_session = static_cast<HWCSession *>(device);
 
@@ -372,8 +374,6 @@
 }
 
 void HWCSession::Dump(hwc2_device_t *device, uint32_t *out_size, char *out_buffer) {
-  SCOPE_LOCK(locker_);
-
   if (!device) {
     return;
   }
@@ -387,6 +387,7 @@
     DumpInterface::GetDump(sdm_dump, 4096);  // TODO(user): Fix this workaround
     std::string s("");
     for (int id = HWC_DISPLAY_PRIMARY; id <= HWC_DISPLAY_VIRTUAL; id++) {
+      SEQUENCE_WAIT_SCOPE_LOCK(locker_[id]);
       if (hwc_session->hwc_display_[id]) {
         s += hwc_session->hwc_display_[id]->Dump();
       }
@@ -490,6 +491,7 @@
                                    int32_t *out_retire_fence) {
   HWCSession *hwc_session = static_cast<HWCSession *>(device);
   DTRACE_SCOPED();
+  SEQUENCE_EXIT_SCOPE_LOCK(locker_[display]);
   if (!device) {
     return HWC2_ERROR_BAD_DISPLAY;
   }
@@ -541,14 +543,14 @@
 int32_t HWCSession::SetColorMode(hwc2_device_t *device, hwc2_display_t display,
                                  int32_t /*android_color_mode_t*/ int_mode) {
   auto mode = static_cast<android_color_mode_t>(int_mode);
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[display]);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
 }
 
 int32_t HWCSession::SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
                                       const float *matrix,
                                       int32_t /*android_color_transform_t*/ hint) {
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[display]);
   android_color_transform_t transform_hint = static_cast<android_color_transform_t>(hint);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorTransform, matrix,
                                          transform_hint);
@@ -634,7 +636,7 @@
 
 int32_t HWCSession::SetLayerZOrder(hwc2_device_t *device, hwc2_display_t display,
                                    hwc2_layer_t layer, uint32_t z) {
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[display]);
   return CallDisplayFunction(device, display, &HWCDisplay::SetLayerZOrder, layer, z);
 }
 
@@ -648,6 +650,7 @@
     return HWC2_ERROR_UNSUPPORTED;
   }
 
+  SCOPE_LOCK(locker_[display]);
   auto *hwc_session = static_cast<HWCSession *>(device);
   if (hwc_session->hwc_display_[display]) {
     auto vds = reinterpret_cast<HWCDisplayVirtual *>(hwc_session->hwc_display_[display]);
@@ -660,7 +663,7 @@
 
 int32_t HWCSession::SetPowerMode(hwc2_device_t *device, hwc2_display_t display, int32_t int_mode) {
   auto mode = static_cast<HWC2::PowerMode>(int_mode);
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
   return CallDisplayFunction(device, display, &HWCDisplay::SetPowerMode, mode);
 }
 
@@ -672,7 +675,6 @@
 int32_t HWCSession::ValidateDisplay(hwc2_device_t *device, hwc2_display_t display,
                                     uint32_t *out_num_types, uint32_t *out_num_requests) {
   DTRACE_SCOPED();
-  SCOPE_LOCK(locker_);
   HWCSession *hwc_session = static_cast<HWCSession *>(device);
   if (!device) {
     return HWC2_ERROR_BAD_DISPLAY;
@@ -681,25 +683,35 @@
   // TODO(user): Handle secure session, handle QDCM solid fill
   // Handle external_pending_connect_ in CreateVirtualDisplay
   auto status = HWC2::Error::BadDisplay;
-  if (hwc_session->hwc_display_[display]) {
-    if (display == HWC_DISPLAY_PRIMARY) {
-      // TODO(user): This can be moved to HWCDisplayPrimary
-      if (hwc_session->reset_panel_) {
-        DLOGW("panel is in bad state, resetting the panel");
-        hwc_session->ResetPanel();
+  {
+    SEQUENCE_ENTRY_SCOPE_LOCK(locker_[display]);
+    if (hwc_session->hwc_display_[display]) {
+      if (display == HWC_DISPLAY_PRIMARY) {
+        // TODO(user): This can be moved to HWCDisplayPrimary
+        if (hwc_session->reset_panel_) {
+          DLOGW("panel is in bad state, resetting the panel");
+          hwc_session->ResetPanel();
+        }
+
+        if (hwc_session->need_invalidate_) {
+          hwc_session->Refresh(display);
+        }
+
+        if (hwc_session->color_mgr_) {
+          hwc_session->color_mgr_->SetColorModeDetailEnhancer(hwc_session->hwc_display_[display]);
+        }
       }
 
-      if (hwc_session->need_invalidate_) {
-        hwc_session->Refresh(display);
-      }
-
-      if (hwc_session->color_mgr_) {
-        hwc_session->color_mgr_->SetColorModeDetailEnhancer(hwc_session->hwc_display_[display]);
-      }
+      status = hwc_session->hwc_display_[display]->Validate(out_num_types, out_num_requests);
     }
-
-    status = hwc_session->hwc_display_[display]->Validate(out_num_types, out_num_requests);
   }
+
+  // If validate fails, cancel the sequence lock so that other operations
+  // (such as Dump or SetPowerMode) may succeed without blocking on the condition
+  if (status == HWC2::Error::BadDisplay) {
+    SEQUENCE_CANCEL_SCOPE_LOCK(locker_[display]);
+  }
+
   return INT32(status);
 }
 
@@ -1013,8 +1025,6 @@
 android::status_t HWCSession::HandleGetDisplayAttributesForConfig(const android::Parcel
                                                                   *input_parcel,
                                                                   android::Parcel *output_parcel) {
-  SCOPE_LOCK(locker_);
-
   int config = input_parcel->readInt32();
   int dpy = input_parcel->readInt32();
   int error = android::BAD_VALUE;
@@ -1024,6 +1034,7 @@
     return android::BAD_VALUE;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[dpy]);
   if (hwc_display_[dpy]) {
     error = hwc_display_[dpy]->GetDisplayAttributesForConfig(config, &display_attributes);
     if (error == 0) {
@@ -1040,7 +1051,7 @@
 }
 
 android::status_t HWCSession::ConfigureRefreshRate(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   uint32_t operation = UINT32(input_parcel->readInt32());
   HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
@@ -1066,20 +1077,19 @@
 }
 
 android::status_t HWCSession::SetDisplayMode(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   uint32_t mode = UINT32(input_parcel->readInt32());
   return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(HWCDisplayPrimary::SET_DISPLAY_MODE, mode);
 }
 
 android::status_t HWCSession::SetMaxMixerStages(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
-
   DisplayError error = kErrorNone;
   std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
   uint32_t max_mixer_stages = UINT32(input_parcel->readInt32());
 
   if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
     if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
       error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetMaxMixerStages(max_mixer_stages);
       if (error != kErrorNone) {
@@ -1089,6 +1099,7 @@
   }
 
   if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_EXTERNAL]);
     if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
       error = hwc_display_[HWC_DISPLAY_EXTERNAL]->SetMaxMixerStages(max_mixer_stages);
       if (error != kErrorNone) {
@@ -1098,6 +1109,7 @@
   }
 
   if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_VIRTUAL]);
     if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
       error = hwc_display_[HWC_DISPLAY_VIRTUAL]->SetMaxMixerStages(max_mixer_stages);
       if (error != kErrorNone) {
@@ -1110,25 +1122,26 @@
 }
 
 void HWCSession::SetFrameDumpConfig(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
-
   uint32_t frame_dump_count = UINT32(input_parcel->readInt32());
   std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
   uint32_t bit_mask_layer_type = UINT32(input_parcel->readInt32());
 
   if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
     if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
       hwc_display_[HWC_DISPLAY_PRIMARY]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
     }
   }
 
   if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_EXTERNAL]);
     if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
       hwc_display_[HWC_DISPLAY_EXTERNAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
     }
   }
 
   if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_VIRTUAL]);
     if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
       hwc_display_[HWC_DISPLAY_VIRTUAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
     }
@@ -1136,8 +1149,6 @@
 }
 
 android::status_t HWCSession::SetMixerResolution(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
-
   DisplayError error = kErrorNone;
   uint32_t dpy = UINT32(input_parcel->readInt32());
 
@@ -1146,6 +1157,7 @@
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
   if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
     DLOGI("Primary display is not initialized");
     return -EINVAL;
@@ -1166,6 +1178,8 @@
   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);
+
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
   auto err = CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
   if (err != HWC2_ERROR_NONE)
     return -EINVAL;
@@ -1181,6 +1195,7 @@
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
   auto err = CallDisplayFunction(device, display, &HWCDisplay::SetColorModeById, mode);
   if (err != HWC2_ERROR_NONE)
     return -EINVAL;
@@ -1188,7 +1203,7 @@
 }
 
 void HWCSession::DynamicDebug(const android::Parcel *input_parcel) {
-  SCOPE_LOCK(locker_);
+  // TODO(user): Do we really need a lock here?
 
   int type = input_parcel->readInt32();
   bool enable = (input_parcel->readInt32() > 0);
@@ -1427,13 +1442,12 @@
   // To prevent sending events to client while a lock is held, acquire scope locks only within
   // below scope so that those get automatically unlocked after the scope ends.
   do {
-    SCOPE_LOCK(locker_);
-
     // If HDMI is primary but not created yet (first time), create it and notify surfaceflinger.
     //    if it is already created, but got disconnected/connected again,
     //    just toggle display status and do not notify surfaceflinger.
     // If HDMI is not primary, create/destroy external display normally.
     if (hdmi_is_primary_) {
+      SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
       if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
         status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetState(connected);
       } else {
@@ -1445,13 +1459,18 @@
       break;
     }
 
-    // Primary display must be connected for HDMI as secondary cases.
-    if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
-      DLOGE("Primary display is not connected.");
-      return -1;
+    {
+      SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
+      // Primary display must be connected for HDMI as secondary cases.
+      if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
+        DLOGE("Primary display is not connected.");
+        return -1;
+      }
     }
 
     if (connected) {
+      SCOPE_LOCK(locker_[HWC_DISPLAY_EXTERNAL]);
+      Locker::ScopeLock lock_v(locker_[HWC_DISPLAY_VIRTUAL]);
       // Connect external display if virtual display is not connected.
       // Else, defer external display connection and process it when virtual display
       // tears down; Do not notify SurfaceFlinger since connection is deferred now.
@@ -1466,6 +1485,7 @@
         external_pending_connect_ = true;
       }
     } else {
+      SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_EXTERNAL]);
       // Do not return error if external display is not in connected status.
       // Due to virtual display concurrency, external display connection might be still pending
       // but hdmi got disconnected before pending connection could be processed.
@@ -1500,7 +1520,7 @@
 }
 
 int HWCSession::GetVsyncPeriod(int disp) {
-  SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_[disp]);
   // default value
   int32_t vsync_period = 1000000000l / 60;
   auto attribute = HWC2::Attribute::VsyncPeriod;
@@ -1514,14 +1534,12 @@
 
 android::status_t HWCSession::GetVisibleDisplayRect(const android::Parcel *input_parcel,
                                                     android::Parcel *output_parcel) {
-  SCOPE_LOCK(locker_);
-
   int dpy = input_parcel->readInt32();
-
   if (dpy < HWC_DISPLAY_PRIMARY || dpy > HWC_DISPLAY_VIRTUAL) {
     return android::BAD_VALUE;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[dpy]);
   if (!hwc_display_[dpy]) {
     return android::NO_INIT;
   }
diff --git a/sdm/libs/hwc2/hwc_session.h b/sdm/libs/hwc2/hwc_session.h
index f09ed0e..4dbcf9b 100644
--- a/sdm/libs/hwc2/hwc_session.h
+++ b/sdm/libs/hwc2/hwc_session.h
@@ -140,6 +140,12 @@
   static int32_t SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
                                    const float *matrix, int32_t /*android_color_transform_t*/ hint);
 
+  // Meant to be called by HWCDisplay to preserve sequence of validate/present during events from
+  // polling thread
+  static void WaitForSequence(hwc2_display_t display) {
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[display]);
+  }
+
  private:
   static const int kExternalConnectionTimeoutMs = 500;
   static const int kPartialUpdateControlTimeoutMs = 100;
@@ -221,7 +227,7 @@
   void Refresh(hwc2_display_t display);
   void HotPlug(hwc2_display_t display, HWC2::Connection state);
 
-  static Locker locker_;
+  static Locker locker_[HWC_NUM_DISPLAY_TYPES];
   CoreInterface *core_intf_ = nullptr;
   HWCDisplay *hwc_display_[HWC_NUM_DISPLAY_TYPES] = {nullptr};
   HWCCallbacks callbacks_;
diff --git a/sdm/libs/hwc2/hwc_session_services.cpp b/sdm/libs/hwc2/hwc_session_services.cpp
index 425ffbe..a5cf66a 100644
--- a/sdm/libs/hwc2/hwc_session_services.cpp
+++ b/sdm/libs/hwc2/hwc_session_services.cpp
@@ -92,12 +92,12 @@
 // Methods from ::vendor::hardware::display::config::V1_0::IDisplayConfig follow.
 Return<void> HWCSession::isDisplayConnected(IDisplayConfig::DisplayType dpy,
                                             isDisplayConnected_cb _hidl_cb) {
-  SCOPE_LOCK(locker_);
-
   int32_t error = -EINVAL;
   bool connected = false;
 
   int disp_id = MapDisplayType(dpy);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
+
   if (disp_id >= 0) {
     connected = hwc_display_[disp_id];
     error = 0;
@@ -109,12 +109,11 @@
 }
 
 int32_t HWCSession::SetSecondaryDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status) {
-  SCOPE_LOCK(locker_);
-
   if (disp_id < 0) {
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
   DLOGI("Display = %d, Status = %d", disp_id, status);
 
   if (disp_id == HWC_DISPLAY_PRIMARY) {
@@ -135,8 +134,7 @@
 
 Return<int32_t> HWCSession::configureDynRefeshRate(IDisplayConfig::DisplayDynRefreshRateOp op,
                                                    uint32_t refreshRate) {
-  SCOPE_LOCK(locker_);
-
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
   HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
 
   switch (op) {
@@ -158,9 +156,13 @@
 }
 
 int32_t HWCSession::GetConfigCount(int disp_id, uint32_t *count) {
-  SCOPE_LOCK(locker_);
+  if (disp_id < 0) {
+    return -EINVAL;
+  }
 
-  if (disp_id >= 0 && hwc_display_[disp_id]) {
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
+
+  if (hwc_display_[disp_id]) {
     return hwc_display_[disp_id]->GetDisplayConfigCount(count);
   }
 
@@ -178,9 +180,13 @@
 }
 
 int32_t HWCSession::GetActiveConfigIndex(int disp_id, uint32_t *config) {
-  SCOPE_LOCK(locker_);
+  if (disp_id < 0) {
+    return -EINVAL;
+  }
 
-  if (disp_id >= 0 && hwc_display_[disp_id]) {
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
+
+  if (hwc_display_[disp_id]) {
     return hwc_display_[disp_id]->GetActiveDisplayConfig(config);
   }
 
@@ -198,12 +204,11 @@
 }
 
 int32_t HWCSession::SetActiveConfigIndex(int disp_id, uint32_t config) {
-  SCOPE_LOCK(locker_);
-
   if (disp_id < 0) {
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
   int32_t error = -EINVAL;
   if (hwc_display_[disp_id]) {
     error = hwc_display_[disp_id]->SetActiveDisplayConfig(config);
@@ -222,12 +227,11 @@
 Return<void> HWCSession::getDisplayAttributes(uint32_t configIndex,
                                               IDisplayConfig::DisplayType dpy,
                                               getDisplayAttributes_cb _hidl_cb) {
-  SCOPE_LOCK(locker_);
-
   int32_t error = -EINVAL;
   IDisplayConfig::DisplayAttributes display_attributes = {};
-
   int disp_id = MapDisplayType(dpy);
+
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
   if (disp_id >= 0 && hwc_display_[disp_id]) {
     DisplayConfigVariableInfo hwc_display_attributes;
     error = hwc_display_[disp_id]->GetDisplayAttributesForConfig(static_cast<int>(configIndex),
@@ -247,9 +251,9 @@
 }
 
 Return<int32_t> HWCSession::setPanelBrightness(uint32_t level) {
-  SCOPE_LOCK(locker_);
-
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
   int32_t error = -EINVAL;
+
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
     error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPanelBrightness(static_cast<int>(level));
     if (error) {
@@ -261,8 +265,7 @@
 }
 
 int32_t HWCSession::GetPanelBrightness(int *level) {
-  SCOPE_LOCK(locker_);
-
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
   int32_t error = -EINVAL;
 
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -285,14 +288,13 @@
 }
 
 int32_t HWCSession::MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level) {
-  SCOPE_LOCK(locker_);
-
   DLOGI("Display %d", disp_id);
 
   if (disp_id < 0) {
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
   if (disp_id != HWC_DISPLAY_EXTERNAL) {
     DLOGE("Not supported for display");
   } else if (!hwc_display_[disp_id]) {
@@ -310,16 +312,13 @@
 }
 
 Return<int32_t> HWCSession::refreshScreen() {
-  SCOPE_LOCK(locker_);
-
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
   Refresh(HWC_DISPLAY_PRIMARY);
 
   return 0;
 }
 
 int32_t HWCSession::ControlPartialUpdate(int disp_id, bool enable) {
-  SCOPE_LOCK(locker_);
-
   if (disp_id < 0) {
     return -EINVAL;
   }
@@ -329,6 +328,7 @@
     return -EINVAL;
   }
 
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
   HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
   if (!hwc_display) {
     DLOGE("primary display object is not instantiated");
@@ -352,7 +352,7 @@
   Refresh(HWC_DISPLAY_PRIMARY);
 
   // Wait until partial update control is complete
-  int32_t error = locker_.WaitFinite(kPartialUpdateControlTimeoutMs);
+  int32_t error = locker_[disp_id].WaitFinite(kPartialUpdateControlTimeoutMs);
 
   return error;
 }
@@ -362,7 +362,7 @@
 }
 
 Return<int32_t> HWCSession::toggleScreenUpdate(bool on) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   int32_t error = -EINVAL;
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -376,7 +376,7 @@
 }
 
 Return<int32_t> HWCSession::setIdleTimeout(uint32_t value) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
     hwc_display_[HWC_DISPLAY_PRIMARY]->SetIdleTimeoutMs(value);
@@ -388,8 +388,6 @@
 
 Return<void> HWCSession::getHDRCapabilities(IDisplayConfig::DisplayType dpy,
                                             getHDRCapabilities_cb _hidl_cb) {
-  SCOPE_LOCK(locker_);
-
   int32_t error = -EINVAL;
   IDisplayConfig::DisplayHDRCapabilities hdr_caps = {};
 
@@ -400,6 +398,7 @@
       break;
     }
 
+    SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
     HWCDisplay *hwc_display = hwc_display_[disp_id];
     if (!hwc_display) {
       DLOGE("Display = %d is not connected.", disp_id);
@@ -438,7 +437,7 @@
 }
 
 Return<int32_t> HWCSession::setCameraLaunchStatus(uint32_t on) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   HWBwModes mode = on > 0 ? kBwCamera : kBwDefault;
 
@@ -457,7 +456,7 @@
 }
 
 int32_t HWCSession::DisplayBWTransactionPending(bool *status) {
-  SCOPE_LOCK(locker_);
+  SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
 
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
     if (sync_wait(bw_mode_release_fd_, 0) < 0) {