Merge remote-tracking branch 'goog/qcom/release/LA.UM.7.3.9.00015.1'

Change-Id: Ice339993884b778548cf4e97027fd58fe5c8ef52

9 files changed, 197 insertions, 35 deletions

diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index 1e948a2a..b07c8a6a 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -155,7 +155,7 @@ DisplayError DisplayBase::BuildLayerStackStats(LayerStack *layer_stack) {
     hw_layers_info.app_layer_count++;
   }
 
-  DLOGV_IF(kTagNone, "LayerStack layer_count: %d, app_layer_count: %d, gpu_target_index: %d, "
+  DLOGD_IF(kTagNone, "LayerStack layer_count: %d, app_layer_count: %d, gpu_target_index: %d, "
            "display type: %d", layers.size(), hw_layers_info.app_layer_count,
            hw_layers_info.gpu_target_index, display_type_);
 
@@ -223,6 +223,7 @@ DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
     return kErrorParameters;
   }
 
+  DLOGI_IF(kTagDisplay, "Entering Prepare for display type : %d", display_type_);
   error = BuildLayerStackStats(layer_stack);
   if (error != kErrorNone) {
     return error;
@@ -275,6 +276,7 @@ DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
     DLOGW("ValidateHDR failed");
   }
 
+  DLOGI_IF(kTagDisplay, "Exiting Prepare for display type : %d", display_type_);
   return error;
 }
 
@@ -309,6 +311,7 @@ DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
     }
   }
 
+  DLOGI_IF(kTagDisplay, "Entering commit for display type : %d", display_type_);
   CommitLayerParams(layer_stack);
 
   error = comp_manager_->Commit(display_comp_ctx_, &hw_layers_);
@@ -340,6 +343,7 @@ DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
     return error;
   }
 
+  DLOGI_IF(kTagDisplay, "Exiting commit for display type : %d", display_type_);
   return kErrorNone;
 }
 
@@ -400,6 +404,8 @@ DisplayError DisplayBase::GetConfig(DisplayConfigFixedInfo *fixed_info) {
   fixed_info->max_luminance = fixed_info->hdr_supported ? hw_panel_info_.peak_luminance: 0;
   fixed_info->average_luminance = fixed_info->hdr_supported ? hw_panel_info_.average_luminance : 0;
   fixed_info->min_luminance = fixed_info->hdr_supported ?  hw_panel_info_.blackness_level: 0;
+  fixed_info->hdr_eotf = hw_panel_info_.hdr_eotf;
+  fixed_info->hdr_metadata_type_one = hw_panel_info_.hdr_metadata_type_one;
 
   return kErrorNone;
 }
@@ -1117,6 +1123,7 @@ DisplayError DisplayBase::ReconfigureMixer(uint32_t width, uint32_t height) {
     return kErrorParameters;
   }
 
+  DLOGD_IF(kTagQDCM, "Reconfiguring mixer with width : %d, height : %d", width, height);
   HWMixerAttributes mixer_attributes;
   mixer_attributes.width = width;
   mixer_attributes.height = height;
@@ -1169,9 +1176,10 @@ bool DisplayBase::NeedsMixerReconfiguration(LayerStack *layer_stack, uint32_t *n
   uint32_t align_y = 2;
 
   if (req_mixer_width_ && req_mixer_height_) {
+    DLOGD_IF(kTagDisplay, "Required mixer width : %d, height : %d",
+             req_mixer_width_, req_mixer_height_);
     *new_mixer_width = req_mixer_width_;
     *new_mixer_height = req_mixer_height_;
-
     return (req_mixer_width_ != mixer_width || req_mixer_height_ != mixer_height);
   }
 
@@ -1187,6 +1195,7 @@ bool DisplayBase::NeedsMixerReconfiguration(LayerStack *layer_stack, uint32_t *n
       max_area_layer_index = i;
     }
   }
+  DLOGV_IF(kTagDisplay, "Max area layer at index : %d", max_area_layer_index);
 
   // TODO(user): Mark layer which needs downscaling on GPU fallback as priority layer and use MDP
   // for composition to avoid quality mismatch between GPU and MDP switch(idle timeout usecase).
