From: Dave Airlie <[email protected]>

This code isn't used, and this function is huge, reimport later if
going to be used.

Signed-off-by: Dave Airlie <[email protected]>
---
 drivers/gpu/drm/amd/display/dc/dml/Makefile        |    4 +-
 .../gpu/drm/amd/display/dc/dml/display_mode_lib.h  |    1 -
 .../drm/amd/display/dc/dml/display_mode_support.c  | 2327 --------------------
 .../drm/amd/display/dc/dml/display_mode_support.h  |    5 -
 4 files changed, 1 insertion(+), 2336 deletions(-)
 delete mode 100644 drivers/gpu/drm/amd/display/dc/dml/display_mode_support.c

diff --git a/drivers/gpu/drm/amd/display/dc/dml/Makefile 
b/drivers/gpu/drm/amd/display/dc/dml/Makefile
index a6bf364..ec712d7 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/Makefile
+++ b/drivers/gpu/drm/amd/display/dc/dml/Makefile
@@ -10,12 +10,10 @@ CFLAGS_display_rq_dlg_helpers.o := -mhard-float -msse 
-mpreferred-stack-boundary
 CFLAGS_display_watermark.o := -mhard-float -msse -mpreferred-stack-boundary=4
 CFLAGS_soc_bounding_box.o := -mhard-float -msse -mpreferred-stack-boundary=4
 CFLAGS_dml_common_defs.o := -mhard-float -msse -mpreferred-stack-boundary=4
-CFLAGS_display_mode_support.o := -mhard-float -msse 
-mpreferred-stack-boundary=4
-
 
 DML = display_mode_lib.o display_rq_dlg_calc.o \
          display_rq_dlg_helpers.o display_watermark.o \
-         soc_bounding_box.o dml_common_defs.o display_mode_support.o
+         soc_bounding_box.o dml_common_defs.o
 
 AMD_DAL_DML = $(addprefix $(AMDDALPATH)/dc/dml/,$(DML))
 
diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h 
b/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h
index eb1c8e6..e0af28d 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h
+++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_lib.h
@@ -29,7 +29,6 @@
 #include "soc_bounding_box.h"
 #include "display_watermark.h"
 #include "display_rq_dlg_calc.h"
-#include "display_mode_support.h"
 
 enum dml_project {
        DML_PROJECT_UNDEFINED,
diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.c 
b/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.c
deleted file mode 100644
index ac57356..0000000
--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.c
+++ /dev/null
@@ -1,2327 +0,0 @@
-/*
- * Copyright 2017 Advanced Micro Devices, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors: AMD
- *
- */
-
-#include "display_mode_support.h"
-#include "display_mode_lib.h"
-
-#include "dml_inline_defs.h"
-int dml_ms_check(
-               struct display_mode_lib *mode_lib,
-               struct _vcs_dpi_display_e2e_pipe_params_st *e2e,
-               int num_pipes)
-{
-       struct _vcs_dpi_ip_params_st *ip;
-       struct _vcs_dpi_soc_bounding_box_st *soc;
-       struct _vcs_dpi_mode_evaluation_st *me;
-       struct dml_ms_internal_vars *v;
-       int num_planes, i, j, ij, k, ijk;
-
-       ip = &(mode_lib->ip);
-       soc = &(mode_lib->soc);
-       me = &(mode_lib->me);
-       v = &(mode_lib->vars);
-       num_planes = dml_wm_e2e_to_wm(mode_lib, e2e, num_pipes, v->planes);
-
-       //instantiating variables to zero
-       v->MacroTileBlockWidthC = 0;
-       v->SwathWidthGranularityC = 0;
-
-       v->DCFCLKPerState[5] = 0;
-       v->DCFCLKPerState[4] = 0;
-       v->DCFCLKPerState[3] = 0;
-       v->DCFCLKPerState[2] = 0;
-       v->DCFCLKPerState[1] = 0;
-       v->DCFCLKPerState[0] = 0;
-
-       if (soc->vmin.dcfclk_mhz > 0) {
-               v->DCFCLKPerState[5] = soc->vmin.dcfclk_mhz;
-               v->DCFCLKPerState[4] = soc->vmin.dcfclk_mhz;
-               v->DCFCLKPerState[3] = soc->vmin.dcfclk_mhz;
-               v->DCFCLKPerState[2] = soc->vmin.dcfclk_mhz;
-               v->DCFCLKPerState[1] = soc->vmin.dcfclk_mhz;
-               v->DCFCLKPerState[0] = soc->vmin.dcfclk_mhz;
-       }
-
-       if (soc->vmid.dcfclk_mhz > 0) {
-               v->DCFCLKPerState[5] = soc->vmid.dcfclk_mhz;
-               v->DCFCLKPerState[4] = soc->vmid.dcfclk_mhz;
-               v->DCFCLKPerState[3] = soc->vmid.dcfclk_mhz;
-               v->DCFCLKPerState[2] = soc->vmid.dcfclk_mhz;
-               v->DCFCLKPerState[1] = soc->vmid.dcfclk_mhz;
-       }
-
-       if (soc->vnom.dcfclk_mhz > 0) {
-               v->DCFCLKPerState[5] = soc->vnom.dcfclk_mhz;
-               v->DCFCLKPerState[4] = soc->vnom.dcfclk_mhz;
-               v->DCFCLKPerState[3] = soc->vnom.dcfclk_mhz;
-               v->DCFCLKPerState[2] = soc->vnom.dcfclk_mhz;
-       }
-
-       if (soc->vmax.dcfclk_mhz > 0) {
-               v->DCFCLKPerState[5] = soc->vmax.dcfclk_mhz;
-               v->DCFCLKPerState[4] = soc->vmax.dcfclk_mhz;
-               v->DCFCLKPerState[3] = soc->vmax.dcfclk_mhz;
-       }
-
-       v->FabricAndDRAMBandwidthPerState[5] = 0;
-       v->FabricAndDRAMBandwidthPerState[4] = 0;
-       v->FabricAndDRAMBandwidthPerState[3] = 0;
-       v->FabricAndDRAMBandwidthPerState[2] = 0;
-       v->FabricAndDRAMBandwidthPerState[1] = 0;
-       v->FabricAndDRAMBandwidthPerState[0] = 0;
-
-       if (soc->vmin.dram_bw_per_chan_gbps > 0) {
-               v->FabricAndDRAMBandwidthPerState[5] = 
soc->vmin.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[4] = 
soc->vmin.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[3] = 
soc->vmin.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[2] = 
soc->vmin.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[1] = 
soc->vmin.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[0] = 
soc->vmin.dram_bw_per_chan_gbps;
-       }
-
-       if (soc->vmid.dram_bw_per_chan_gbps > 0) {
-               v->FabricAndDRAMBandwidthPerState[5] = 
soc->vmid.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[4] = 
soc->vmid.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[3] = 
soc->vmid.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[2] = 
soc->vmid.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[1] = 
soc->vmid.dram_bw_per_chan_gbps;
-       }
-
-       if (soc->vnom.dram_bw_per_chan_gbps > 0) {
-               v->FabricAndDRAMBandwidthPerState[5] = 
soc->vnom.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[4] = 
soc->vnom.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[3] = 
soc->vnom.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[2] = 
soc->vnom.dram_bw_per_chan_gbps;
-       }
-
-       if (soc->vmax.dram_bw_per_chan_gbps > 0) {
-               v->FabricAndDRAMBandwidthPerState[5] = 
soc->vmax.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[4] = 
soc->vmax.dram_bw_per_chan_gbps;
-               v->FabricAndDRAMBandwidthPerState[3] = 
soc->vmax.dram_bw_per_chan_gbps;
-       }
-
-       v->PHYCLKPerState[5] = 0;
-       v->PHYCLKPerState[4] = 0;
-       v->PHYCLKPerState[3] = 0;
-       v->PHYCLKPerState[2] = 0;
-       v->PHYCLKPerState[1] = 0;
-       v->PHYCLKPerState[0] = 0;
-
-       if (soc->vmin.phyclk_mhz > 0) {
-               v->PHYCLKPerState[5] = soc->vmin.phyclk_mhz;
-               v->PHYCLKPerState[4] = soc->vmin.phyclk_mhz;
-               v->PHYCLKPerState[3] = soc->vmin.phyclk_mhz;
-               v->PHYCLKPerState[2] = soc->vmin.phyclk_mhz;
-               v->PHYCLKPerState[1] = soc->vmin.phyclk_mhz;
-               v->PHYCLKPerState[0] = soc->vmin.phyclk_mhz;
-       }
-
-       if (soc->vmid.phyclk_mhz > 0) {
-               v->PHYCLKPerState[5] = soc->vmid.phyclk_mhz;
-               v->PHYCLKPerState[4] = soc->vmid.phyclk_mhz;
-               v->PHYCLKPerState[3] = soc->vmid.phyclk_mhz;
-               v->PHYCLKPerState[2] = soc->vmid.phyclk_mhz;
-               v->PHYCLKPerState[1] = soc->vmid.phyclk_mhz;
-       }
-
-       if (soc->vnom.phyclk_mhz > 0) {
-               v->PHYCLKPerState[5] = soc->vnom.phyclk_mhz;
-               v->PHYCLKPerState[4] = soc->vnom.phyclk_mhz;
-               v->PHYCLKPerState[3] = soc->vnom.phyclk_mhz;
-               v->PHYCLKPerState[2] = soc->vnom.phyclk_mhz;
-       }
-
-       if (soc->vmax.phyclk_mhz > 0) {
-               v->PHYCLKPerState[5] = soc->vmax.phyclk_mhz;
-               v->PHYCLKPerState[4] = soc->vmax.phyclk_mhz;
-               v->PHYCLKPerState[3] = soc->vmax.phyclk_mhz;
-       }
-
-       v->MaxDispclk[5] = 0;
-       v->MaxDispclk[4] = 0;
-       v->MaxDispclk[3] = 0;
-       v->MaxDispclk[2] = 0;
-       v->MaxDispclk[1] = 0;
-       v->MaxDispclk[0] = 0;
-
-       if (soc->vmin.dispclk_mhz > 0) {
-               v->MaxDispclk[5] = soc->vmin.dispclk_mhz;
-               v->MaxDispclk[4] = soc->vmin.dispclk_mhz;
-               v->MaxDispclk[3] = soc->vmin.dispclk_mhz;
-               v->MaxDispclk[2] = soc->vmin.dispclk_mhz;
-               v->MaxDispclk[1] = soc->vmin.dispclk_mhz;
-               v->MaxDispclk[0] = soc->vmin.dispclk_mhz;
-       }
-
-       if (soc->vmid.dispclk_mhz > 0) {
-               v->MaxDispclk[5] = soc->vmid.dispclk_mhz;
-               v->MaxDispclk[4] = soc->vmid.dispclk_mhz;
-               v->MaxDispclk[3] = soc->vmid.dispclk_mhz;
-               v->MaxDispclk[2] = soc->vmid.dispclk_mhz;
-               v->MaxDispclk[1] = soc->vmid.dispclk_mhz;
-       }
-
-       if (soc->vnom.dispclk_mhz > 0) {
-               v->MaxDispclk[5] = soc->vnom.dispclk_mhz;
-               v->MaxDispclk[4] = soc->vnom.dispclk_mhz;
-               v->MaxDispclk[3] = soc->vnom.dispclk_mhz;
-               v->MaxDispclk[2] = soc->vnom.dispclk_mhz;
-       }
-
-       if (soc->vmax.dispclk_mhz > 0) {
-               v->MaxDispclk[5] = soc->vmax.dispclk_mhz;
-               v->MaxDispclk[4] = soc->vmax.dispclk_mhz;
-               v->MaxDispclk[3] = soc->vmax.dispclk_mhz;
-       }
-
-       v->MaxDppclk[5] = 0;
-       v->MaxDppclk[4] = 0;
-       v->MaxDppclk[3] = 0;
-       v->MaxDppclk[2] = 0;
-       v->MaxDppclk[1] = 0;
-       v->MaxDppclk[0] = 0;
-
-       if (soc->vmin.dppclk_mhz > 0) {
-               v->MaxDppclk[5] = soc->vmin.dppclk_mhz;
-               v->MaxDppclk[4] = soc->vmin.dppclk_mhz;
-               v->MaxDppclk[3] = soc->vmin.dppclk_mhz;
-               v->MaxDppclk[2] = soc->vmin.dppclk_mhz;
-               v->MaxDppclk[1] = soc->vmin.dppclk_mhz;
-               v->MaxDppclk[0] = soc->vmin.dppclk_mhz;
-       }
-
-       if (soc->vmid.dppclk_mhz > 0) {
-               v->MaxDppclk[5] = soc->vmid.dppclk_mhz;
-               v->MaxDppclk[4] = soc->vmid.dppclk_mhz;
-               v->MaxDppclk[3] = soc->vmid.dppclk_mhz;
-               v->MaxDppclk[2] = soc->vmid.dppclk_mhz;
-               v->MaxDppclk[1] = soc->vmid.dppclk_mhz;
-       }
-
-       if (soc->vnom.dppclk_mhz > 0) {
-               v->MaxDppclk[5] = soc->vnom.dppclk_mhz;
-               v->MaxDppclk[4] = soc->vnom.dppclk_mhz;
-               v->MaxDppclk[3] = soc->vnom.dppclk_mhz;
-               v->MaxDppclk[2] = soc->vnom.dppclk_mhz;
-       }
-
-       if (soc->vmax.dppclk_mhz > 0) {
-               v->MaxDppclk[5] = soc->vmax.dppclk_mhz;
-               v->MaxDppclk[4] = soc->vmax.dppclk_mhz;
-               v->MaxDppclk[3] = soc->vmax.dppclk_mhz;
-       }
-
-       if (me->voltage_override == dm_vmax) {
-               v->VoltageOverrideLevel = NumberOfStates - 1;
-       } else if (me->voltage_override == dm_vnom) {
-               v->VoltageOverrideLevel = NumberOfStates - 2;
-       } else if (me->voltage_override == dm_vmid) {
-               v->VoltageOverrideLevel = NumberOfStates - 3;
-       } else {
-               v->VoltageOverrideLevel = 0;
-       }
-
-       // Scale Ratio Support Check
-
-       v->ScaleRatioSupport = 1;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_scaler_ratio_depth_st scale_ratio_depth =
-                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-               struct _vcs_dpi_scaler_taps_st scale_taps =
-                               e2e[v->planes[k].e2e_index].pipe.scale_taps;
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-
-               if (scale_ratio_depth.hscl_ratio > ip->max_hscl_ratio
-                               || scale_ratio_depth.vscl_ratio > 
ip->max_vscl_ratio
-                               || scale_ratio_depth.hscl_ratio > 
scale_taps.htaps
-                               || scale_ratio_depth.vscl_ratio > 
scale_taps.vtaps
-                               || (src.source_format != dm_444_64 && 
src.source_format != dm_444_32
-                                               && src.source_format != 
dm_444_16
-                                               && 
((scale_ratio_depth.hscl_ratio / 2
-                                                               > 
scale_taps.htaps_c)
-                                                               || 
(scale_ratio_depth.vscl_ratio / 2
-                                                                               
> scale_taps.vtaps_c))))
-
-                               {
-                       v->ScaleRatioSupport = 0;
-               }
-       }
-
-       // Source Format, Pixel Format and Scan Support Check
-
-       v->SourceFormatPixelAndScanSupport = 1;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-
-               if ((src.sw_mode == dm_sw_linear && src.source_scan != dm_horz)
-                               || ((src.sw_mode == dm_sw_4kb_d || src.sw_mode 
== dm_sw_4kb_d_x
-                                               || src.sw_mode == dm_sw_64kb_d
-                                               || src.sw_mode == dm_sw_64kb_d_t
-                                               || src.sw_mode == dm_sw_64kb_d_x
-                                               || src.sw_mode == dm_sw_var_d
-                                               || src.sw_mode == dm_sw_var_d_x)
-                                               && (src.source_format != 
dm_444_64))) {
-                       v->SourceFormatPixelAndScanSupport = 0;
-               }
-       }
-
-       // Bandwidth Support Check
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-
-               if (src.source_scan == dm_horz) {
-                       v->SwathWidthYSingleDPP[k] = src.viewport_width;
-               } else {
-                       v->SwathWidthYSingleDPP[k] = src.viewport_height;
-               }
-
-               if (src.source_format == dm_444_64) {
-                       v->BytePerPixelInDETY[k] = 8;
-                       v->BytePerPixelInDETC[k] = 0;
-               } else if (src.source_format == dm_444_32) {
-                       v->BytePerPixelInDETY[k] = 4;
-                       v->BytePerPixelInDETC[k] = 0;
-               } else if (src.source_format == dm_444_16) {
-                       v->BytePerPixelInDETY[k] = 2;
-                       v->BytePerPixelInDETC[k] = 0;
-               } else if (src.source_format == dm_420_8) {
-                       v->BytePerPixelInDETY[k] = 1;
-                       v->BytePerPixelInDETC[k] = 2;
-               } else {
-                       v->BytePerPixelInDETY[k] = 4.00 / 3.00;
-                       v->BytePerPixelInDETC[k] = 8.00 / 3.00;
-               }
-       }
-
-       v->TotalReadBandwidthConsumedGBytePerSecond = 0;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-               struct _vcs_dpi_display_pipe_dest_params_st dest =
-                               e2e[v->planes[k].e2e_index].pipe.dest;
-               struct _vcs_dpi_scaler_ratio_depth_st scale_ratio_depth =
-                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-
-               v->ReadBandwidth[k] =
-                               v->SwathWidthYSingleDPP[k]
-                                               * 
(dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                                               * 
scale_ratio_depth.vscl_ratio
-                                                               + (dml_ceil_ex(
-                                                                               
v->BytePerPixelInDETC[k],
-                                                                               
2) / 2)
-                                                                               
* (scale_ratio_depth.vscl_ratio
-                                                                               
                / 2))
-                                               / (dest.htotal / 
dest.pixel_rate_mhz);
-
-               if (src.dcc == 1) {
-                       v->ReadBandwidth[k] = v->ReadBandwidth[k] * (1 + 1 / 
256);
-               }
-
-               if (ip->pte_enable == 1 && src.source_scan != dm_horz
-                               && (src.sw_mode == dm_sw_4kb_s || src.sw_mode 
== dm_sw_4kb_s_x
-                                               || src.sw_mode == dm_sw_4kb_d
-                                               || src.sw_mode == 
dm_sw_4kb_d_x)) {
-                       v->ReadBandwidth[k] = v->ReadBandwidth[k] * (1 + 1 / 
64);
-               } else if (ip->pte_enable == 1 && src.source_scan == dm_horz
-                               && (src.source_format == dm_444_64 || 
src.source_format == dm_444_32)
-                               && (src.sw_mode == dm_sw_64kb_s || src.sw_mode 
== dm_sw_64kb_s_t
-                                               || src.sw_mode == dm_sw_64kb_s_x
-                                               || src.sw_mode == dm_sw_64kb_d
-                                               || src.sw_mode == dm_sw_64kb_d_t
-                                               || src.sw_mode == 
dm_sw_64kb_d_x)) {
-                       v->ReadBandwidth[k] = v->ReadBandwidth[k] * (1 + 1 / 
256);
-               } else if (ip->pte_enable == 1) {
-                       v->ReadBandwidth[k] = v->ReadBandwidth[k] * (1 + 1 / 
512);
-               }
-
-               v->TotalReadBandwidthConsumedGBytePerSecond =
-                               v->TotalReadBandwidthConsumedGBytePerSecond
-                                               + v->ReadBandwidth[k] / 1000;
-       }
-
-       v->TotalWriteBandwidthConsumedGBytePerSecond = 0;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_dest_params_st dest =
-                               e2e[v->planes[k].e2e_index].pipe.dest;
-               struct _vcs_dpi_display_output_params_st dout = 
e2e[v->planes[k].e2e_index].dout;
-
-               if (dout.output_type == dm_wb && dout.output_format == dm_444) {
-                       v->WriteBandwidth[k] = dest.recout_width
-                                       / (dest.htotal / dest.pixel_rate_mhz) * 
4;
-               } else if (dout.output_type == dm_wb) {
-                       v->WriteBandwidth[k] = dest.recout_width
-                                       / (dest.htotal / dest.pixel_rate_mhz) * 
1.5;
-               } else {
-                       v->WriteBandwidth[k] = 0;
-               }
-
-               v->TotalWriteBandwidthConsumedGBytePerSecond =
-                               v->TotalWriteBandwidthConsumedGBytePerSecond
-                                               + v->WriteBandwidth[k] / 1000;
-       }
-
-       v->TotalBandwidthConsumedGBytePerSecond = 
v->TotalReadBandwidthConsumedGBytePerSecond
-                       + v->TotalWriteBandwidthConsumedGBytePerSecond;
-
-       v->DCCEnabledInAnyPlane = 0;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-
-               if (src.dcc == 1) {
-                       v->DCCEnabledInAnyPlane = 1;
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               v->ReturnBWToDCNPerState = dml_min(
-                               soc->return_bus_width_bytes * 
v->DCFCLKPerState[i],
-                               v->FabricAndDRAMBandwidthPerState[i] * 1000
-                                               * 
soc->ideal_dram_bw_after_urgent_percent / 100);
-
-               v->ReturnBWPerState[i] = v->ReturnBWToDCNPerState;
-
-               if (v->DCCEnabledInAnyPlane == 1
-                               && v->ReturnBWToDCNPerState
-                                               > (v->DCFCLKPerState[i]
-                                                               * 
soc->return_bus_width_bytes / 4)) {
-                       v->ReturnBWPerState[i] =
-                                       dml_min(
-                                                       v->ReturnBWPerState[i],
-                                                       
v->ReturnBWToDCNPerState * 4
-                                                                       * (1
-                                                                               
        - soc->urgent_latency_us
-                                                                               
                        / ((ip->rob_buffer_size_kbytes
-                                                                               
                                        - ip->pixel_chunk_size_kbytes)
-                                                                               
                                        * 1024
-                                                                               
                                        / (v->ReturnBWToDCNPerState
-                                                                               
                                                        - v->DCFCLKPerState[i]
-                                                                               
                                                                        * 
soc->return_bus_width_bytes
-                                                                               
                                                                        / 4)
-                                                                               
                                        + soc->urgent_latency_us)));
-               }
-
-               v->CriticalPoint = 2 * soc->return_bus_width_bytes * 
v->DCFCLKPerState[i]
-                               * soc->urgent_latency_us
-                               / (v->ReturnBWToDCNPerState * 
soc->urgent_latency_us
-                                               + (ip->rob_buffer_size_kbytes
-                                                               - 
ip->pixel_chunk_size_kbytes)
-                                                               * 1024);
-
-               if (v->DCCEnabledInAnyPlane == 1 && v->CriticalPoint > 1 && 
v->CriticalPoint < 4) {
-                       v->ReturnBWPerState[i] =
-                                       dml_min(
-                                                       v->ReturnBWPerState[i],
-                                                       4 * 
v->ReturnBWToDCNPerState
-                                                                       * 
(ip->rob_buffer_size_kbytes
-                                                                               
        - ip->pixel_chunk_size_kbytes)
-                                                                       * 1024
-                                                                       * 
soc->return_bus_width_bytes
-                                                                       * 
v->DCFCLKPerState[i]
-                                                                       * 
soc->urgent_latency_us
-                                                                       / 
dml_pow(
-                                                                               
        (v->ReturnBWToDCNPerState
-                                                                               
                        * soc->urgent_latency_us
-                                                                               
                        + (ip->rob_buffer_size_kbytes
-                                                                               
                                        - ip->pixel_chunk_size_kbytes)
-                                                                               
                                        * 1024),
-                                                                               
        2));
-               }
-
-               v->ReturnBWToDCNPerState = dml_min(
-                               soc->return_bus_width_bytes * 
v->DCFCLKPerState[i],
-                               v->FabricAndDRAMBandwidthPerState[i] * 1000);
-
-               if (v->DCCEnabledInAnyPlane == 1
-                               && v->ReturnBWToDCNPerState
-                                               > (v->DCFCLKPerState[i]
-                                                               * 
soc->return_bus_width_bytes / 4)) {
-                       v->ReturnBWPerState[i] =
-                                       dml_min(
-                                                       v->ReturnBWPerState[i],
-                                                       
v->ReturnBWToDCNPerState * 4
-                                                                       * (1
-                                                                               
        - soc->urgent_latency_us
-                                                                               
                        / ((ip->rob_buffer_size_kbytes
-                                                                               
                                        - ip->pixel_chunk_size_kbytes)
-                                                                               
                                        * 1024
-                                                                               
                                        / (v->ReturnBWToDCNPerState
-                                                                               
                                                        - v->DCFCLKPerState[i]
-                                                                               
                                                                        * 
soc->return_bus_width_bytes
-                                                                               
                                                                        / 4)
-                                                                               
                                        + soc->urgent_latency_us)));
-               }
-
-               v->CriticalPoint = 2 * soc->return_bus_width_bytes * 
v->DCFCLKPerState[i]
-                               * soc->urgent_latency_us
-                               / (v->ReturnBWToDCNPerState * 
soc->urgent_latency_us
-                                               + (ip->rob_buffer_size_kbytes
-                                                               - 
ip->pixel_chunk_size_kbytes)
-                                                               * 1024);
-
-               if (v->DCCEnabledInAnyPlane == 1 && v->CriticalPoint > 1 && 
v->CriticalPoint < 4) {
-                       v->ReturnBWPerState[i] =
-                                       dml_min(
-                                                       v->ReturnBWPerState[i],
-                                                       4 * 
v->ReturnBWToDCNPerState
-                                                                       * 
(ip->rob_buffer_size_kbytes
-                                                                               
        - ip->pixel_chunk_size_kbytes)
-                                                                       * 1024
-                                                                       * 
soc->return_bus_width_bytes
-                                                                       * 
v->DCFCLKPerState[i]
-                                                                       * 
soc->urgent_latency_us
-                                                                       / 
dml_pow(
-                                                                               
        (v->ReturnBWToDCNPerState
-                                                                               
                        * soc->urgent_latency_us
-                                                                               
                        + (ip->rob_buffer_size_kbytes
-                                                                               
                                        - ip->pixel_chunk_size_kbytes)
-                                                                               
                                        * 1024),
-                                                                               
        2));
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               if ((v->TotalReadBandwidthConsumedGBytePerSecond * 1000 <= 
v->ReturnBWPerState[i])
-                               && (v->TotalBandwidthConsumedGBytePerSecond * 
1000
-                                               <= 
v->FabricAndDRAMBandwidthPerState[i] * 1000
-                                                               * 
soc->ideal_dram_bw_after_urgent_percent
-                                                               / 100)) {
-                       v->BandwidthSupport[i] = 1;
-               } else {
-                       v->BandwidthSupport[i] = 0;
-               }
-       }
-
-       // Writeback Latency support check
-
-       v->WritebackLatencySupport = 1;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_dest_params_st dest =
-                               e2e[v->planes[k].e2e_index].pipe.dest;
-               struct _vcs_dpi_display_output_params_st dout = 
e2e[v->planes[k].e2e_index].dout;
-
-               if (dout.output_type == dm_wb && dout.output_format == dm_444
-                               && (dest.recout_width / (dest.htotal / 
dest.pixel_rate_mhz) * 4)
-                                               > 
((ip->writeback_luma_buffer_size_kbytes
-                                                               + 
ip->writeback_chroma_buffer_size_kbytes)
-                                                               * 1024 / 
soc->writeback_latency_us)) {
-                       v->WritebackLatencySupport = 0;
-               } else if (dout.output_type == dm_wb
-                               && (dest.recout_width / (dest.htotal / 
dest.pixel_rate_mhz))
-                                               > (dml_min(
-                                                               
ip->writeback_luma_buffer_size_kbytes,
-                                                               2
-                                                                               
* ip->writeback_chroma_buffer_size_kbytes)
-                                                               * 1024 / 
soc->writeback_latency_us)) {
-                       v->WritebackLatencySupport = 0;
-               }
-       }
-
-       // Re-ordering Buffer Support Check
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               v->UrgentRoundTripAndOutOfOrderLatencyPerState[i] =
-                               (soc->round_trip_ping_latency_dcfclk_cycles + 
32)
-                                               / v->DCFCLKPerState[i]
-                                               + 
soc->urgent_out_of_order_return_per_channel_bytes
-                                                               * soc->num_chans
-                                                               / 
v->ReturnBWPerState[i];
-
-               if ((ip->rob_buffer_size_kbytes - ip->pixel_chunk_size_kbytes) 
* 1024
-                               / v->ReturnBWPerState[i]
-                               > 
v->UrgentRoundTripAndOutOfOrderLatencyPerState[i]) {
-                       v->ROBSupport[i] = 1;
-               } else {
-                       v->ROBSupport[i] = 0;
-               }
-       }
-
-       // Display IO Support Check
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_dest_params_st dest =
-                               e2e[v->planes[k].e2e_index].pipe.dest;
-               struct _vcs_dpi_display_output_params_st dout = 
e2e[v->planes[k].e2e_index].dout;
-
-               if (dout.output_format == dm_420) {
-                       v->RequiredOutputBW = dest.pixel_rate_mhz * 3 / 2;
-               } else {
-                       v->RequiredOutputBW = dest.pixel_rate_mhz * 3;
-               }
-
-               if (dout.output_type == dm_hdmi) {
-                       v->RequiredPHYCLK[k] = v->RequiredOutputBW / 3;
-               } else if (dout.output_type == dm_dp) {
-                       v->RequiredPHYCLK[k] = v->RequiredOutputBW / 4;
-               } else {
-                       v->RequiredPHYCLK[k] = 0;
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               v->DIOSupport[i] = 1;
-
-               for (k = 0; k < num_planes; k++) {
-                       struct _vcs_dpi_display_output_params_st dout =
-                                       e2e[v->planes[k].e2e_index].dout;
-
-                       if ((v->RequiredPHYCLK[k] > v->PHYCLKPerState[i])
-                                       || (dout.output_type == dm_hdmi
-                                                       && v->RequiredPHYCLK[k] 
> 600)) {
-                               v->DIOSupport[i] = 0;
-                       }
-               }
-       }
-
-       // Total Available Writeback Support Check
-
-       v->TotalNumberOfActiveWriteback = 0;
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_output_params_st dout = 
e2e[v->planes[k].e2e_index].dout;
-
-               if (dout.output_type == dm_wb) {
-                       v->TotalNumberOfActiveWriteback = 
v->TotalNumberOfActiveWriteback + 1;
-               }
-       }
-
-       if (v->TotalNumberOfActiveWriteback <= ip->max_num_wb) {
-               v->TotalAvailableWritebackSupport = 1;
-       } else {
-               v->TotalAvailableWritebackSupport = 0;
-       }
-
-       // Maximum DISPCLK/DPPCLK Support check
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_dest_params_st dest =
-                               e2e[v->planes[k].e2e_index].pipe.dest;
-               struct _vcs_dpi_scaler_ratio_depth_st scale_ratio_depth =
-                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-               struct _vcs_dpi_scaler_taps_st scale_taps =
-                               e2e[v->planes[k].e2e_index].pipe.scale_taps;
-
-               if (scale_ratio_depth.hscl_ratio > 1) {
-                       v->PSCL_FACTOR[k] = dml_min(
-                                       ip->max_dchub_pscl_bw_pix_per_clk,
-                                       ip->max_pscl_lb_bw_pix_per_clk
-                                                       * 
scale_ratio_depth.hscl_ratio
-                                                       / 
dml_ceil_ex(scale_taps.htaps / 6, 1));
-               } else {
-                       v->PSCL_FACTOR[k] = dml_min(
-                                       ip->max_dchub_pscl_bw_pix_per_clk,
-                                       ip->max_pscl_lb_bw_pix_per_clk);
-               }
-
-               if (v->BytePerPixelInDETC[k] == 0) {
-                       v->PSCL_FACTOR_CHROMA[k] = 0;
-                       v->MinDPPCLKUsingSingleDPP[k] =
-                                       dest.pixel_rate_mhz
-                                                       * dml_max(
-                                                                       
scale_taps.vtaps / 6
-                                                                               
        * dml_min(
-                                                                               
                        1,
-                                                                               
                        scale_ratio_depth.hscl_ratio),
-                                                                       dml_max(
-                                                                               
        scale_ratio_depth.hscl_ratio
-                                                                               
                        * scale_ratio_depth.vscl_ratio
-                                                                               
                        / v->PSCL_FACTOR[k],
-                                                                               
        1));
-
-               } else {
-                       if (scale_ratio_depth.hscl_ratio / 2 > 1) {
-                               v->PSCL_FACTOR_CHROMA[k] = dml_min(
-                                               
ip->max_dchub_pscl_bw_pix_per_clk,
-                                               ip->max_pscl_lb_bw_pix_per_clk
-                                                               * 
scale_ratio_depth.hscl_ratio / 2
-                                                               / dml_ceil_ex(
-                                                                               
scale_taps.htaps_c
-                                                                               
                / 6,
-                                                                               
1));
-                       } else {
-                               v->PSCL_FACTOR_CHROMA[k] = dml_min(
-                                               
ip->max_dchub_pscl_bw_pix_per_clk,
-                                               ip->max_pscl_lb_bw_pix_per_clk);
-                       }
-                       v->MinDPPCLKUsingSingleDPP[k] =
-                                       dest.pixel_rate_mhz
-                                                       * dml_max(
-                                                                       dml_max(
-                                                                               
        scale_taps.vtaps
-                                                                               
                        / 6
-                                                                               
                        * dml_min(
-                                                                               
                                        1,
-                                                                               
                                        scale_ratio_depth.hscl_ratio),
-                                                                               
        scale_ratio_depth.hscl_ratio
-                                                                               
                        * scale_ratio_depth.vscl_ratio
-                                                                               
                        / v->PSCL_FACTOR[k]),
-                                                                       dml_max(
-                                                                               
        dml_max(
-                                                                               
                        scale_taps.vtaps_c
-                                                                               
                                        / 6
-                                                                               
                                        * dml_min(
-                                                                               
                                                        1,
-                                                                               
                                                        
scale_ratio_depth.hscl_ratio
-                                                                               
                                                                        / 2),
-                                                                               
                        scale_ratio_depth.hscl_ratio
-                                                                               
                                        * scale_ratio_depth.vscl_ratio
-                                                                               
                                        / 4
-                                                                               
                                        / v->PSCL_FACTOR_CHROMA[k]),
-                                                                               
        1));
-
-               }
-       }
-
-       for (k = 0; k < num_planes; k++) {
-               struct _vcs_dpi_display_pipe_source_params_st src =
-                               e2e[v->planes[k].e2e_index].pipe.src;
-               struct _vcs_dpi_scaler_ratio_depth_st scale_ratio_depth =
-                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-               struct _vcs_dpi_scaler_taps_st scale_taps =
-                               e2e[v->planes[k].e2e_index].pipe.scale_taps;
-
-               if (src.source_format == dm_444_64 || src.source_format == 
dm_444_32
-                               || src.source_format == dm_444_16) {
-                       if (src.sw_mode == dm_sw_linear) {
-                               v->Read256BlockHeightY[k] = 1;
-                       } else if (src.source_format == dm_444_64) {
-                               v->Read256BlockHeightY[k] = 4;
-                       } else {
-                               v->Read256BlockHeightY[k] = 8;
-                       }
-
-                       v->Read256BlockWidthY[k] = 256 / 
dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                       / v->Read256BlockHeightY[k];
-                       v->Read256BlockHeightC[k] = 0;
-                       v->Read256BlockWidthC[k] = 0;
-               } else {
-                       if (src.sw_mode == dm_sw_linear) {
-                               v->Read256BlockHeightY[k] = 1;
-                               v->Read256BlockHeightC[k] = 1;
-                       } else if (src.source_format == dm_420_8) {
-                               v->Read256BlockHeightY[k] = 16;
-                               v->Read256BlockHeightC[k] = 8;
-                       } else {
-                               v->Read256BlockHeightY[k] = 8;
-                               v->Read256BlockHeightC[k] = 8;
-                       }
-
-                       v->Read256BlockWidthY[k] = 256 / 
dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                       / v->Read256BlockHeightY[k];
-                       v->Read256BlockWidthC[k] = 256 / 
dml_ceil_ex(v->BytePerPixelInDETC[k], 2)
-                                       / v->Read256BlockHeightC[k];
-               }
-
-               if (src.source_scan == dm_horz) {
-                       v->MaxSwathHeightY[k] = v->Read256BlockHeightY[k];
-                       v->MaxSwathHeightC[k] = v->Read256BlockHeightC[k];
-               } else {
-                       v->MaxSwathHeightY[k] = v->Read256BlockWidthY[k];
-                       v->MaxSwathHeightC[k] = v->Read256BlockWidthC[k];
-               }
-
-               if (src.source_format == dm_444_64 || src.source_format == 
dm_444_32
-                               || src.source_format == dm_444_16) {
-                       if (src.sw_mode == dm_sw_linear
-                                       || (src.source_format == dm_444_64
-                                                       && (src.sw_mode == 
dm_sw_4kb_s
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_4kb_s_x
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_64kb_s
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_64kb_s_t
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_64kb_s_x
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_var_s
-                                                                       || 
src.sw_mode
-                                                                               
        == dm_sw_var_s_x)
-                                                       && src.source_scan == 
dm_horz)) {
-                               v->MinSwathHeightY[k] = v->MaxSwathHeightY[k];
-                       } else {
-                               v->MinSwathHeightY[k] = v->MaxSwathHeightY[k] / 
2;
-                       }
-                       v->MinSwathHeightC[k] = v->MaxSwathHeightC[k];
-               } else {
-                       if (src.sw_mode == dm_sw_linear) {
-                               v->MinSwathHeightY[k] = v->MaxSwathHeightY[k];
-                               v->MinSwathHeightC[k] = v->MaxSwathHeightC[k];
-                       } else if (src.source_format == dm_420_8 && 
src.source_scan == dm_horz) {
-                               v->MinSwathHeightY[k] = v->MaxSwathHeightY[k] / 
2;
-                               if (ip->bug_forcing_LC_req_same_size_fixed == 
1) {
-                                       v->MinSwathHeightC[k] = 
v->MaxSwathHeightC[k];
-                               } else {
-                                       v->MinSwathHeightC[k] = 
v->MaxSwathHeightC[k] / 2;
-                               }
-                       } else if (src.source_format == dm_420_10 && 
src.source_scan == dm_horz) {
-                               v->MinSwathHeightC[k] = v->MaxSwathHeightC[k] / 
2;
-                               if (ip->bug_forcing_LC_req_same_size_fixed == 
1) {
-                                       v->MinSwathHeightY[k] = 
v->MaxSwathHeightY[k];
-                               } else {
-                                       v->MinSwathHeightY[k] = 
v->MaxSwathHeightY[k] / 2;
-                               }
-                       } else {
-                               v->MinSwathHeightY[k] = v->MaxSwathHeightY[k];
-                               v->MinSwathHeightC[k] = v->MaxSwathHeightC[k];
-                       }
-               }
-
-               if (src.sw_mode == dm_sw_linear) {
-                       v->MaximumSwathWidth = 8192;
-               } else {
-                       v->MaximumSwathWidth = 5120;
-               }
-
-               v->NumberOfDPPRequiredForDETSize =
-                               dml_ceil_ex(
-                                               v->SwathWidthYSingleDPP[k]
-                                                               / dml_min(
-                                                                               
v->MaximumSwathWidth,
-                                                                               
ip->det_buffer_size_kbytes
-                                                                               
                * 1024
-                                                                               
                / 2
-                                                                               
                / (v->BytePerPixelInDETY[k]
-                                                                               
                                * v->MinSwathHeightY[k]
-                                                                               
                                + v->BytePerPixelInDETC[k]
-                                                                               
                                                / 2
-                                                                               
                                                * v->MinSwathHeightC[k])),
-                                               1);
-
-               if (v->BytePerPixelInDETC[k] == 0) {
-                       v->NumberOfDPPRequiredForLBSize =
-                                       dml_ceil_ex(
-                                                       (scale_taps.vtaps
-                                                                       + 
dml_max(
-                                                                               
        dml_ceil_ex(
-                                                                               
                        scale_ratio_depth.vscl_ratio,
-                                                                               
                        1)
-                                                                               
                        - 2,
-                                                                               
        0))
-                                                                       * 
v->SwathWidthYSingleDPP[k]
-                                                                       / 
dml_max(
-                                                                               
        scale_ratio_depth.hscl_ratio,
-                                                                               
        1)
-                                                                       * 
scale_ratio_depth.lb_depth
-                                                                       / 
ip->line_buffer_size_bits,
-                                                       1);
-               } else {
-                       v->NumberOfDPPRequiredForLBSize =
-                                       dml_max(
-                                                       dml_ceil_ex(
-                                                                       
(scale_taps.vtaps
-                                                                               
        + dml_max(
-                                                                               
                        dml_ceil_ex(
-                                                                               
                                        scale_ratio_depth.vscl_ratio,
-                                                                               
                                        1)
-                                                                               
                                        - 2,
-                                                                               
                        0))
-                                                                               
        * v->SwathWidthYSingleDPP[k]
-                                                                               
        / dml_max(
-                                                                               
                        scale_ratio_depth.hscl_ratio,
-                                                                               
                        1)
-                                                                               
        * scale_ratio_depth.lb_depth
-                                                                               
        / ip->line_buffer_size_bits,
-                                                                       1),
-                                                       dml_ceil_ex(
-                                                                       
(scale_taps.vtaps_c
-                                                                               
        + dml_max(
-                                                                               
                        dml_ceil_ex(
-                                                                               
                                        scale_ratio_depth.vscl_ratio
-                                                                               
                                                        / 2,
-                                                                               
                                        1)
-                                                                               
                                        - 2,
-                                                                               
                        0))
-                                                                               
        * v->SwathWidthYSingleDPP[k]
-                                                                               
        / 2
-                                                                               
        / dml_max(
-                                                                               
                        scale_ratio_depth.hscl_ratio
-                                                                               
                                        / 2,
-                                                                               
                        1)
-                                                                               
        * scale_ratio_depth.lb_depth
-                                                                               
        / ip->line_buffer_size_bits,
-                                                                       1));
-               }
-
-               v->NumberOfDPPRequiredForDETAndLBSize[k] = dml_max(
-                               v->NumberOfDPPRequiredForDETSize,
-                               v->NumberOfDPPRequiredForLBSize);
-
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       v->TotalNumberOfActiveDPP[j * NumberOfStatesPlusTwo + 
i] = 0;
-                       v->RequiredDISPCLK[j * NumberOfStatesPlusTwo + i] = 0;
-                       v->DISPCLK_DPPCLK_Support[j * NumberOfStatesPlusTwo + 
i] = 1;
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               v->MinDispclkUsingSingleDPP = dml_max(
-                                               dest.pixel_rate_mhz,
-                                               v->MinDPPCLKUsingSingleDPP[k] * 
(j + 1))
-                                               * (1 + soc->downspread_percent 
/ 100);
-                               v->MinDispclkUsingDualDPP = dml_max(
-                                               dest.pixel_rate_mhz,
-                                               v->MinDPPCLKUsingSingleDPP[k] / 
2 * (j + 1))
-                                               * (1 + soc->downspread_percent 
/ 100);
-
-                               if (i < NumberOfStates) {
-                                       v->MinDispclkUsingSingleDPP =
-                                                       
v->MinDispclkUsingSingleDPP
-                                                                       * (1
-                                                                               
        + ip->dispclk_ramp_margin_percent
-                                                                               
                        / 100);
-                                       v->MinDispclkUsingDualDPP =
-                                                       
v->MinDispclkUsingDualDPP
-                                                                       * (1
-                                                                               
        + ip->dispclk_ramp_margin_percent
-                                                                               
                        / 100);
-                               }
-
-                               if (v->MinDispclkUsingSingleDPP
-                                               <= dml_min(
-                                                               
v->MaxDispclk[i],
-                                                               (j + 1) * 
v->MaxDppclk[i])
-                                               && 
v->NumberOfDPPRequiredForDETAndLBSize[k] <= 1) {
-                                       v->NoOfDPP[ijk] = 1;
-                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo + i] = dml_max(
-                                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo
-                                                                       + i],
-                                                       
v->MinDispclkUsingSingleDPP);
-                               } else if (v->MinDispclkUsingDualDPP
-                                               <= dml_min(
-                                                               
v->MaxDispclk[i],
-                                                               (j + 1) * 
v->MaxDppclk[i])) {
-                                       v->NoOfDPP[ijk] = 2;
-                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo + i] = dml_max(
-                                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo
-                                                                       + i],
-                                                       
v->MinDispclkUsingDualDPP);
-                               } else {
-                                       v->NoOfDPP[ijk] = 2;
-                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo + i] = dml_max(
-                                                       v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo
-                                                                       + i],
-                                                       
v->MinDispclkUsingDualDPP);
-                                       v->DISPCLK_DPPCLK_Support[j * 
NumberOfStatesPlusTwo + i] =
-                                                       0;
-                               }
-
-                               v->TotalNumberOfActiveDPP[j * 
NumberOfStatesPlusTwo + i] =
-                                               v->TotalNumberOfActiveDPP[j * 
NumberOfStatesPlusTwo
-                                                               + i] + 
v->NoOfDPP[ijk];
-                       }
-
-                       if (v->TotalNumberOfActiveDPP[j * NumberOfStatesPlusTwo 
+ i]
-                                       > ip->max_num_dpp) {
-                               v->TotalNumberOfActiveDPP[j * 
NumberOfStatesPlusTwo + i] = 0;
-                               v->RequiredDISPCLK[j * NumberOfStatesPlusTwo + 
i] = 0;
-                               v->DISPCLK_DPPCLK_Support[j * 
NumberOfStatesPlusTwo + i] = 1;
-
-                               for (k = 0; k < num_planes; k++) {
-                                       struct 
_vcs_dpi_display_pipe_dest_params_st dest =
-                                                       
e2e[v->planes[k].e2e_index].pipe.dest;
-                                       ijk = k * 2 * NumberOfStatesPlusTwo
-                                                       + j * 
NumberOfStatesPlusTwo + i;
-
-                                       v->MinDispclkUsingSingleDPP = dml_max(
-                                                       dest.pixel_rate_mhz,
-                                                       
v->MinDPPCLKUsingSingleDPP[k] * (j + 1))
-                                                       * (1 + 
soc->downspread_percent / 100);
-                                       v->MinDispclkUsingDualDPP = dml_max(
-                                                       dest.pixel_rate_mhz,
-                                                       
v->MinDPPCLKUsingSingleDPP[k] / 2 * (j + 1))
-                                                       * (1 + 
soc->downspread_percent / 100);
-
-                                       if (i < NumberOfStates) {
-                                               v->MinDispclkUsingSingleDPP =
-                                                               
v->MinDispclkUsingSingleDPP
-                                                                               
* (1
-                                                                               
                + ip->dispclk_ramp_margin_percent
-                                                                               
                                / 100);
-                                               v->MinDispclkUsingDualDPP =
-                                                               
v->MinDispclkUsingDualDPP
-                                                                               
* (1
-                                                                               
                + ip->dispclk_ramp_margin_percent
-                                                                               
                                / 100);
-                                       }
-
-                                       if 
(v->NumberOfDPPRequiredForDETAndLBSize[k] <= 1) {
-                                               v->NoOfDPP[ijk] = 1;
-                                               v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo + i] =
-                                                               dml_max(
-                                                                               
v->RequiredDISPCLK[j
-                                                                               
                * NumberOfStatesPlusTwo
-                                                                               
                + i],
-                                                                               
v->MinDispclkUsingSingleDPP);
-                                               if (v->MinDispclkUsingSingleDPP
-                                                               > dml_min(
-                                                                               
v->MaxDispclk[i],
-                                                                               
(j + 1)
-                                                                               
                * v->MaxDppclk[i])) {
-                                                       
v->DISPCLK_DPPCLK_Support[j
-                                                                       * 
NumberOfStatesPlusTwo + i] =
-                                                                       0;
-                                               }
-                                       } else {
-                                               v->NoOfDPP[ijk] = 2;
-                                               v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo + i] =
-                                                               dml_max(
-                                                                               
v->RequiredDISPCLK[j
-                                                                               
                * NumberOfStatesPlusTwo
-                                                                               
                + i],
-                                                                               
v->MinDispclkUsingDualDPP);
-                                               if (v->MinDispclkUsingDualDPP
-                                                               > dml_min(
-                                                                               
v->MaxDispclk[i],
-                                                                               
(j + 1)
-                                                                               
                * v->MaxDppclk[i])) {
-                                                       
v->DISPCLK_DPPCLK_Support[j
-                                                                       * 
NumberOfStatesPlusTwo + i] =
-                                                                       0;
-                                               }
-                                       }
-                                       v->TotalNumberOfActiveDPP[j * 
NumberOfStatesPlusTwo + i] =
-                                                       
v->TotalNumberOfActiveDPP[j
-                                                                       * 
NumberOfStatesPlusTwo + i]
-                                                                       + 
v->NoOfDPP[ijk];
-                               }
-                       }
-               }
-       }
-
-       // Viewport Size Check
-
-       v->ViewportSizeSupport = 1;
-
-       for (k = 0; k < num_planes; k++) {
-               if (v->NumberOfDPPRequiredForDETAndLBSize[k] > 2) {
-                       v->ViewportSizeSupport = 0;
-               }
-       }
-
-       // Total Available Pipes Support Check
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       if (v->TotalNumberOfActiveDPP[j * NumberOfStatesPlusTwo 
+ i]
-                                       <= ip->max_num_dpp) {
-                               v->TotalAvailablePipesSupport[j * 
NumberOfStatesPlusTwo + i] = 1;
-                       } else {
-                               v->TotalAvailablePipesSupport[j * 
NumberOfStatesPlusTwo + i] = 0;
-                       }
-               }
-       }
-
-       // Urgent Latency Support Check
-
-       for (j = 0; j < 2; j++) {
-               for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               struct _vcs_dpi_scaler_ratio_depth_st 
scale_ratio_depth =
-                                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-                               struct _vcs_dpi_scaler_taps_st scale_taps =
-                                               
e2e[v->planes[k].e2e_index].pipe.scale_taps;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               v->SwathWidthYPerState[ijk] = 
v->SwathWidthYSingleDPP[k]
-                                               / v->NoOfDPP[ijk];
-
-                               v->SwathWidthGranularityY = 256
-                                               / 
dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                               / v->MaxSwathHeightY[k];
-                               v->RoundedUpMaxSwathSizeBytesY = (dml_ceil_ex(
-                                               v->SwathWidthYPerState[ijk] - 1,
-                                               v->SwathWidthGranularityY)
-                                               + v->SwathWidthGranularityY)
-                                               * v->BytePerPixelInDETY[k] * 
v->MaxSwathHeightY[k];
-                               if (src.source_format == dm_420_10) {
-                                       v->RoundedUpMaxSwathSizeBytesY = 
dml_ceil_ex(
-                                                       
v->RoundedUpMaxSwathSizeBytesY,
-                                                       256) + 256;
-                               }
-                               if (v->MaxSwathHeightC[k] > 0) {
-                                       v->SwathWidthGranularityC = 256
-                                                       / 
dml_ceil_ex(v->BytePerPixelInDETC[k], 2)
-                                                       / v->MaxSwathHeightC[k];
-                               }
-                               v->RoundedUpMaxSwathSizeBytesC = (dml_ceil_ex(
-                                               v->SwathWidthYPerState[ijk] / 2 
- 1,
-                                               v->SwathWidthGranularityC)
-                                               + v->SwathWidthGranularityC)
-                                               * v->BytePerPixelInDETC[k] * 
v->MaxSwathHeightC[k];
-                               if (src.source_format == dm_420_10) {
-                                       v->RoundedUpMaxSwathSizeBytesC = 
dml_ceil_ex(
-                                                       
v->RoundedUpMaxSwathSizeBytesC,
-                                                       256) + 256;
-                               }
-
-                               if (v->RoundedUpMaxSwathSizeBytesY + 
v->RoundedUpMaxSwathSizeBytesC
-                                               <= ip->det_buffer_size_kbytes * 
1024 / 2) {
-                                       v->SwathHeightYPerState[ijk] = 
v->MaxSwathHeightY[k];
-                                       v->SwathHeightCPerState[ijk] = 
v->MaxSwathHeightC[k];
-                               } else {
-                                       v->SwathHeightYPerState[ijk] = 
v->MinSwathHeightY[k];
-                                       v->SwathHeightCPerState[ijk] = 
v->MinSwathHeightC[k];
-                               }
-
-                               if (v->BytePerPixelInDETC[k] == 0) {
-                                       v->LinesInDETLuma = 
ip->det_buffer_size_kbytes * 1024
-                                                       / 
v->BytePerPixelInDETY[k]
-                                                       / 
v->SwathWidthYPerState[ijk];
-
-                                       v->LinesInDETChroma = 0;
-                               } else if (v->SwathHeightYPerState[ijk]
-                                               <= 
v->SwathHeightCPerState[ijk]) {
-                                       v->LinesInDETLuma = 
ip->det_buffer_size_kbytes * 1024 / 2
-                                                       / 
v->BytePerPixelInDETY[k]
-                                                       / 
v->SwathWidthYPerState[ijk];
-                                       v->LinesInDETChroma = 
ip->det_buffer_size_kbytes * 1024 / 2
-                                                       / 
v->BytePerPixelInDETC[k]
-                                                       / 
(v->SwathWidthYPerState[ijk] / 2);
-                               } else {
-                                       v->LinesInDETLuma = 
ip->det_buffer_size_kbytes * 1024 * 2
-                                                       / 3 / 
v->BytePerPixelInDETY[k]
-                                                       / 
v->SwathWidthYPerState[ijk];
-                                       v->LinesInDETChroma = 
ip->det_buffer_size_kbytes * 1024 / 3
-                                                       / 
v->BytePerPixelInDETY[k]
-                                                       / 
(v->SwathWidthYPerState[ijk] / 2);
-                               }
-
-                               v->EffectiveLBLatencyHidingSourceLinesLuma =
-                                               dml_min(
-                                                               
ip->max_line_buffer_lines,
-                                                               dml_floor_ex(
-                                                                               
ip->line_buffer_size_bits
-                                                                               
                / scale_ratio_depth.lb_depth
-                                                                               
                / (v->SwathWidthYPerState[ijk]
-                                                                               
                                / dml_max(
-                                                                               
                                                scale_ratio_depth.hscl_ratio,
-                                                                               
                                                1)),
-                                                                               
1))
-                                                               - 
(scale_taps.vtaps - 1);
-
-                               v->EffectiveLBLatencyHidingSourceLinesChroma =
-                                               dml_min(
-                                                               
ip->max_line_buffer_lines,
-                                                               dml_floor_ex(
-                                                                               
ip->line_buffer_size_bits
-                                                                               
                / scale_ratio_depth.lb_depth
-                                                                               
                / (v->SwathWidthYPerState[ijk]
-                                                                               
                                / 2
-                                                                               
                                / dml_max(
-                                                                               
                                                scale_ratio_depth.hscl_ratio
-                                                                               
                                                                / 2,
-                                                                               
                                                1)),
-                                                                               
1))
-                                                               - 
(scale_taps.vtaps_c - 1);
-
-                               v->EffectiveDETLBLinesLuma =
-                                               dml_floor_ex(
-                                                               
v->LinesInDETLuma
-                                                                               
+ dml_min(
-                                                                               
                v->LinesInDETLuma
-                                                                               
                                * v->RequiredDISPCLK[ij]
-                                                                               
                                * v->BytePerPixelInDETY[k]
-                                                                               
                                * v->PSCL_FACTOR[k]
-                                                                               
                                / v->ReturnBWPerState[i],
-                                                                               
                v->EffectiveLBLatencyHidingSourceLinesLuma),
-                                                               
v->SwathHeightYPerState[ijk]);
-
-                               v->EffectiveDETLBLinesChroma =
-                                               dml_floor_ex(
-                                                               
v->LinesInDETChroma
-                                                                               
+ dml_min(
-                                                                               
                v->LinesInDETChroma
-                                                                               
                                * v->RequiredDISPCLK[ij]
-                                                                               
                                * v->BytePerPixelInDETC[k]
-                                                                               
                                * v->PSCL_FACTOR_CHROMA[k]
-                                                                               
                                / v->ReturnBWPerState[i],
-                                                                               
                v->EffectiveLBLatencyHidingSourceLinesChroma),
-                                                               
v->SwathHeightCPerState[ijk]);
-
-                               if (v->BytePerPixelInDETC[k] == 0) {
-                                       v->UrgentLatencySupportUsPerState[ijk] =
-                                                       
v->EffectiveDETLBLinesLuma
-                                                                       * 
(dest.htotal
-                                                                               
        / dest.pixel_rate_mhz)
-                                                                       / 
scale_ratio_depth.vscl_ratio
-                                                                       - 
v->EffectiveDETLBLinesLuma
-                                                                               
        * v->SwathWidthYPerState[ijk]
-                                                                               
        * dml_ceil_ex(
-                                                                               
                        v->BytePerPixelInDETY[k],
-                                                                               
                        1)
-                                                                               
        / (v->ReturnBWPerState[i]
-                                                                               
                        / v->NoOfDPP[ijk]);
-                               } else {
-                                       v->UrgentLatencySupportUsPerState[ijk] =
-                                                       dml_min(
-                                                                       
v->EffectiveDETLBLinesLuma
-                                                                               
        * (dest.htotal
-                                                                               
                        / dest.pixel_rate_mhz)
-                                                                               
        / scale_ratio_depth.vscl_ratio
-                                                                               
        - v->EffectiveDETLBLinesLuma
-                                                                               
                        * v->SwathWidthYPerState[ijk]
-                                                                               
                        * dml_ceil_ex(
-                                                                               
                                        v->BytePerPixelInDETY[k],
-                                                                               
                                        1)
-                                                                               
                        / (v->ReturnBWPerState[i]
-                                                                               
                                        / v->NoOfDPP[ijk]),
-                                                                       
v->EffectiveDETLBLinesChroma
-                                                                               
        * (dest.htotal
-                                                                               
                        / dest.pixel_rate_mhz)
-                                                                               
        / (scale_ratio_depth.vscl_ratio
-                                                                               
                        / 2)
-                                                                               
        - v->EffectiveDETLBLinesChroma
-                                                                               
                        * v->SwathWidthYPerState[ijk]
-                                                                               
                        / 2
-                                                                               
                        * dml_ceil_ex(
-                                                                               
                                        v->BytePerPixelInDETC[k],
-                                                                               
                                        2)
-                                                                               
                        / (v->ReturnBWPerState[i]
-                                                                               
                                        / v->NoOfDPP[ijk]));
-                               }
-
-                       }
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-
-                       v->UrgentLatencySupport[ij] = 1;
-                       for (k = 0; k < num_planes; k++) {
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (v->UrgentLatencySupportUsPerState[ijk]
-                                               < soc->urgent_latency_us / 1) {
-                                       v->UrgentLatencySupport[ij] = 0;
-                               }
-                       }
-               }
-       }
-
-       // Prefetch Check
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-
-                       v->TotalNumberOfDCCActiveDPP[ij] = 0;
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (src.dcc == 1) {
-                                       v->TotalNumberOfDCCActiveDPP[ij] =
-                                                       
v->TotalNumberOfDCCActiveDPP[ij]
-                                                                       + 
v->NoOfDPP[ijk];
-                               }
-                       }
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-
-                       v->ProjectedDCFCLKDeepSleep = 8;
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               struct _vcs_dpi_scaler_ratio_depth_st 
scale_ratio_depth =
-                                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               v->ProjectedDCFCLKDeepSleep = dml_max(
-                                               v->ProjectedDCFCLKDeepSleep,
-                                               dest.pixel_rate_mhz / 16);
-                               if (v->BytePerPixelInDETC[k] == 0) {
-                                       if (scale_ratio_depth.vscl_ratio <= 1) {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETY[k],
-                                                                               
                                1)
-                                                                               
                / 64
-                                                                               
                * scale_ratio_depth.hscl_ratio
-                                                                               
                * dest.pixel_rate_mhz
-                                                                               
                / v->NoOfDPP[ijk]);