diff --git a/sdm/libs/core/drm/hw_device_drm.cpp b/sdm/libs/core/drm/hw_device_drm.cpp
index e129a7d9..c2beb7a8 100644
--- a/sdm/libs/core/drm/hw_device_drm.cpp
+++ b/sdm/libs/core/drm/hw_device_drm.cpp
@@ -192,6 +192,7 @@ static void GetDRMFormat(LayerBufferFormat format, uint32_t *drm_format,
       *drm_format = DRM_FORMAT_NV21;
       break;
     case kFormatYCbCr420P010:
+    case kFormatYCbCr420P010Venus:
       *drm_format = DRM_FORMAT_NV12;
       *drm_format_modifier = DRM_FORMAT_MOD_QCOM_DX;
       break;
diff --git a/sdm/libs/core/drm/hw_device_drm.h b/sdm/libs/core/drm/hw_device_drm.h
index 16355c86..5b7576ab 100644
--- a/sdm/libs/core/drm/hw_device_drm.h
+++ b/sdm/libs/core/drm/hw_device_drm.h
@@ -97,6 +97,7 @@ class HWDeviceDRM : public HWInterface {
   virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes);
   virtual void InitializeConfigs();
   virtual DisplayError DumpDebugData() { return kErrorNone; }
+  virtual void PopulateHWPanelInfo();
 
   enum {
     kHWEventVSync,
@@ -113,7 +114,6 @@ class HWDeviceDRM : public HWInterface {
   DisplayError SetStride(HWDeviceType device_type, LayerBufferFormat format, uint32_t width,
                          uint32_t *target);
   DisplayError PopulateDisplayAttributes(uint32_t index);
-  void PopulateHWPanelInfo();
   void GetHWDisplayPortAndMode();
   void GetHWPanelMaxBrightness();
   bool EnableHotPlugDetection(int enable);
diff --git a/sdm/libs/core/drm/hw_info_drm.cpp b/sdm/libs/core/drm/hw_info_drm.cpp
index 55bc003b..269cc16a 100644
--- a/sdm/libs/core/drm/hw_info_drm.cpp
+++ b/sdm/libs/core/drm/hw_info_drm.cpp
@@ -85,17 +85,18 @@ namespace sdm {
 
 class DRMLoggerImpl : public DRMLogger {
  public:
-#define PRINTLOG(method, format, buf)        \
+#define PRINTLOG(tag, method, format, buf)        \
   va_list list;                              \
   va_start(list, format);                    \
   vsnprintf(buf, sizeof(buf), format, list); \
   va_end(list);                              \
-  Debug::Get()->method(kTagNone, "%s", buf);
+  Debug::Get()->method(tag, "%s", buf);
 
-  void Error(const char *format, ...) { PRINTLOG(Error, format, buf_); }
-  void Warning(const char *format, ...) { PRINTLOG(Warning, format, buf_); }
-  void Info(const char *format, ...) { PRINTLOG(Info, format, buf_); }
-  void Debug(const char *format, ...) { PRINTLOG(Debug, format, buf_); }
+  void Error(const char *format, ...) { PRINTLOG(kTagNone, Error, format, buf_); }
+  void Warning(const char *format, ...) { PRINTLOG(kTagDriverConfig, Warning, format, buf_); }
+  void Info(const char *format, ...) { PRINTLOG(kTagDriverConfig, Info, format, buf_); }
+  void Debug(const char *format, ...) { PRINTLOG(kTagDriverConfig, Debug, format, buf_); }
+  void Verbose(const char *format, ...) { PRINTLOG(kTagDriverConfig, Verbose, format, buf_); }
 
  private:
   char buf_[1024] = {};
@@ -191,7 +192,6 @@ DisplayError HWInfoDRM::GetHWResourceInfo(HWResourceInfo *hw_resource) {
   hw_resource->has_dyn_bw_support = false;
   hw_resource->has_qseed3 = false;
   hw_resource->has_concurrent_writeback = false;
-  hw_resource->has_hdr = true;
 
   hw_resource->hw_version = SDEVERSION(4, 0, 1);
   // TODO(user): On FB driver hw_revision comprises of major version, minor version and hw_revision.
@@ -278,6 +278,7 @@ DisplayError HWInfoDRM::GetHWResourceInfo(HWResourceInfo *hw_resource) {
 void HWInfoDRM::GetSystemInfo(HWResourceInfo *hw_resource) {
   DRMCrtcInfo info;
   drm_mgr_intf_->GetCrtcInfo(0 /* system_info */, &info);
+  hw_resource->has_hdr = info.has_hdr;
   hw_resource->is_src_split = info.has_src_split;
   hw_resource->has_qseed3 = (info.qseed_version == sde_drm::QSEEDVersion::V3);
   hw_resource->num_blending_stages = info.max_blend_stages;
@@ -322,6 +323,7 @@ void HWInfoDRM::GetSystemInfo(HWResourceInfo *hw_resource) {
   hw_resource->hw_dest_scalar_info.max_scale_up = info.max_dest_scale_up;
   hw_resource->hw_dest_scalar_info.max_input_width = info.max_dest_scaler_input_width;
   hw_resource->hw_dest_scalar_info.max_output_width = info.max_dest_scaler_output_width;
+  hw_resource->min_prefill_lines = info.min_prefill_lines;
 }
 
 void HWInfoDRM::GetHWPlanesInfo(HWResourceInfo *hw_resource) {
@@ -491,8 +493,9 @@ void HWInfoDRM::GetSDMFormat(uint32_t v4l2_format, LayerBufferFormat *sdm_format
     case SDE_PIX_FMT_RGBA_1010102_UBWC: *sdm_format = kFormatRGBA1010102Ubwc;          break;
     case SDE_PIX_FMT_RGBX_1010102_UBWC: *sdm_format = kFormatRGBX1010102Ubwc;          break;
     case SDE_PIX_FMT_Y_CBCR_H2V2_P010:  *sdm_format = kFormatYCbCr420P010;             break;
-    case SDE_PIX_FMT_Y_CBCR_H2V2_TP10_UBWC: *sdm_format = kFormatYCbCr420TP10Ubwc;     break;
-    case SDE_PIX_FMT_Y_CBCR_H2V2_P010_UBWC: *sdm_format = kFormatYCbCr420P010Ubwc;     break;
+    case SDE_PIX_FMT_Y_CBCR_H2V2_TP10_UBWC:  *sdm_format = kFormatYCbCr420TP10Ubwc;     break;
+    case SDE_PIX_FMT_Y_CBCR_H2V2_P010_UBWC:  *sdm_format = kFormatYCbCr420P010Ubwc;     break;
+    case SDE_PIX_FMT_Y_CBCR_H2V2_P010_VENUS: *sdm_format = kFormatYCbCr420P010Venus;    break;
     default: *sdm_format = kFormatInvalid;
   }
 }
@@ -661,7 +664,8 @@ void HWInfoDRM::GetSDMFormat(uint32_t drm_format, uint64_t drm_format_modifier,
       } else if (drm_format_modifier == DRM_FORMAT_MOD_QCOM_COMPRESSED) {
          fmts.push_back(kFormatYCbCr420SPVenusUbwc);
       } else if (drm_format_modifier == DRM_FORMAT_MOD_QCOM_DX) {
-         fmts.push_back(kFormatYCbCr420P010);
+        fmts.push_back(kFormatYCbCr420P010);
+        fmts.push_back(kFormatYCbCr420P010Venus);
       } else {
          fmts.push_back(kFormatYCbCr420SemiPlanarVenus);
          fmts.push_back(kFormatYCbCr420SemiPlanar);
diff --git a/sdm/libs/core/drm/hw_tv_drm.cpp b/sdm/libs/core/drm/hw_tv_drm.cpp
index 565652ef..f1d0d80b 100644
--- a/sdm/libs/core/drm/hw_tv_drm.cpp
+++ b/sdm/libs/core/drm/hw_tv_drm.cpp
@@ -28,6 +28,7 @@
 */
 
 #include "hw_tv_drm.h"
+#include <sys/time.h>
 #include <utils/debug.h>
 #include <utils/sys.h>
 #include <utils/formats.h>
@@ -41,9 +42,19 @@
 #include <map>
 #include <utility>
 
+#ifndef HDR_EOTF_SMTPE_ST2084
+#define HDR_EOTF_SMTPE_ST2084 2
+#endif
+#ifndef HDR_EOTF_HLG
+#define HDR_EOTF_HLG 3
+#endif
 
 #define __CLASS__ "HWTVDRM"
 
+#define HDR_DISABLE 0
+#define HDR_ENABLE 1
+#define MIN_HDR_RESET_WAITTIME 2
+
 using drm_utils::DRMMaster;
 using drm_utils::DRMResMgr;
 using drm_utils::DRMLibLoader;
@@ -60,6 +71,23 @@ using sde_drm::DRMPowerMode;
 
 namespace sdm {
 
+static int32_t GetEOTF(const GammaTransfer &transfer) {
+  int32_t hdr_transfer = -1;
+
+  switch (transfer) {
+  case Transfer_SMPTE_ST2084:
+    hdr_transfer = HDR_EOTF_SMTPE_ST2084;
+    break;
+  case Transfer_HLG:
+    hdr_transfer = HDR_EOTF_HLG;
+    break;
+  default:
+    DLOGW("Unknown Transfer: %d", transfer);
+  }
+
+  return hdr_transfer;
+}
+
 HWTVDRM::HWTVDRM(BufferSyncHandler *buffer_sync_handler, BufferAllocator *buffer_allocator,
                      HWInfoInterface *hw_info_intf)
   : HWDeviceDRM(buffer_sync_handler, buffer_allocator, hw_info_intf) {
@@ -148,5 +176,119 @@ DisplayError HWTVDRM::Standby() {
   return kErrorNone;
 }
 
+void HWTVDRM::PopulateHWPanelInfo() {
+  hw_panel_info_ = {};
+
+  HWDeviceDRM::PopulateHWPanelInfo();
+  hw_panel_info_.hdr_enabled = connector_info_.ext_hdr_prop.hdr_supported;
+  hw_panel_info_.hdr_metadata_type_one = connector_info_.ext_hdr_prop.hdr_metadata_type_one;
+  hw_panel_info_.hdr_eotf = connector_info_.ext_hdr_prop.hdr_eotf;
+  hw_panel_info_.peak_luminance = connector_info_.ext_hdr_prop.hdr_max_luminance;
+  hw_panel_info_.average_luminance = connector_info_.ext_hdr_prop.hdr_avg_luminance;
+  hw_panel_info_.blackness_level = connector_info_.ext_hdr_prop.hdr_min_luminance;
+  DLOGI("TV Panel: %s, type_one = %d, eotf = %d, luminance[max = %d, min = %d, avg = %d]",
+        hw_panel_info_.hdr_enabled ? "HDR" : "Non-HDR", hw_panel_info_.hdr_metadata_type_one,
+        hw_panel_info_.hdr_eotf, hw_panel_info_.peak_luminance, hw_panel_info_.blackness_level,
+        hw_panel_info_.average_luminance);
+}
+
+DisplayError HWTVDRM::Commit(HWLayers *hw_layers) {
+  DisplayError error = UpdateHDRMetaData(hw_layers);
+  if (error != kErrorNone) {
+    return error;
+  }
+  return HWDeviceDRM::Commit(hw_layers);
+}
+
+DisplayError HWTVDRM::UpdateHDRMetaData(HWLayers *hw_layers) {
+  static struct timeval hdr_reset_start, hdr_reset_end;
+  static bool reset_hdr_flag = false;
+  const HWHDRLayerInfo &hdr_layer_info = hw_layers->info.hdr_layer_info;
+  if (!hw_panel_info_.hdr_enabled) {
+    return kErrorNone;
+  }
+
+  DisplayError error = kErrorNone;
+
+  Layer hdr_layer = {};
+  if (hdr_layer_info.operation == HWHDRLayerInfo::kSet && hdr_layer_info.layer_index > -1) {
+    hdr_layer = *(hw_layers->info.stack->layers.at(UINT32(hdr_layer_info.layer_index)));
+  }
+
+  const LayerBuffer *layer_buffer = &hdr_layer.input_buffer;
+  const MasteringDisplay &mastering_display = layer_buffer->color_metadata.masteringDisplayInfo;
+  const ContentLightLevel &light_level = layer_buffer->color_metadata.contentLightLevel;
+  const Primaries &primaries = mastering_display.primaries;
+
+  if (hdr_layer_info.operation == HWHDRLayerInfo::kSet) {
+    // Reset reset_hdr_flag to handle where there are two consecutive HDR video playbacks with not
+    // enough non-HDR frames in between to reset the HDR metadata.
+    reset_hdr_flag = false;
+
+    int32_t eotf = GetEOTF(layer_buffer->color_metadata.transfer);
+    hdr_metadata_.hdr_supported = 1;
+    hdr_metadata_.hdr_state = HDR_ENABLE;
+    hdr_metadata_.eotf = (eotf < 0) ? 0 : UINT32(eotf);
+    hdr_metadata_.white_point_x = primaries.whitePoint[0];
+    hdr_metadata_.white_point_y = primaries.whitePoint[1];
+    hdr_metadata_.display_primaries_x[0] = primaries.rgbPrimaries[0][0];
+    hdr_metadata_.display_primaries_y[0] = primaries.rgbPrimaries[0][1];
+    hdr_metadata_.display_primaries_x[1] = primaries.rgbPrimaries[1][0];
+    hdr_metadata_.display_primaries_y[1] = primaries.rgbPrimaries[1][1];
+    hdr_metadata_.display_primaries_x[2] = primaries.rgbPrimaries[2][0];
+    hdr_metadata_.display_primaries_y[2] = primaries.rgbPrimaries[2][1];
+    hdr_metadata_.min_luminance = mastering_display.minDisplayLuminance;
+    hdr_metadata_.max_luminance = mastering_display.maxDisplayLuminance/10000;
+    hdr_metadata_.max_content_light_level = light_level.maxContentLightLevel;
+    hdr_metadata_.max_average_light_level = light_level.minPicAverageLightLevel;
+
+    drm_atomic_intf_->Perform(DRMOps::CONNECTOR_SET_HDR_METADATA, token_.conn_id, &hdr_metadata_);
+    DumpHDRMetaData(hdr_layer_info.operation);
+  } else if (hdr_layer_info.operation == HWHDRLayerInfo::kReset) {
+    memset(&hdr_metadata_, 0, sizeof(hdr_metadata_));
+    hdr_metadata_.hdr_supported = 1;
+    hdr_metadata_.hdr_state = HDR_ENABLE;
+    reset_hdr_flag = true;
+    gettimeofday(&hdr_reset_start, NULL);
+
+    drm_atomic_intf_->Perform(DRMOps::CONNECTOR_SET_HDR_METADATA, token_.conn_id, &hdr_metadata_);
+    DumpHDRMetaData(hdr_layer_info.operation);
+  } else if (hdr_layer_info.operation == HWHDRLayerInfo::kNoOp) {
+    // TODO(user): This case handles the state transition from HDR_ENABLED to HDR_DISABLED.
+    // As per HDMI spec requirement, we need to send zero metadata for atleast 2 sec after end of
+    // playback. This timer calculates the 2 sec window after playback stops to stop sending HDR
+    // metadata. This will be replaced with an idle timer implementation in the future.
+    if (reset_hdr_flag) {
+      gettimeofday(&hdr_reset_end, NULL);
+      float hdr_reset_time_start = ((hdr_reset_start.tv_sec*1000) + (hdr_reset_start.tv_usec/1000));
+      float hdr_reset_time_end = ((hdr_reset_end.tv_sec*1000) + (hdr_reset_end.tv_usec/1000));
+
+      if (((hdr_reset_time_end-hdr_reset_time_start)/1000) >= MIN_HDR_RESET_WAITTIME) {
+        memset(&hdr_metadata_, 0, sizeof(hdr_metadata_));
+        hdr_metadata_.hdr_supported = 1;
+        hdr_metadata_.hdr_state = HDR_DISABLE;
+        reset_hdr_flag = false;
+
+        drm_atomic_intf_->Perform(DRMOps::CONNECTOR_SET_HDR_METADATA, token_.conn_id,
+                                  &hdr_metadata_);
+      }
+    }
+  }
+
+  return error;
+}
+
+void HWTVDRM::DumpHDRMetaData(HWHDRLayerInfo::HDROperation operation) {
+  DLOGI("Operation = %d, HDR Metadata: MaxDisplayLuminance = %d MinDisplayLuminance = %d\n"
+        "MaxContentLightLevel = %d MaxAverageLightLevel = %d Red_x = %d Red_y = %d Green_x = %d\n"
+        "Green_y = %d Blue_x = %d Blue_y = %d WhitePoint_x = %d WhitePoint_y = %d EOTF = %d\n",
+        operation, hdr_metadata_.max_luminance, hdr_metadata_.min_luminance,
+        hdr_metadata_.max_content_light_level, hdr_metadata_.max_average_light_level,
+        hdr_metadata_.display_primaries_x[0], hdr_metadata_.display_primaries_y[0],
+        hdr_metadata_.display_primaries_x[1], hdr_metadata_.display_primaries_y[1],
+        hdr_metadata_.display_primaries_x[2], hdr_metadata_.display_primaries_y[2],
+        hdr_metadata_.white_point_x, hdr_metadata_.white_point_y, hdr_metadata_.eotf);
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/drm/hw_tv_drm.h b/sdm/libs/core/drm/hw_tv_drm.h
index 54ce3274..5661bc27 100644
--- a/sdm/libs/core/drm/hw_tv_drm.h
+++ b/sdm/libs/core/drm/hw_tv_drm.h
@@ -46,10 +46,16 @@ class HWTVDRM : public HWDeviceDRM {
   virtual DisplayError Doze();
   virtual DisplayError DozeSuspend();
   virtual DisplayError Standby();
+  virtual DisplayError Commit(HWLayers *hw_layers);
+  virtual void PopulateHWPanelInfo();
 
  private:
+  DisplayError UpdateHDRMetaData(HWLayers *hw_layers);
+  void DumpHDRMetaData(HWHDRLayerInfo::HDROperation operation);
+
   static const int kBitRGB  = 20;
   static const int kBitYUV  = 21;
+  drm_msm_ext_hdr_metadata hdr_metadata_ = {};
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/core/fb/hw_device.cpp b/sdm/libs/core/fb/hw_device.cpp
index cac14548..38e57d85 100644
--- a/sdm/libs/core/fb/hw_device.cpp
+++ b/sdm/libs/core/fb/hw_device.cpp
@@ -190,9 +190,9 @@ DisplayError HWDevice::Validate(HWLayers *hw_layers) {
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t hw_layer_count = UINT32(hw_layer_info.hw_layers.size());
 
-  DLOGV_IF(kTagDriverConfig, "************************** %s Validate Input ***********************",
+  DLOGD_IF(kTagDriverConfig, "************************** %s Validate Input ***********************",
            device_name_);
-  DLOGV_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_count);
+  DLOGD_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_count);
 
   mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
   uint32_t &mdp_layer_count = mdp_commit.input_layer_cnt;
@@ -267,11 +267,11 @@ DisplayError HWDevice::Validate(HWLayers *hw_layers) {
 
         mdp_layer_count++;
 
-        DLOGV_IF(kTagDriverConfig, "******************* Layer[%d] %s pipe Input ******************",
+        DLOGD_IF(kTagDriverConfig, "******************* Layer[%d] %s pipe Input ******************",
                  i, count ? "Right" : "Left");
-        DLOGV_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d", mdp_buffer.width, mdp_buffer.height,
+        DLOGD_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d", mdp_buffer.width, mdp_buffer.height,
                  mdp_buffer.format);
-        DLOGV_IF(kTagDriverConfig, "plane_alpha %d, zorder %d, blending %d, horz_deci %d, "
+        DLOGD_IF(kTagDriverConfig, "plane_alpha %d, zorder %d, blending %d, horz_deci %d, "
                  "vert_deci %d, pipe_id = 0x%x, mdp_flags 0x%x", mdp_layer.alpha, mdp_layer.z_order,
                  mdp_layer.blend_op, mdp_layer.horz_deci, mdp_layer.vert_deci, mdp_layer.pipe_ndx,
                  mdp_layer.flags);
@@ -280,7 +280,7 @@ DisplayError HWDevice::Validate(HWLayers *hw_layers) {
         DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_layer.dst_rect.x,
                  mdp_layer.dst_rect.y, mdp_layer.dst_rect.w, mdp_layer.dst_rect.h);
         hw_scale_->DumpScaleData(mdp_layer.scale);
-        DLOGV_IF(kTagDriverConfig, "*************************************************************");
+        DLOGD_IF(kTagDriverConfig, "*************************************************************");
       }
     }
   }
@@ -338,16 +338,16 @@ DisplayError HWDevice::Validate(HWLayers *hw_layers) {
 
     index++;
 
-    DLOGV_IF(kTagDriverConfig, "************************ DestScalar[%d] **************************",
+    DLOGD_IF(kTagDriverConfig, "************************ DestScalar[%d] **************************",
              dest_scalar_data->dest_scaler_ndx);
-    DLOGV_IF(kTagDriverConfig, "Mixer WxH %dx%d flags %x", dest_scalar_data->lm_width,
+    DLOGD_IF(kTagDriverConfig, "Mixer WxH %dx%d flags %x", dest_scalar_data->lm_width,
              dest_scalar_data->lm_height, dest_scalar_data->flags);
 #ifdef MDP_DESTSCALER_ROI_ENABLE
-    DLOGV_IF(kTagDriverConfig, "Panel ROI [%d, %d, %d, %d]", dest_scalar_data->panel_roi.x,
+    DLOGD_IF(kTagDriverConfig, "Panel ROI [%d, %d, %d, %d]", dest_scalar_data->panel_roi.x,
              dest_scalar_data->panel_roi.y, dest_scalar_data->panel_roi.w,
              dest_scalar_data->panel_roi.h);
 #endif
-    DLOGV_IF(kTagDriverConfig, "*****************************************************************");
+    DLOGD_IF(kTagDriverConfig, "*****************************************************************");
   }
   mdp_commit.dest_scaler_cnt = UINT32(hw_layer_info.dest_scale_info_map.size());
 
@@ -411,9 +411,9 @@ DisplayError HWDevice::Commit(HWLayers *hw_layers) {
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t hw_layer_count = UINT32(hw_layer_info.hw_layers.size());
 
-  DLOGV_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
+  DLOGD_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
            device_name_);
-  DLOGV_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_count);
+  DLOGD_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_count);
 
   mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
   uint32_t mdp_layer_index = 0;
@@ -449,16 +449,16 @@ DisplayError HWDevice::Commit(HWLayers *hw_layers) {
         mdp_buffer.fence = input_buffer->acquire_fence_fd;
         mdp_layer_index++;
 
-        DLOGV_IF(kTagDriverConfig, "****************** Layer[%d] %s pipe Input *******************",
+        DLOGD_IF(kTagDriverConfig, "****************** Layer[%d] %s pipe Input *******************",
                  i, count ? "Right" : "Left");
-        DLOGI_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d, horz_deci %d, vert_deci %d",
+        DLOGD_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d, horz_deci %d, vert_deci %d",
                  mdp_buffer.width, mdp_buffer.height, mdp_buffer.format, mdp_layer.horz_deci,
                  mdp_layer.vert_deci);
-        DLOGI_IF(kTagDriverConfig, "in_buf_fd %d, in_buf_offset %d, in_buf_stride %d, " \
+        DLOGV_IF(kTagDriverConfig, "in_buf_fd %d, in_buf_offset %d, in_buf_stride %d, " \
                  "in_plane_count %d, in_fence %d, layer count %d", mdp_buffer.planes[0].fd,
                  mdp_buffer.planes[0].offset, mdp_buffer.planes[0].stride, mdp_buffer.plane_count,
                  mdp_buffer.fence, mdp_commit.input_layer_cnt);
-        DLOGV_IF(kTagDriverConfig, "*************************************************************");
+        DLOGD_IF(kTagDriverConfig, "*************************************************************");
       }
     }
   }
diff --git a/sdm/libs/core/fb/hw_hdmi.cpp b/sdm/libs/core/fb/hw_hdmi.cpp
index e1d7ba12..e339908e 100644
--- a/sdm/libs/core/fb/hw_hdmi.cpp
+++ b/sdm/libs/core/fb/hw_hdmi.cpp
@@ -1059,7 +1059,7 @@ DisplayError HWHDMI::UpdateHDRMetaData(HWLayers *hw_layers) {
                            (bits_per_component  < 0) ? 0 : UINT32(bits_per_component);
     hdr_ctrl.hdr_stream.content_type = GetContentType(hdr_layer.input_buffer);
 
-    DLOGV_IF(kTagDriverConfig, "kSet: HDR Stream : MaxDisplayLuminance = %d\n"
+    DLOGD_IF(kTagDriverConfig, "kSet: HDR Stream : MaxDisplayLuminance = %d\n"
       "MinDisplayLuminance = %d MaxContentLightLevel = %d MaxAverageLightLevel = %d\n"
       "Red_x = %d Red_y = %d Green_x = %d Green_y = %d Blue_x = %d Blue_y = %d\n"
       "WhitePoint_x = %d WhitePoint_y = %d EOTF = %d PixelEncoding = %d Colorimetry = %d\n"
@@ -1083,7 +1083,7 @@ DisplayError HWHDMI::UpdateHDRMetaData(HWLayers *hw_layers) {
     cdm_color_space_ = (mdp_color_space) MDP_CSC_DEFAULT;
     cdm_color_space_commit_ = true;
 #endif
-    DLOGV_IF(kTagDriverConfig, "kReset: HDR Stream: HDR_RESET");
+    DLOGD_IF(kTagDriverConfig, "kReset: HDR Stream: HDR_RESET");
   } else if (hdr_layer_info.operation == HWHDRLayerInfo::kNoOp) {
      if (reset_hdr_flag_) {
        hdr_reset_end_ = time(NULL);
@@ -1092,7 +1092,7 @@ DisplayError HWHDMI::UpdateHDRMetaData(HWLayers *hw_layers) {
           reset_hdr_flag_ = false;
           memset(&hdr_ctrl.hdr_stream, 0, sizeof(hdr_ctrl.hdr_stream));
           hdr_ctrl.hdr_state = HDR_DISABLE;
-          DLOGV_IF(kTagDriverConfig, "kNoOp: HDR Stream: HDR_DISABLE");
+          DLOGD_IF(kTagDriverConfig, "kNoOp: HDR Stream: HDR_DISABLE");
        } else {
           return kErrorNone;
        }
diff --git a/sdm/libs/core/fb/hw_scale.cpp b/sdm/libs/core/fb/hw_scale.cpp
index e44af5d6..02585704 100644
--- a/sdm/libs/core/fb/hw_scale.cpp
+++ b/sdm/libs/core/fb/hw_scale.cpp
@@ -104,7 +104,7 @@ void HWScaleV1::DumpScaleData(void *mdp_scale) {
 
   mdp_scale_data *scale = reinterpret_cast<mdp_scale_data *>(mdp_scale);
   if (scale->enable_pxl_ext) {
-    DLOGV_IF(kTagDriverConfig, "Scale Enable = %d", scale->enable_pxl_ext);
+    DLOGD_IF(kTagDriverConfig, "Scale Enable = %d", scale->enable_pxl_ext);
     for (int j = 0; j < MAX_PLANES; j++) {
       DLOGV_IF(kTagDriverConfig, "Scale Data[%d] : Phase=[%x %x %x %x] Pixel_Ext=[%d %d %d %d]",
                j, scale->init_phase_x[j], scale->phase_step_x[j], scale->init_phase_y[j],
@@ -273,7 +273,7 @@ void HWScaleV2::DumpScaleData(void *mdp_scale) {
 
   mdp_scale_data_v2 *scale = reinterpret_cast<mdp_scale_data_v2 *>(mdp_scale);
   if (scale->enable) {
-    DLOGV_IF(kTagDriverConfig, "Scale Enable = %d", scale->enable);
+    DLOGD_IF(kTagDriverConfig, "Scale Enable = %d", scale->enable);
     for (int j = 0; j < MAX_PLANES; j++) {
       DLOGV_IF(kTagDriverConfig, "Scale Data[%d]: Phase_init[x y]=[%x %x] Phase_step:[x y]=[%x %x]",
         j, scale->init_phase_x[j], scale->init_phase_y[j], scale->phase_step_x[j],
@@ -287,7 +287,7 @@ void HWScaleV2::DumpScaleData(void *mdp_scale) {
         scale->src_width[j], scale->src_height[j], scale->roi_w[j]);
     }
 
-    DLOGV_IF(kTagDriverConfig, "LUT flags = %d", scale->lut_flag);
+    DLOGD_IF(kTagDriverConfig, "LUT flags = %d", scale->lut_flag);
     DLOGV_IF(kTagDriverConfig, "y_rgb_filter=%d, uv_filter=%d, alpha_filter=%d, blend_cfg=%d",
       scale->y_rgb_filter_cfg, scale->uv_filter_cfg, scale->alpha_filter_cfg, scale->blend_cfg);
     DLOGV_IF(kTagDriverConfig, "dir_lut=%d, y_rgb_cir=%d, uv_cir=%d, y_rgb_sep=%d, uv_sep=%d",