-                                       } else {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETY[k],
-                                                                               
                                1)
-                                                                               
                / 64
-                                                                               
                * v->PSCL_FACTOR[k]
-                                                                               
                * v->RequiredDISPCLK[ij]
-                                                                               
                / (1
-                                                                               
                                + j));
-                                       }
-
-                               } else {
-                                       if (scale_ratio_depth.vscl_ratio <= 1) {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETY[k],
-                                                                               
                                1)
-                                                                               
                / 32
-                                                                               
                * scale_ratio_depth.hscl_ratio
-                                                                               
                * dest.pixel_rate_mhz
-                                                                               
                / v->NoOfDPP[ijk]);
-                                       } else {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETY[k],
-                                                                               
                                1)
-                                                                               
                / 32
-                                                                               
                * v->PSCL_FACTOR[k]
-                                                                               
                * v->RequiredDISPCLK[ij]
-                                                                               
                / (1
-                                                                               
                                + j));
-                                       }
-                                       if ((scale_ratio_depth.vscl_ratio / 2) 
<= 1) {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETC[k],
-                                                                               
                                2)
-                                                                               
                / 32
-                                                                               
                * scale_ratio_depth.hscl_ratio
-                                                                               
                / 2
-                                                                               
                * dest.pixel_rate_mhz
-                                                                               
                / v->NoOfDPP[ijk]);
-                                       } else {
-                                               v->ProjectedDCFCLKDeepSleep =
-                                                               dml_max(
-                                                                               
v->ProjectedDCFCLKDeepSleep,
-                                                                               
1.1
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETC[k],
-                                                                               
                                2)
-                                                                               
                / 32
-                                                                               
                * v->PSCL_FACTOR_CHROMA[k]
-                                                                               
                * v->RequiredDISPCLK[ij]
-                                                                               
                / (1
-                                                                               
                                + j));
-                                       }
-
-                               }
-                       }
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               struct _vcs_dpi_scaler_ratio_depth_st 
scale_ratio_depth =
-                                               
e2e[v->planes[k].e2e_index].pipe.scale_ratio_depth;
-                               struct _vcs_dpi_scaler_taps_st scale_taps =
-                                               
e2e[v->planes[k].e2e_index].pipe.scale_taps;
-                               struct _vcs_dpi_display_output_params_st dout =
-                                               
e2e[v->planes[k].e2e_index].dout;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (src.dcc == 1) {
-                                       v->MetaReqHeightY = 8 * 
v->Read256BlockHeightY[k];
-                                       v->MetaReqWidthY = 64 * 256
-                                                       / 
dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                                       / v->MetaReqHeightY;
-                                       v->MetaSurfaceWidthY = dml_ceil_ex(
-                                                       src.viewport_width / 
v->NoOfDPP[ijk] - 1,
-                                                       v->MetaReqWidthY) + 
v->MetaReqWidthY;
-                                       v->MetaSurfaceHeightY = dml_ceil_ex(
-                                                       src.viewport_height - 1,
-                                                       v->MetaReqHeightY) + 
v->MetaReqHeightY;
-                                       if (ip->pte_enable == 1) {
-                                               v->MetaPteBytesPerFrameY =
-                                                               (dml_ceil_ex(
-                                                                               
(v->MetaSurfaceWidthY
-                                                                               
                * v->MetaSurfaceHeightY
-                                                                               
                * dml_ceil_ex(
-                                                                               
                                v->BytePerPixelInDETY[k],
-                                                                               
                                1)
-                                                                               
                / 256.0
-                                                                               
                - 4096)
-                                                                               
                / 8
-                                                                               
                / 4096,
-                                                                               
1) + 1) * 64;
-                                       } else {
-                                               v->MetaPteBytesPerFrameY = 0;
-                                       }
-                                       if (src.source_scan == dm_horz) {
-                                               v->MetaRowBytesY =
-                                                               
v->MetaSurfaceWidthY
-                                                                               
* v->MetaReqHeightY
-                                                                               
* dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETY[k],
-                                                                               
                1)
-                                                                               
/ 256;
-                                       } else {
-                                               v->MetaRowBytesY =
-                                                               
v->MetaSurfaceHeightY
-                                                                               
* v->MetaReqWidthY
-                                                                               
* dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETY[k],
-                                                                               
                1)
-                                                                               
/ 256;
-                                       }
-                               } else {
-                                       v->MetaPteBytesPerFrameY = 0;
-                                       v->MetaRowBytesY = 0;
-                               }
-
-                               if (ip->pte_enable == 1) {
-                                       if (src.sw_mode == dm_sw_linear) {
-                                               v->MacroTileBlockSizeBytesY = 
256;
-                                               v->MacroTileBlockHeightY = 1;
-                                       } else if (src.sw_mode == dm_sw_4kb_s
-                                                       || src.sw_mode == 
dm_sw_4kb_s_x
-                                                       || src.sw_mode == 
dm_sw_4kb_d
-                                                       || src.sw_mode == 
dm_sw_4kb_d_x) {
-                                               v->MacroTileBlockSizeBytesY = 
4096;
-                                               v->MacroTileBlockHeightY = 4
-                                                               * 
v->Read256BlockHeightY[k];
-                                       } else if (src.sw_mode == dm_sw_64kb_s
-                                                       || src.sw_mode == 
dm_sw_64kb_s_t
-                                                       || src.sw_mode == 
dm_sw_64kb_s_x
-                                                       || src.sw_mode == 
dm_sw_64kb_d
-                                                       || src.sw_mode == 
dm_sw_64kb_d_t
-                                                       || src.sw_mode == 
dm_sw_64kb_d_x) {
-                                               v->MacroTileBlockSizeBytesY = 
64 * 1024;
-                                               v->MacroTileBlockHeightY = 16
-                                                               * 
v->Read256BlockHeightY[k];
-                                       } else {
-                                               v->MacroTileBlockSizeBytesY = 
256 * 1024;
-                                               v->MacroTileBlockHeightY = 32
-                                                               * 
v->Read256BlockHeightY[k];
-                                       }
-                                       if (v->MacroTileBlockSizeBytesY <= 
65536) {
-                                               v->DataPTEReqHeightY = 
v->MacroTileBlockHeightY;
-                                       } else {
-                                               v->DataPTEReqHeightY = 16
-                                                               * 
v->Read256BlockHeightY[k];
-                                       }
-                                       v->DataPTEReqWidthY = 4096
-                                                       / 
dml_ceil_ex(v->BytePerPixelInDETY[k], 1)
-                                                       / v->DataPTEReqHeightY 
* 8;
-                                       if (src.sw_mode == dm_sw_linear) {
-                                               v->DPTEBytesPerRowY =
-                                                               64
-                                                                               
* (dml_ceil_ex(
-                                                                               
                (src.viewport_width
-                                                                               
                                / v->NoOfDPP[ijk]
-                                                                               
                                * dml_min(
-                                                                               
                                                128,
-                                                                               
                                                dml_pow(
-                                                                               
                                                                2,
-                                                                               
                                                                dml_floor_ex(
-                                                                               
                                                                                
dml_log(
-                                                                               
                                                                                
                ip->dpte_buffer_size_in_pte_reqs
-                                                                               
                                                                                
                                * v->DataPTEReqWidthY
-                                                                               
                                                                                
                                / (src.viewport_width
-                                                                               
                                                                                
                                                / v->NoOfDPP[ijk]),
-                                                                               
                                                                                
                2),
-                                                                               
                                                                                
1)))
-                                                                               
                                - 1)
-                                                                               
                                / v->DataPTEReqWidthY,
-                                                                               
                1)
-                                                                               
                + 1);
-                                       } else if (src.source_scan == dm_horz) {
-                                               v->DPTEBytesPerRowY =
-                                                               64
-                                                                               
* (dml_ceil_ex(
-                                                                               
                (src.viewport_width
-                                                                               
                                / v->NoOfDPP[ijk]
-                                                                               
                                - 1)
-                                                                               
                                / v->DataPTEReqWidthY,
-                                                                               
                1)
-                                                                               
                + 1);
-                                       } else {
-                                               v->DPTEBytesPerRowY =
-                                                               64
-                                                                               
* (dml_ceil_ex(
-                                                                               
                (src.viewport_height
-                                                                               
                                - 1)
-                                                                               
                                / v->DataPTEReqHeightY,
-                                                                               
                1)
-                                                                               
                + 1);
-                                       }
-                               } else {
-                                       v->DPTEBytesPerRowY = 0;
-                               }
-
-                               if (src.source_format != dm_444_64 && 
src.source_format != dm_444_32
-                                               && src.source_format != 
dm_444_16) {
-                                       if (src.dcc == 1) {
-                                               v->MetaReqHeightC = 8 * 
v->Read256BlockHeightC[k];
-                                               v->MetaReqWidthC =
-                                                               64 * 256
-                                                                               
/ dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETC[k],
-                                                                               
                2)
-                                                                               
/ v->MetaReqHeightC;
-                                               v->MetaSurfaceWidthC = 
dml_ceil_ex(
-                                                               
src.viewport_width / v->NoOfDPP[ijk]
-                                                                               
/ 2 - 1,
-                                                               
v->MetaReqWidthC)
-                                                               + 
v->MetaReqWidthC;
-                                               v->MetaSurfaceHeightC = 
dml_ceil_ex(
-                                                               
src.viewport_height / 2 - 1,
-                                                               
v->MetaReqHeightC)
-                                                               + 
v->MetaReqHeightC;
-                                               if (ip->pte_enable == 1) {
-                                                       
v->MetaPteBytesPerFrameC =
-                                                                       
(dml_ceil_ex(
-                                                                               
        (v->MetaSurfaceWidthC
-                                                                               
                        * v->MetaSurfaceHeightC
-                                                                               
                        * dml_ceil_ex(
-                                                                               
                                        v->BytePerPixelInDETC[k],
-                                                                               
                                        2)
-                                                                               
                        / 256.0
-                                                                               
                        - 4096)
-                                                                               
                        / 8
-                                                                               
                        / 4096,
-                                                                               
        1) + 1)
-                                                                               
        * 64;
-                                               } else {
-                                                       
v->MetaPteBytesPerFrameC = 0;
-                                               }
-                                               if (src.source_scan == dm_horz) 
{
-                                                       v->MetaRowBytesC =
-                                                                       
v->MetaSurfaceWidthC
-                                                                               
        * v->MetaReqHeightC
-                                                                               
        * dml_ceil_ex(
-                                                                               
                        v->BytePerPixelInDETC[k],
-                                                                               
                        2)
-                                                                               
        / 256;
-                                               } else {
-                                                       v->MetaRowBytesC =
-                                                                       
v->MetaSurfaceHeightC
-                                                                               
        * v->MetaReqWidthC
-                                                                               
        * dml_ceil_ex(
-                                                                               
                        v->BytePerPixelInDETC[k],
-                                                                               
                        2)
-                                                                               
        / 256;
-                                               }
-                                       } else {
-                                               v->MetaPteBytesPerFrameC = 0;
-                                               v->MetaRowBytesC = 0;
-                                       }
-
-                                       if (ip->pte_enable == 1) {
-                                               if (src.sw_mode == 
dm_sw_linear) {
-                                                       
v->MacroTileBlockSizeBytesC = 256;
-                                                       
v->MacroTileBlockHeightC = 1;
-                                               } else if (src.sw_mode == 
dm_sw_4kb_s
-                                                               || src.sw_mode 
== dm_sw_4kb_s_x
-                                                               || src.sw_mode 
== dm_sw_4kb_d
-                                                               || src.sw_mode 
== dm_sw_4kb_d_x) {
-                                                       
v->MacroTileBlockSizeBytesC = 4096;
-                                                       
v->MacroTileBlockHeightC = 4
-                                                                       * 
v->Read256BlockHeightC[k];
-                                               } else if (src.sw_mode == 
dm_sw_64kb_s
-                                                               || src.sw_mode 
== dm_sw_64kb_s_t
-                                                               || src.sw_mode 
== dm_sw_64kb_s_x
-                                                               || src.sw_mode 
== dm_sw_64kb_d
-                                                               || src.sw_mode 
== dm_sw_64kb_d_t
-                                                               || src.sw_mode 
== dm_sw_64kb_d_x) {
-                                                       
v->MacroTileBlockSizeBytesC = 64 * 1024;
-                                                       
v->MacroTileBlockHeightC = 16
-                                                                       * 
v->Read256BlockHeightC[k];
-                                               } else {
-                                                       
v->MacroTileBlockSizeBytesC = 256 * 1024;
-                                                       
v->MacroTileBlockHeightC = 32
-                                                                       * 
v->Read256BlockHeightC[k];
-                                               }
-                                               v->MacroTileBlockWidthC =
-                                                               
v->MacroTileBlockSizeBytesC
-                                                                               
/ dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETC[k],
-                                                                               
                2)
-                                                                               
/ v->MacroTileBlockHeightC;
-                                               if (v->MacroTileBlockSizeBytesC 
<= 65536) {
-                                                       v->DataPTEReqHeightC =
-                                                                       
v->MacroTileBlockHeightC;
-                                               } else {
-                                                       v->DataPTEReqHeightC = 
16
-                                                                       * 
v->Read256BlockHeightC[k];
-                                               }
-                                               v->DataPTEReqWidthC =
-                                                               4096
-                                                                               
/ dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETC[k],
-                                                                               
                2)
-                                                                               
/ v->DataPTEReqHeightC
-                                                                               
* 8;
-                                               if (src.sw_mode == 
dm_sw_linear) {
-                                                       v->DPTEBytesPerRowC =
-                                                                       64
-                                                                               
        * (dml_ceil_ex(
-                                                                               
                        (src.viewport_width
-                                                                               
                                        / v->NoOfDPP[ijk]
-                                                                               
                                        / 2
-                                                                               
                                        * dml_min(
-                                                                               
                                                        128,
-                                                                               
                                                        dml_pow(
-                                                                               
                                                                        2,
-                                                                               
                                                                        
dml_floor_ex(
-                                                                               
                                                                                
        dml_log(
-                                                                               
                                                                                
                        ip->dpte_buffer_size_in_pte_reqs
-                                                                               
                                                                                
                                        * v->DataPTEReqWidthC
-                                                                               
                                                                                
                                        / (src.viewport_width
-                                                                               
                                                                                
                                                        / v->NoOfDPP[ijk]
-                                                                               
                                                                                
                                                        / 2),
-                                                                               
                                                                                
                        2),
-                                                                               
                                                                                
        1)))
-                                                                               
                                        - 1)
-                                                                               
                                        / v->DataPTEReqWidthC,
-                                                                               
                        1)
-                                                                               
                        + 1);
-                                               } else if (src.source_scan == 
dm_horz) {
-                                                       v->DPTEBytesPerRowC =
-                                                                       64
-                                                                               
        * (dml_ceil_ex(
-                                                                               
                        (src.viewport_width
-                                                                               
                                        / v->NoOfDPP[ijk]
-                                                                               
                                        / 2
-                                                                               
                                        - 1)
-                                                                               
                                        / v->DataPTEReqWidthC,
-                                                                               
                        1)
-                                                                               
                        + 1);
-                                               } else {
-                                                       v->DPTEBytesPerRowC =
-                                                                       64
-                                                                               
        * (dml_ceil_ex(
-                                                                               
                        (src.viewport_height
-                                                                               
                                        / 2
-                                                                               
                                        - 1)
-                                                                               
                                        / v->DataPTEReqHeightC,
-                                                                               
                        1)
-                                                                               
                        + 1);
-                                               }
-                                       } else {
-                                               v->DPTEBytesPerRowC = 0;
-                                       }
-                               } else {
-                                       v->DPTEBytesPerRowC = 0;
-                                       v->MetaPteBytesPerFrameC = 0;
-                                       v->MetaRowBytesC = 0;
-                               }
-
-                               v->DPTEBytesPerRow[k] = v->DPTEBytesPerRowY + 
v->DPTEBytesPerRowC;
-                               v->MetaPTEBytesPerFrame[k] = 
v->MetaPteBytesPerFrameY
-                                               + v->MetaPteBytesPerFrameC;
-                               v->MetaRowBytes[k] = v->MetaRowBytesY + 
v->MetaRowBytesC;
-
-                               v->VInitY = (scale_ratio_depth.vscl_ratio + 
scale_taps.vtaps + 1
-                                               + dest.interlaced * 0.5
-                                                               * 
scale_ratio_depth.vscl_ratio)
-                                               / 2.0;
-                               v->PrefillY[k] = dml_floor_ex(v->VInitY, 1);
-                               v->MaxNumSwY[k] = dml_ceil_ex(
-                                               (v->PrefillY[k] - 1.0)
-                                                               / 
v->SwathHeightYPerState[ijk],
-                                               1) + 1.0;
-
-                               if (v->PrefillY[k] > 1) {
-                                       v->MaxPartialSwY = ((int) 
(v->PrefillY[k] - 2))
-                                                       % ((int) 
v->SwathHeightYPerState[ijk]);
-                               } else {
-                                       v->MaxPartialSwY = ((int) 
(v->PrefillY[k]
-                                                       + 
v->SwathHeightYPerState[ijk] - 2))
-                                                       % ((int) 
v->SwathHeightYPerState[ijk]);
-                               }
-                               v->MaxPartialSwY = dml_max(1, v->MaxPartialSwY);
-
-                               v->PrefetchLinesY[k] = v->MaxNumSwY[k]
-                                               * v->SwathHeightYPerState[ijk] 
+ v->MaxPartialSwY;
-
-                               if (src.source_format != dm_444_64 && 
src.source_format != dm_444_32
-                                               && src.source_format != 
dm_444_16) {
-                                       v->VInitC =
-                                                       
(scale_ratio_depth.vscl_ratio / 2
-                                                                       + 
scale_taps.vtaps + 1
-                                                                       + 
dest.interlaced * 0.5
-                                                                               
        * scale_ratio_depth.vscl_ratio
-                                                                               
        / 2) / 2.0;
-                                       v->PrefillC[k] = 
dml_floor_ex(v->VInitC, 1);
-                                       v->MaxNumSwC[k] =
-                                                       dml_ceil_ex(
-                                                                       
(v->PrefillC[k] - 1.0)
-                                                                               
        / v->SwathHeightCPerState[ijk],
-                                                                       1) + 
1.0;
-                                       if (v->PrefillC[k] > 1) {
-                                               v->MaxPartialSwC =
-                                                               ((int) 
(v->PrefillC[k] - 2))
-                                                                               
% ((int) v->SwathHeightCPerState[ijk]);
-                                       } else {
-                                               v->MaxPartialSwC =
-                                                               ((int) 
(v->PrefillC[k]
-                                                                               
+ v->SwathHeightCPerState[ijk]
-                                                                               
- 2))
-                                                                               
% ((int) v->SwathHeightCPerState[ijk]);
-                                       }
-                                       v->MaxPartialSwC = dml_max(1, 
v->MaxPartialSwC);
-
-                                       v->PrefetchLinesC[k] = v->MaxNumSwC[k]
-                                                       * 
v->SwathHeightCPerState[ijk]
-                                                       + v->MaxPartialSwC;
-                               } else {
-                                       v->PrefetchLinesC[k] = 0;
-                               }
-
-                               v->dst_x_after_scaler = 90 * dest.pixel_rate_mhz
-                                               / (v->RequiredDISPCLK[ij] / (j 
+ 1))
-                                               + 42 * dest.pixel_rate_mhz / 
v->RequiredDISPCLK[ij];
-                               if (v->NoOfDPP[ijk] > 1) {
-                                       v->dst_x_after_scaler = 
v->dst_x_after_scaler
-                                                       + dest.recout_width / 
2.0;
-                               }
-
-                               if (dout.output_format == dm_420) {
-                                       v->dst_y_after_scaler = 1;
-                               } else {
-                                       v->dst_y_after_scaler = 0;
-                               }
-
-                               v->TimeCalc = 24 / v->ProjectedDCFCLKDeepSleep;
-
-                               v->VUpdateOffset = dml_ceil_ex(dest.htotal / 4, 
1);
-                               v->TotalRepeaterDelay = 
ip->max_inter_dcn_tile_repeaters
-                                               * (2 / (v->RequiredDISPCLK[ij] 
/ (j + 1))
-                                                               + 3 / 
v->RequiredDISPCLK[ij]);
-                               v->VUpdateWidth = (14 / 
v->ProjectedDCFCLKDeepSleep
-                                               + 12 / (v->RequiredDISPCLK[ij] 
/ (j + 1))
-                                               + v->TotalRepeaterDelay) * 
dest.pixel_rate_mhz;
-                               v->VReadyOffset =
-                                               dml_max(
-                                                               150
-                                                                               
/ (v->RequiredDISPCLK[ij]
-                                                                               
                / (j
-                                                                               
                                + 1)),
-                                                               
v->TotalRepeaterDelay
-                                                                               
+ 20
-                                                                               
                / v->ProjectedDCFCLKDeepSleep
-                                                                               
+ 10
-                                                                               
                / (v->RequiredDISPCLK[ij]
-                                                                               
                                / (j
-                                                                               
                                                + 1)))
-                                                               * 
dest.pixel_rate_mhz;
-
-                               v->TimeSetup =
-                                               (v->VUpdateOffset + 
v->VUpdateWidth
-                                                               + 
v->VReadyOffset)
-                                                               / 
dest.pixel_rate_mhz;
-
-                               v->ExtraLatency =
-                                               
v->UrgentRoundTripAndOutOfOrderLatencyPerState[i]
-                                                               + 
(v->TotalNumberOfActiveDPP[ij]
-                                                                               
* ip->pixel_chunk_size_kbytes
-                                                                               
+ v->TotalNumberOfDCCActiveDPP[ij]
-                                                                               
                * ip->meta_chunk_size_kbytes)
-                                                                               
* 1024
-                                                                               
/ v->ReturnBWPerState[i];
-
-                               if (ip->pte_enable == 1) {
-                                       v->ExtraLatency = v->ExtraLatency
-                                                       + 
v->TotalNumberOfActiveDPP[ij]
-                                                                       * 
ip->pte_chunk_size_kbytes
-                                                                       * 1024
-                                                                       / 
v->ReturnBWPerState[i];
-                               }
-
-                               if 
(ip->can_vstartup_lines_exceed_vsync_plus_back_porch_lines_minus_one
-                                               == 1) {
-                                       v->MaximumVStartup = dest.vtotal - 
dest.vactive - 1;
-                               } else {
-                                       v->MaximumVStartup = 
dest.vsync_plus_back_porch - 1;
-                               }
-
-                               v->LineTimesForPrefetch[k] =
-                                               v->MaximumVStartup
-                                                               - 
soc->urgent_latency_us
-                                                                               
/ (dest.htotal
-                                                                               
                / dest.pixel_rate_mhz)
-                                                               - (v->TimeCalc 
+ v->TimeSetup)
-                                                                               
/ (dest.htotal
-                                                                               
                / dest.pixel_rate_mhz)
-                                                               - 
(v->dst_y_after_scaler
-                                                                               
+ v->dst_x_after_scaler
-                                                                               
                / dest.htotal);
-
-                               v->LineTimesForPrefetch[k] = dml_floor_ex(
-                                               4.0 * 
(v->LineTimesForPrefetch[k] + 0.125),
-                                               1) / 4;
-
-                               v->PrefetchBW[k] =
-                                               (v->MetaPTEBytesPerFrame[k] + 2 
* v->MetaRowBytes[k]
-                                                               + 2 * 
v->DPTEBytesPerRow[k]
-                                                               + 
v->PrefetchLinesY[k]
-                                                                               
* v->SwathWidthYPerState[ijk]
-                                                                               
* dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETY[k],
-                                                                               
                1)
-                                                               + 
v->PrefetchLinesC[k]
-                                                                               
* v->SwathWidthYPerState[ijk]
-                                                                               
/ 2
-                                                                               
* dml_ceil_ex(
-                                                                               
                v->BytePerPixelInDETC[k],
-                                                                               
                2))
-                                                               / 
(v->LineTimesForPrefetch[k]
-                                                                               
* dest.htotal
-                                                                               
/ dest.pixel_rate_mhz);
-                       }
-
-                       v->BWAvailableForImmediateFlip = v->ReturnBWPerState[i];
-
-                       for (k = 0; k < num_planes; k++) {
-                               v->BWAvailableForImmediateFlip = 
v->BWAvailableForImmediateFlip
-                                               - dml_max(v->ReadBandwidth[k], 
v->PrefetchBW[k]);
-                       }
-
-                       v->TotalImmediateFlipBytes = 0;
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-
-                               if (src.source_format != dm_420_8
-                                               && src.source_format != 
dm_420_10) {
-                                       v->TotalImmediateFlipBytes = 
v->TotalImmediateFlipBytes
-                                                       + 
v->MetaPTEBytesPerFrame[k]
-                                                       + v->MetaRowBytes[k]
-                                                       + v->DPTEBytesPerRow[k];
-                               }
-                       }
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (ip->pte_enable == 1 && src.dcc == 1) {
-                                       v->TimeForMetaPTEWithImmediateFlip =
-                                                       dml_max(
-                                                                       
v->MetaPTEBytesPerFrame[k]
-                                                                               
        / v->PrefetchBW[k],
-                                                                       dml_max(
-                                                                               
        v->MetaPTEBytesPerFrame[k]
-                                                                               
                        * v->TotalImmediateFlipBytes
-                                                                               
                        / (v->BWAvailableForImmediateFlip
-                                                                               
                                        * (v->MetaPTEBytesPerFrame[k]
-                                                                               
                                                        + v->MetaRowBytes[k]
-                                                                               
                                                        + 
v->DPTEBytesPerRow[k])),
-                                                                               
        dml_max(
-                                                                               
                        v->ExtraLatency,
-                                                                               
                        dml_max(
-                                                                               
                                        soc->urgent_latency_us,
-                                                                               
                                        dest.htotal
-                                                                               
                                                        / dest.pixel_rate_mhz
-                                                                               
                                                        / 4))));
-
-                                       v->TimeForMetaPTEWithoutImmediateFlip =
-                                                       dml_max(
-                                                                       
v->MetaPTEBytesPerFrame[k]
-                                                                               
        / v->PrefetchBW[k],
-                                                                       dml_max(
-                                                                               
        v->ExtraLatency,
-                                                                               
        dest.htotal
-                                                                               
                        / dest.pixel_rate_mhz
-                                                                               
                        / 4));
-                               } else {
-                                       v->TimeForMetaPTEWithImmediateFlip = 
dest.htotal
-                                                       / dest.pixel_rate_mhz / 
4;
-                                       v->TimeForMetaPTEWithoutImmediateFlip = 
dest.htotal
-                                                       / dest.pixel_rate_mhz / 
4;
-                               }
-
-                               if (ip->pte_enable == 1 || src.dcc == 1) {
-                                       
v->TimeForMetaAndDPTERowWithImmediateFlip =
-                                                       dml_max(
-                                                                       
(v->MetaRowBytes[k]
-                                                                               
        + v->DPTEBytesPerRow[k])
-                                                                               
        / v->PrefetchBW[k],
-                                                                       dml_max(
-                                                                               
        (v->MetaRowBytes[k]
-                                                                               
                        + v->DPTEBytesPerRow[k])
-                                                                               
                        * v->TotalImmediateFlipBytes
-                                                                               
                        / (v->BWAvailableForImmediateFlip
-                                                                               
                                        * (v->MetaPTEBytesPerFrame[k]
-                                                                               
                                                        + v->MetaRowBytes[k]
-                                                                               
                                                        + 
v->DPTEBytesPerRow[k])),
-                                                                               
        dml_max(
-                                                                               
                        dest.htotal
-                                                                               
                                        / dest.pixel_rate_mhz
-                                                                               
                                        - v->TimeForMetaPTEWithImmediateFlip,
-                                                                               
                        dml_max(
-                                                                               
                                        v->ExtraLatency,
-                                                                               
                                        2
-                                                                               
                                                        * 
soc->urgent_latency_us))));
-
-                                       
v->TimeForMetaAndDPTERowWithoutImmediateFlip =
-                                                       dml_max(
-                                                                       
(v->MetaRowBytes[k]
-                                                                               
        + v->DPTEBytesPerRow[k])
-                                                                               
        / v->PrefetchBW[k],
-                                                                       dml_max(
-                                                                               
        dest.htotal
-                                                                               
                        / dest.pixel_rate_mhz
-                                                                               
                        - v->TimeForMetaPTEWithoutImmediateFlip,
-                                                                               
        v->ExtraLatency));
-                               } else {
-                                       
v->TimeForMetaAndDPTERowWithImmediateFlip =
-                                                       dml_max(
-                                                                       
dest.htotal
-                                                                               
        / dest.pixel_rate_mhz
-                                                                               
        - v->TimeForMetaPTEWithImmediateFlip,
-                                                                       
v->ExtraLatency
-                                                                               
        - v->TimeForMetaPTEWithImmediateFlip);
-                                       
v->TimeForMetaAndDPTERowWithoutImmediateFlip =
-                                                       dml_max(
-                                                                       
dest.htotal
-                                                                               
        / dest.pixel_rate_mhz
-                                                                               
        - v->TimeForMetaPTEWithoutImmediateFlip,
-                                                                       
v->ExtraLatency
-                                                                               
        - v->TimeForMetaPTEWithoutImmediateFlip);
-                               }
-
-                               v->LinesForMetaPTEWithImmediateFlip[k] =
-                                               dml_floor_ex(
-                                                               4.0
-                                                                               
* (v->TimeForMetaPTEWithImmediateFlip
-                                                                               
                / (dest.htotal
-                                                                               
                                / dest.pixel_rate_mhz)
-                                                                               
                + 0.125),
-                                                               1) / 4.0;
-
-                               v->LinesForMetaPTEWithoutImmediateFlip[k] =
-                                               dml_floor_ex(
-                                                               4.0
-                                                                               
* (v->TimeForMetaPTEWithoutImmediateFlip
-                                                                               
                / (dest.htotal
-                                                                               
                                / dest.pixel_rate_mhz)
-                                                                               
                + 0.125),
-                                                               1) / 4.0;
-
-                               v->LinesForMetaAndDPTERowWithImmediateFlip[k] =
-                                               dml_floor_ex(
-                                                               4.0
-                                                                               
* (v->TimeForMetaAndDPTERowWithImmediateFlip
-                                                                               
                / (dest.htotal
-                                                                               
                                / dest.pixel_rate_mhz)
-                                                                               
                + 0.125),
-                                                               1) / 4.0;
-
-                               
v->LinesForMetaAndDPTERowWithoutImmediateFlip[k] =
-                                               dml_floor_ex(
-                                                               4.0
-                                                                               
* (v->TimeForMetaAndDPTERowWithoutImmediateFlip
-                                                                               
                / (dest.htotal
-                                                                               
                                / dest.pixel_rate_mhz)
-                                                                               
                + 0.125),
-                                                               1) / 4.0;
-
-                               
v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip =
-                                               v->LineTimesForPrefetch[k]
-                                                               - 
v->LinesForMetaPTEWithImmediateFlip[k]
-                                                               - 
v->LinesForMetaAndDPTERowWithImmediateFlip[k];
-
-                               
v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip =
-                                               v->LineTimesForPrefetch[k]
-                                                               - 
v->LinesForMetaPTEWithoutImmediateFlip[k]
-                                                               - 
v->LinesForMetaAndDPTERowWithoutImmediateFlip[k];
-
-                               if 
(v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip > 0) {
-                                       v->VRatioPreYWithImmediateFlip[ijk] =
-                                                       v->PrefetchLinesY[k]
-                                                                       / 
v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip;
-                                       if (v->SwathHeightYPerState[ijk] > 4) {
-                                               if 
(v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                               - 
(v->PrefillY[k] - 3.0) / 2.0
-                                                               > 0) {
-                                                       
v->VRatioPreYWithImmediateFlip[ijk] =
-                                                                       dml_max(
-                                                                               
        v->VRatioPreYWithImmediateFlip[ijk],
-                                                                               
        (v->MaxNumSwY[k]
-                                                                               
                        * v->SwathHeightYPerState[ijk])
-                                                                               
                        / 
(v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                                               
                                        - (v->PrefillY[k]
-                                                                               
                                                        - 3.0)
-                                                                               
                                                        / 2.0));
-                                               } else {
-                                                       
v->VRatioPreYWithImmediateFlip[ijk] =
-                                                                       999999;
-                                               }
-                                       }
-                                       v->VRatioPreCWithImmediateFlip[ijk] =
-                                                       v->PrefetchLinesC[k]
-                                                                       / 
v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip;
-                                       if (v->SwathHeightCPerState[ijk] > 4) {
-                                               if 
(v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                               - 
(v->PrefillC[k] - 3.0) / 2.0
-                                                               > 0) {
-                                                       
v->VRatioPreCWithImmediateFlip[ijk] =
-                                                                       dml_max(
-                                                                               
        v->VRatioPreCWithImmediateFlip[ijk],
-                                                                               
        (v->MaxNumSwC[k]
-                                                                               
                        * v->SwathHeightCPerState[ijk])
-                                                                               
                        / 
(v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                                               
                                        - (v->PrefillC[k]
-                                                                               
                                                        - 3.0)
-                                                                               
                                                        / 2.0));
-                                               } else {
-                                                       
v->VRatioPreCWithImmediateFlip[ijk] =
-                                                                       999999;
-                                               }
-                                       }
-
-                                       
v->RequiredPrefetchPixelDataBWWithImmediateFlip[ijk] =
-                                                       v->NoOfDPP[ijk]
-                                                                       * 
(v->PrefetchLinesY[k]
-                                                                               
        / v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                                               
        * dml_ceil_ex(
-                                                                               
                        v->BytePerPixelInDETY[k],
-                                                                               
                        1)
-                                                                               
        + v->PrefetchLinesC[k]
-                                                                               
                        / 
v->LineTimesToRequestPrefetchPixelDataWithImmediateFlip
-                                                                               
                        * dml_ceil_ex(
-                                                                               
                                        v->BytePerPixelInDETC[k],
-                                                                               
                                        2)
-                                                                               
                        / 2)
-                                                                       * 
v->SwathWidthYPerState[ijk]
-                                                                       / 
(dest.htotal
-                                                                               
        / dest.pixel_rate_mhz);
-                               } else {
-                                       v->VRatioPreYWithImmediateFlip[ijk] = 
999999;
-                                       v->VRatioPreCWithImmediateFlip[ijk] = 
999999;
-                                       
v->RequiredPrefetchPixelDataBWWithImmediateFlip[ijk] =
-                                                       999999;
-                               }
-
-                               if 
(v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                               > 0) {
-                                       v->VRatioPreYWithoutImmediateFlip[ijk] =
-                                                       v->PrefetchLinesY[k]
-                                                                       / 
v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip;
-                                       if (v->SwathHeightYPerState[ijk] > 4) {
-                                               if 
(v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                               - 
(v->PrefillY[k] - 3.0) / 2.0
-                                                               > 0) {
-                                                       
v->VRatioPreYWithoutImmediateFlip[ijk] =
-                                                                       dml_max(
-                                                                               
        v->VRatioPreYWithoutImmediateFlip[ijk],
-                                                                               
        (v->MaxNumSwY[k]
-                                                                               
                        * v->SwathHeightYPerState[ijk])
-                                                                               
                        / 
(v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                                               
                                        - (v->PrefillY[k]
-                                                                               
                                                        - 3.0)
-                                                                               
                                                        / 2.0));
-                                               } else {
-                                                       
v->VRatioPreYWithoutImmediateFlip[ijk] =
-                                                                       999999;
-                                               }
-                                       }
-                                       v->VRatioPreCWithoutImmediateFlip[ijk] =
-                                                       v->PrefetchLinesC[k]
-                                                                       / 
v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip;
-                                       if (v->SwathHeightCPerState[ijk] > 4) {
-                                               if 
(v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                               - 
(v->PrefillC[k] - 3.0) / 2.0
-                                                               > 0) {
-                                                       
v->VRatioPreCWithoutImmediateFlip[ijk] =
-                                                                       dml_max(
-                                                                               
        v->VRatioPreCWithoutImmediateFlip[ijk],
-                                                                               
        (v->MaxNumSwC[k]
-                                                                               
                        * v->SwathHeightCPerState[ijk])
-                                                                               
                        / 
(v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                                               
                                        - (v->PrefillC[k]
-                                                                               
                                                        - 3.0)
-                                                                               
                                                        / 2.0));
-                                               } else {
-                                                       
v->VRatioPreCWithoutImmediateFlip[ijk] =
-                                                                       999999;
-                                               }
-                                       }
-
-                                       
v->RequiredPrefetchPixelDataBWWithoutImmediateFlip[ijk] =
-                                                       v->NoOfDPP[ijk]
-                                                                       * 
(v->PrefetchLinesY[k]
-                                                                               
        / v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                                               
        * dml_ceil_ex(
-                                                                               
                        v->BytePerPixelInDETY[k],
-                                                                               
                        1)
-                                                                               
        + v->PrefetchLinesC[k]
-                                                                               
                        / 
v->LineTimesToRequestPrefetchPixelDataWithoutImmediateFlip
-                                                                               
                        * dml_ceil_ex(
-                                                                               
                                        v->BytePerPixelInDETC[k],
-                                                                               
                                        2)
-                                                                               
                        / 2)
-                                                                       * 
v->SwathWidthYPerState[ijk]
-                                                                       / 
(dest.htotal
-                                                                               
        / dest.pixel_rate_mhz);
-                               } else {
-                                       v->VRatioPreYWithoutImmediateFlip[ijk] 
= 999999;
-                                       v->VRatioPreCWithoutImmediateFlip[ijk] 
= 999999;
-                                       
v->RequiredPrefetchPixelDataBWWithoutImmediateFlip[ijk] =
-                                                       999999;
-                               }
-                       }
-
-                       v->MaximumReadBandwidthWithPrefetchWithImmediateFlip = 
0;
-
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               struct _vcs_dpi_display_pipe_dest_params_st 
dest =
-                                               
e2e[v->planes[k].e2e_index].pipe.dest;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (src.source_format != dm_420_8
-                                               && src.source_format != 
dm_420_10) {
-                                       
v->MaximumReadBandwidthWithPrefetchWithImmediateFlip =
-                                                       
v->MaximumReadBandwidthWithPrefetchWithImmediateFlip
-                                                                       + 
dml_max(
-                                                                               
        v->ReadBandwidth[k],
-                                                                               
        v->RequiredPrefetchPixelDataBWWithImmediateFlip[ijk])
-                                                                       + 
dml_max(
-                                                                               
        v->MetaPTEBytesPerFrame[k]
-                                                                               
                        / (v->LinesForMetaPTEWithImmediateFlip[k]
-                                                                               
                                        * dest.htotal
-                                                                               
                                        / dest.pixel_rate_mhz),
-                                                                               
        (v->MetaRowBytes[k]
-                                                                               
                        + v->DPTEBytesPerRow[k])
-                                                                               
                        / (v->LinesForMetaAndDPTERowWithImmediateFlip[k]
-                                                                               
                                        * dest.htotal
-                                                                               
                                        / dest.pixel_rate_mhz));
-                               } else {
-                                       
v->MaximumReadBandwidthWithPrefetchWithImmediateFlip =
-                                                       
v->MaximumReadBandwidthWithPrefetchWithImmediateFlip
-                                                                       + 
dml_max(
-                                                                               
        v->ReadBandwidth[k],
-                                                                               
        v->RequiredPrefetchPixelDataBWWithoutImmediateFlip[ijk]);
-                               }
-                       }
-
-                       v->MaximumReadBandwidthWithPrefetchWithoutImmediateFlip 
= 0;
-
-                       for (k = 0; k < num_planes; k++) {
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               
v->MaximumReadBandwidthWithPrefetchWithoutImmediateFlip =
-                                               
v->MaximumReadBandwidthWithPrefetchWithoutImmediateFlip
-                                                               + dml_max(
-                                                                               
v->ReadBandwidth[k],
-                                                                               
v->RequiredPrefetchPixelDataBWWithoutImmediateFlip[ijk]);
-                       }
-
-                       v->PrefetchSupportedWithImmediateFlip[ij] = 1;
-                       if (v->MaximumReadBandwidthWithPrefetchWithImmediateFlip
-                                       > v->ReturnBWPerState[i]) {
-                               v->PrefetchSupportedWithImmediateFlip[ij] = 0;
-                       }
-                       for (k = 0; k < num_planes; k++) {
-                               if (v->LineTimesForPrefetch[k] < 2
-                                               || 
v->LinesForMetaPTEWithImmediateFlip[k] >= 8
-                                               || 
v->LinesForMetaAndDPTERowWithImmediateFlip[k]
-                                                               >= 16) {
-                                       
v->PrefetchSupportedWithImmediateFlip[ij] = 0;
-                               }
-                       }
-
-                       v->PrefetchSupportedWithoutImmediateFlip[ij] = 1;
-                       if 
(v->MaximumReadBandwidthWithPrefetchWithoutImmediateFlip
-                                       > v->ReturnBWPerState[i]) {
-                               v->PrefetchSupportedWithoutImmediateFlip[ij] = 
0;
-                       }
-                       for (k = 0; k < num_planes; k++) {
-                               if (v->LineTimesForPrefetch[k] < 2
-                                               || 
v->LinesForMetaPTEWithoutImmediateFlip[k] >= 8
-                                               || 
v->LinesForMetaAndDPTERowWithoutImmediateFlip[k]
-                                                               >= 16) {
-                                       
v->PrefetchSupportedWithoutImmediateFlip[ij] = 0;
-                               }
-                       }
-               }
-       }
-
-       for (i = 0; i < NumberOfStatesPlusTwo; i++) {
-               for (j = 0; j < 2; j++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-
-                       v->VRatioInPrefetchSupportedWithImmediateFlip[ij] = 1;
-                       for (k = 0; k < num_planes; k++) {
-                               struct _vcs_dpi_display_pipe_source_params_st 
src =
-                                               
e2e[v->planes[k].e2e_index].pipe.src;
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (((src.source_format != dm_420_8
-                                               && src.source_format != 
dm_420_10)
-                                               && 
(v->VRatioPreYWithImmediateFlip[ijk] > 4
-                                                               || 
v->VRatioPreCWithImmediateFlip[ijk]
-                                                                               
> 4))
-                                               || ((src.source_format == 
dm_420_8
-                                                               || 
src.source_format == dm_420_10)
-                                                               && 
(v->VRatioPreYWithoutImmediateFlip[ijk]
-                                                                               
> 4
-                                                                               
|| v->VRatioPreCWithoutImmediateFlip[ijk]
-                                                                               
                > 4))) {
-                                       
v->VRatioInPrefetchSupportedWithImmediateFlip[ij] = 0;
-                               }
-                       }
-                       v->VRatioInPrefetchSupportedWithoutImmediateFlip[ij] = 
1;
-                       for (k = 0; k < num_planes; k++) {
-                               ijk = k * 2 * NumberOfStatesPlusTwo + j * 
NumberOfStatesPlusTwo + i;
-
-                               if (v->VRatioPreYWithoutImmediateFlip[ijk] > 4
-                                               || 
v->VRatioPreCWithoutImmediateFlip[ijk] > 4) {
-                                       
v->VRatioInPrefetchSupportedWithoutImmediateFlip[ij] = 0;
-                               }
-                       }
-               }
-       }
-
-       // Mode Support, Voltage State and SOC Configuration
-
-       for (i = (NumberOfStatesPlusTwo - 1); i >= 0; i--) // use int type here
-                       {
-               for (j = 0; j < 2; j++) {
-                       ij = j * NumberOfStatesPlusTwo + i;
-
-                       if (v->ScaleRatioSupport == 1 && 
v->SourceFormatPixelAndScanSupport == 1
-                                       && v->ViewportSizeSupport == 1
-                                       && v->BandwidthSupport[i] == 1 && 
v->DIOSupport[i] == 1
-                                       && v->UrgentLatencySupport[ij] == 1 && 
v->ROBSupport[i] == 1
-                                       && v->DISPCLK_DPPCLK_Support[ij] == 1
-                                       && v->TotalAvailablePipesSupport[ij] == 
1
-                                       && v->TotalAvailableWritebackSupport == 
1
-                                       && v->WritebackLatencySupport == 1) {
-                               if (v->PrefetchSupportedWithImmediateFlip[ij] 
== 1
-                                               && 
v->VRatioInPrefetchSupportedWithImmediateFlip[ij]
-                                                               == 1) {
-                                       v->ModeSupportWithImmediateFlip[ij] = 1;
-                               } else {
-                                       v->ModeSupportWithImmediateFlip[ij] = 0;
-                               }
-                               if 
(v->PrefetchSupportedWithoutImmediateFlip[ij] == 1
-                                               && 
v->VRatioInPrefetchSupportedWithoutImmediateFlip[ij]
-                                                               == 1) {
-                                       v->ModeSupportWithoutImmediateFlip[ij] 
= 1;
-                               } else {
-                                       v->ModeSupportWithoutImmediateFlip[ij] 
= 0;
-                               }
-                       } else {
-                               v->ModeSupportWithImmediateFlip[ij] = 0;
-                               v->ModeSupportWithoutImmediateFlip[ij] = 0;
-                       }
-               }
-       }
-
-       for (i = (NumberOfStatesPlusTwo - 1); i >= 0; i--) // use int type here
-                       {
-               if ((i == (NumberOfStatesPlusTwo - 1)
-                               || v->ModeSupportWithImmediateFlip[1 * 
NumberOfStatesPlusTwo + i]
-                                               == 1
-                               || v->ModeSupportWithImmediateFlip[0 * 
NumberOfStatesPlusTwo + i]
-                                               == 1) && i >= 
v->VoltageOverrideLevel) {
-                       v->VoltageLevelWithImmediateFlip = i;
-               }
-       }
-
-       for (i = (NumberOfStatesPlusTwo - 1); i >= 0; i--) // use int type here
-                       {
-               if ((i == (NumberOfStatesPlusTwo - 1)
-                               || v->ModeSupportWithoutImmediateFlip[1 * 
NumberOfStatesPlusTwo + i]
-                                               == 1
-                               || v->ModeSupportWithoutImmediateFlip[0 * 
NumberOfStatesPlusTwo + i]
-                                               == 1) && i >= 
v->VoltageOverrideLevel) {
-                       v->VoltageLevelWithoutImmediateFlip = i;
-               }
-       }
-
-       if (v->VoltageLevelWithImmediateFlip == (NumberOfStatesPlusTwo - 1)) {
-               v->ImmediateFlipSupported = 0;
-               v->VoltageLevel = v->VoltageLevelWithoutImmediateFlip;
-       } else {
-               v->ImmediateFlipSupported = 1;
-               v->VoltageLevel = v->VoltageLevelWithImmediateFlip;
-       }
-
-       v->DCFCLK = v->DCFCLKPerState[(int) v->VoltageLevel];
-       v->FabricAndDRAMBandwidth = v->FabricAndDRAMBandwidthPerState[(int) 
v->VoltageLevel];
-
-       for (j = 0; j < 2; j++) {
-               v->RequiredDISPCLKPerRatio[j] = v->RequiredDISPCLK[j * 
NumberOfStatesPlusTwo
-                               + (int) v->VoltageLevel];
-               for (k = 0; k < num_planes; k++) {
-                       v->DPPPerPlanePerRatio[k * 2 + j] = v->NoOfDPP[k * 2 * 
NumberOfStatesPlusTwo
-                                       + j * NumberOfStatesPlusTwo + (int) 
v->VoltageLevel];
-               }
-               v->DISPCLK_DPPCLK_SupportPerRatio[j] = 
v->DISPCLK_DPPCLK_Support[j
-                               * NumberOfStatesPlusTwo + (int) 
v->VoltageLevel];
-       }
-
-       ASSERT(v->ImmediateFlipSupported || v->MacroTileBlockWidthC || 
v->DCFCLK || v->FabricAndDRAMBandwidth);
-
-       return (v->VoltageLevel);
-}
-
diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.h 
b/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.h
index ead4942..d4ea037 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.h
+++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_support.h
@@ -191,9 +191,4 @@ struct dml_ms_internal_vars {
        struct _vcs_dpi_wm_calc_pipe_params_st planes[DC__NUM_PIPES__MAX];
 };
 
-int dml_ms_check(
-               struct display_mode_lib *mode_lib,
-               struct _vcs_dpi_display_e2e_pipe_params_st *e2e,
-               int num_pipes);
-
 #endif
-- 
2.9.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

Reply via email to