diff options
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71/2514-drm-amd-display-add-mode-support-check-to-dml-vba-co.patch')
| -rw-r--r-- | meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71/2514-drm-amd-display-add-mode-support-check-to-dml-vba-co.patch | 7506 |
1 files changed, 7506 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71/2514-drm-amd-display-add-mode-support-check-to-dml-vba-co.patch b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71/2514-drm-amd-display-add-mode-support-check-to-dml-vba-co.patch new file mode 100644 index 00000000..421eb69b --- /dev/null +++ b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.14.71/2514-drm-amd-display-add-mode-support-check-to-dml-vba-co.patch @@ -0,0 +1,7506 @@ +From 01d4ec839c188de78fa624db8f486791bcdbc0ea Mon Sep 17 00:00:00 2001 +From: Dmytro Laktyushkin <Dmytro.Laktyushkin@amd.com> +Date: Fri, 15 Sep 2017 16:03:09 -0400 +Subject: [PATCH 2514/4131] drm/amd/display: add mode support check to dml vba + code + +Signed-off-by: Dmytro Laktyushkin <Dmytro.Laktyushkin@amd.com> +Reviewed-by: Tony Cheng <Tony.Cheng@amd.com> +Acked-by: Harry Wentland <Harry.Wentland@amd.com> +--- + .../drm/amd/display/dc/dml/display_mode_enums.h | 10 +- + .../drm/amd/display/dc/dml/display_mode_structs.h | 5 + + .../gpu/drm/amd/display/dc/dml/display_mode_vba.c | 5701 +++++++++++++++----- + .../gpu/drm/amd/display/dc/dml/display_mode_vba.h | 456 +- + .../gpu/drm/amd/display/dc/dml/dml_common_defs.c | 12 + + .../gpu/drm/amd/display/dc/dml/dml_common_defs.h | 3 + + 6 files changed, 4604 insertions(+), 1583 deletions(-) + +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_enums.h b/drivers/gpu/drm/amd/display/dc/dml/display_mode_enums.h +index eebaeb1..b1ad355 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_enums.h ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_enums.h +@@ -26,7 +26,7 @@ + #define __DISPLAY_MODE_ENUMS_H__ + + enum output_encoder_class { +- dm_dp = 0, dm_hdmi = 1, dm_wb = 2 ++ dm_dp = 0, dm_hdmi = 1, dm_wb = 2, dm_edp + }; + enum output_format_class { + dm_444 = 0, dm_420 = 1, dm_n422, dm_s422 +@@ -39,7 +39,9 @@ enum source_format_class { + dm_420_10 = 4, + dm_422_8 = 5, + dm_422_10 = 6, +- dm_444_8 = 7 ++ dm_444_8 = 7, ++ dm_mono_8, ++ dm_mono_16 + }; + enum output_bpc_class { + dm_out_6 = 0, dm_out_8 = 1, dm_out_10 = 2, dm_out_12 = 3, dm_out_16 = 4 +@@ -79,7 +81,9 @@ enum dm_swizzle_mode { + dm_sw_SPARE_15 = 28, + dm_sw_var_s_x = 29, + dm_sw_var_d_x = 30, +- dm_sw_64kb_r_x ++ dm_sw_64kb_r_x, ++ dm_sw_gfx7_2d_thin_lvp, ++ dm_sw_gfx7_2d_thin_gl + }; + enum lb_depth { + dm_lb_10 = 0, dm_lb_8 = 1, dm_lb_6 = 2, dm_lb_12 = 3, dm_lb_16 +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h b/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h +index e5b7f70..27e2046 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h +@@ -66,6 +66,7 @@ struct _vcs_dpi_mode_evaluation_st { + + struct _vcs_dpi_voltage_scaling_st { + int state; ++ double dscclk_mhz; + double dcfclk_mhz; + double socclk_mhz; + double dram_speed_mhz; +@@ -131,6 +132,9 @@ struct _vcs_dpi_ip_params_st { + unsigned int writeback_chroma_line_buffer_width_pixels; + unsigned int max_page_table_levels; + unsigned int max_num_dpp; ++ unsigned int max_num_otg; ++ unsigned int cursor_chunk_size; ++ unsigned int cursor_buffer_size; + unsigned int max_num_wb; + unsigned int max_dchub_pscl_bw_pix_per_clk; + unsigned int max_pscl_lb_bw_pix_per_clk; +@@ -224,6 +228,7 @@ struct writeback_st { + }; + + struct _vcs_dpi_display_output_params_st { ++ int dp_lanes; + int output_bpp; + int dsc_enable; + int wb_enable; +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c +index ada0eee..e1a3182 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c +@@ -6,202 +6,220 @@ static const unsigned int NumberOfStates = DC__VOLTAGE_STATES; + static void fetch_socbb_params(struct display_mode_lib *mode_lib); + static void fetch_ip_params(struct display_mode_lib *mode_lib); + static void fetch_pipe_params(struct display_mode_lib *mode_lib); +-static void recalculate_params(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes); ++static void recalculate_params( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes); + static void recalculate(struct display_mode_lib *mode_lib); +-static double adjust_ReturnBW(struct display_mode_lib *mode_lib, double ReturnBW, bool DCCEnabledAnyPlane, double ReturnBandwidthToDCN); ++static double adjust_ReturnBW( ++ struct display_mode_lib *mode_lib, ++ double ReturnBW, ++ bool DCCEnabledAnyPlane, ++ double ReturnBandwidthToDCN); + static void ModeSupportAndSystemConfiguration(struct display_mode_lib *mode_lib); + static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib); +-static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(struct display_mode_lib *mode_lib); +-static unsigned int dscceComputeDelay(unsigned int bpc, +- double bpp, +- unsigned int sliceWidth, +- unsigned int numSlices, +- enum output_format_class pixelFormat); ++static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation( ++ struct display_mode_lib *mode_lib); ++static unsigned int dscceComputeDelay( ++ unsigned int bpc, ++ double bpp, ++ unsigned int sliceWidth, ++ unsigned int numSlices, ++ enum output_format_class pixelFormat); + static unsigned int dscComputeDelay(enum output_format_class pixelFormat); + // Super monster function with some 45 argument +-static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, +- double DPPCLK, +- double DISPCLK, +- double PixelClock, +- double DCFClkDeepSleep, +- unsigned int DSCDelay, +- unsigned int DPPPerPlane, +- bool ScalerEnabled, +- unsigned int NumberOfCursors, +- double DPPCLKDelaySubtotal, +- double DPPCLKDelaySCL, +- double DPPCLKDelaySCLLBOnly, +- double DPPCLKDelayCNVCFormater, +- double DPPCLKDelayCNVCCursor, +- double DISPCLKDelaySubtotal, +- unsigned int ScalerRecoutWidth, +- enum output_format_class OutputFormat, +- unsigned int VBlank, +- unsigned int HTotal, +- unsigned int MaxInterDCNTileRepeaters, +- unsigned int VStartup, +- unsigned int PageTableLevels, +- bool VirtualMemoryEnable, +- bool DynamicMetadataEnable, +- unsigned int DynamicMetadataLinesBeforeActiveRequired, +- unsigned int DynamicMetadataTransmittedBytes, +- bool DCCEnable, +- double UrgentLatency, +- double UrgentExtraLatency, +- double TCalc, +- unsigned int PDEAndMetaPTEBytesFrame, +- unsigned int MetaRowByte, +- unsigned int PixelPTEBytesPerRow, +- double PrefetchSourceLinesY, +- unsigned int SwathWidthY, +- double BytePerPixelDETY, +- double VInitPreFillY, +- unsigned int MaxNumSwathY, +- double PrefetchSourceLinesC, +- double BytePerPixelDETC, +- double VInitPreFillC, +- unsigned int MaxNumSwathC, +- unsigned int SwathHeightY, +- unsigned int SwathHeightC, +- double TWait, +- bool XFCEnabled, +- double XFCRemoteSurfaceFlipDelay, +- bool InterlaceEnable, +- bool ProgressiveToInterlaceUnitInOPP, +- double *DSTXAfterScaler, +- double *DSTYAfterScaler, +- double *DestinationLinesForPrefetch, +- double *PrefetchBandwidth, +- double *DestinationLinesToRequestVMInVBlank, +- double *DestinationLinesToRequestRowInVBlank, +- double *VRatioPrefetchY, +- double *VRatioPrefetchC, +- double *RequiredPrefetchPixDataBW, +- unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, +- double *Tno_bw); +-static double CeilToDFSGranularity(double Clock, double VCOSpeed); +-static double FloorToDFSGranularity(double Clock, double VCOSpeed); +-static double CalculatePrefetchSourceLines(struct display_mode_lib *mode_lib, +- double VRatio, +- double vtaps, +- bool Interlace, +- bool ProgressiveToInterlaceUnitInOPP, +- unsigned int SwathHeight, +- unsigned int ViewportYStart, +- double *VInitPreFill, +- unsigned int *MaxNumSwath); +-static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, +- bool DCCEnable, +- unsigned int BlockHeight256Bytes, +- unsigned int BlockWidth256Bytes, +- enum source_format_class SourcePixelFormat, +- unsigned int SurfaceTiling, +- unsigned int BytePerPixel, +- enum scan_direction_class ScanDirection, +- unsigned int ViewportWidth, +- unsigned int ViewportHeight, +- unsigned int SwathWidthY, +- bool VirtualMemoryEnable, +- unsigned int VMMPageSize, +- unsigned int PTEBufferSizeInRequests, +- unsigned int PDEProcessingBufIn64KBReqs, +- unsigned int Pitch, +- unsigned int DCCMetaPitch, +- unsigned int *MacroTileWidth, +- unsigned int *MetaRowByte, +- unsigned int *PixelPTEBytesPerRow, +- bool *PTEBufferSizeNotExceeded, +- unsigned int *dpte_row_height, +- unsigned int *meta_row_height); +-static double CalculateTWait(unsigned int PrefetchMode, +- double DRAMClockChangeLatency, +- double UrgentLatency, +- double SREnterPlusExitTime); +-static double CalculateRemoteSurfaceFlipDelay(struct display_mode_lib *mode_lib, +- double VRatio, +- double SwathWidth, +- double Bpp, +- double LineTime, +- double XFCTSlvVupdateOffset, +- double XFCTSlvVupdateWidth, +- double XFCTSlvVreadyOffset, +- double XFCXBUFLatencyTolerance, +- double XFCFillBWOverhead, +- double XFCSlvChunkSize, +- double XFCBusTransportTime, +- double TCalc, +- double TWait, +- double *SrcActiveDrainRate, +- double *TInitXFill, +- double *TslvChk); +-static double CalculateWriteBackDISPCLK(enum source_format_class WritebackPixelFormat, +- double PixelClock, +- double WritebackHRatio, +- double WritebackVRatio, +- unsigned int WritebackLumaHTaps, +- unsigned int WritebackLumaVTaps, +- unsigned int WritebackChromaHTaps, +- unsigned int WritebackChromaVTaps, +- double WritebackDestinationWidth, +- unsigned int HTotal, +- unsigned int WritebackChromaLineBufferWidth); +-static void CalculateActiveRowBandwidth(bool VirtualMemoryEnable, +- enum source_format_class SourcePixelFormat, +- double VRatio, +- bool DCCEnable, +- double LineTime, +- unsigned int MetaRowByteLuma, +- unsigned int MetaRowByteChroma, +- unsigned int meta_row_height_luma, +- unsigned int meta_row_height_chroma, +- unsigned int PixelPTEBytesPerRowLuma, +- unsigned int PixelPTEBytesPerRowChroma, +- unsigned int dpte_row_height_luma, +- unsigned int dpte_row_height_chroma, +- double *meta_row_bw, +- double *dpte_row_bw, +- double *qual_row_bw); +-static void CalculateFlipSchedule(struct display_mode_lib *mode_lib, +- double UrgentExtraLatency, +- double UrgentLatency, +- unsigned int MaxPageTableLevels, +- bool VirtualMemoryEnable, +- double BandwidthAvailableForImmediateFlip, +- unsigned int TotImmediateFlipBytes, +- enum source_format_class SourcePixelFormat, +- unsigned int ImmediateFlipBytes, +- double LineTime, +- double Tno_bw, +- double VRatio, +- double PDEAndMetaPTEBytesFrame, +- unsigned int MetaRowByte, +- unsigned int PixelPTEBytesPerRow, +- bool DCCEnable, +- unsigned int dpte_row_height, +- unsigned int meta_row_height, +- double qual_row_bw, +- double *DestinationLinesToRequestVMInImmediateFlip, +- double *DestinationLinesToRequestRowInImmediateFlip, +- double *final_flip_bw, +- bool *ImmediateFlipSupportedForPipe); +-static double CalculateWriteBackDelay(enum source_format_class WritebackPixelFormat, +- double WritebackHRatio, +- double WritebackVRatio, +- unsigned int WritebackLumaHTaps, +- unsigned int WritebackLumaVTaps, +- unsigned int WritebackChromaHTaps, +- unsigned int WritebackChromaVTaps, +- unsigned int WritebackDestinationWidth); ++static bool CalculatePrefetchSchedule( ++ struct display_mode_lib *mode_lib, ++ double DPPCLK, ++ double DISPCLK, ++ double PixelClock, ++ double DCFClkDeepSleep, ++ unsigned int DSCDelay, ++ unsigned int DPPPerPlane, ++ bool ScalerEnabled, ++ unsigned int NumberOfCursors, ++ double DPPCLKDelaySubtotal, ++ double DPPCLKDelaySCL, ++ double DPPCLKDelaySCLLBOnly, ++ double DPPCLKDelayCNVCFormater, ++ double DPPCLKDelayCNVCCursor, ++ double DISPCLKDelaySubtotal, ++ unsigned int ScalerRecoutWidth, ++ enum output_format_class OutputFormat, ++ unsigned int VBlank, ++ unsigned int HTotal, ++ unsigned int MaxInterDCNTileRepeaters, ++ unsigned int VStartup, ++ unsigned int PageTableLevels, ++ bool VirtualMemoryEnable, ++ bool DynamicMetadataEnable, ++ unsigned int DynamicMetadataLinesBeforeActiveRequired, ++ unsigned int DynamicMetadataTransmittedBytes, ++ bool DCCEnable, ++ double UrgentLatency, ++ double UrgentExtraLatency, ++ double TCalc, ++ unsigned int PDEAndMetaPTEBytesFrame, ++ unsigned int MetaRowByte, ++ unsigned int PixelPTEBytesPerRow, ++ double PrefetchSourceLinesY, ++ unsigned int SwathWidthY, ++ double BytePerPixelDETY, ++ double VInitPreFillY, ++ unsigned int MaxNumSwathY, ++ double PrefetchSourceLinesC, ++ double BytePerPixelDETC, ++ double VInitPreFillC, ++ unsigned int MaxNumSwathC, ++ unsigned int SwathHeightY, ++ unsigned int SwathHeightC, ++ double TWait, ++ bool XFCEnabled, ++ double XFCRemoteSurfaceFlipDelay, ++ bool InterlaceEnable, ++ bool ProgressiveToInterlaceUnitInOPP, ++ double *DSTXAfterScaler, ++ double *DSTYAfterScaler, ++ double *DestinationLinesForPrefetch, ++ double *PrefetchBandwidth, ++ double *DestinationLinesToRequestVMInVBlank, ++ double *DestinationLinesToRequestRowInVBlank, ++ double *VRatioPrefetchY, ++ double *VRatioPrefetchC, ++ double *RequiredPrefetchPixDataBW, ++ unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, ++ double *Tno_bw); ++static double RoundToDFSGranularityUp(double Clock, double VCOSpeed); ++static double RoundToDFSGranularityDown(double Clock, double VCOSpeed); ++static double CalculatePrefetchSourceLines( ++ struct display_mode_lib *mode_lib, ++ double VRatio, ++ double vtaps, ++ bool Interlace, ++ bool ProgressiveToInterlaceUnitInOPP, ++ unsigned int SwathHeight, ++ unsigned int ViewportYStart, ++ double *VInitPreFill, ++ unsigned int *MaxNumSwath); ++static unsigned int CalculateVMAndRowBytes( ++ struct display_mode_lib *mode_lib, ++ bool DCCEnable, ++ unsigned int BlockHeight256Bytes, ++ unsigned int BlockWidth256Bytes, ++ enum source_format_class SourcePixelFormat, ++ unsigned int SurfaceTiling, ++ unsigned int BytePerPixel, ++ enum scan_direction_class ScanDirection, ++ unsigned int ViewportWidth, ++ unsigned int ViewportHeight, ++ unsigned int SwathWidthY, ++ bool VirtualMemoryEnable, ++ unsigned int VMMPageSize, ++ unsigned int PTEBufferSizeInRequests, ++ unsigned int PDEProcessingBufIn64KBReqs, ++ unsigned int Pitch, ++ unsigned int DCCMetaPitch, ++ unsigned int *MacroTileWidth, ++ unsigned int *MetaRowByte, ++ unsigned int *PixelPTEBytesPerRow, ++ bool *PTEBufferSizeNotExceeded, ++ unsigned int *dpte_row_height, ++ unsigned int *meta_row_height); ++static double CalculateTWait( ++ unsigned int PrefetchMode, ++ double DRAMClockChangeLatency, ++ double UrgentLatency, ++ double SREnterPlusExitTime); ++static double CalculateRemoteSurfaceFlipDelay( ++ struct display_mode_lib *mode_lib, ++ double VRatio, ++ double SwathWidth, ++ double Bpp, ++ double LineTime, ++ double XFCTSlvVupdateOffset, ++ double XFCTSlvVupdateWidth, ++ double XFCTSlvVreadyOffset, ++ double XFCXBUFLatencyTolerance, ++ double XFCFillBWOverhead, ++ double XFCSlvChunkSize, ++ double XFCBusTransportTime, ++ double TCalc, ++ double TWait, ++ double *SrcActiveDrainRate, ++ double *TInitXFill, ++ double *TslvChk); ++static double CalculateWriteBackDISPCLK( ++ enum source_format_class WritebackPixelFormat, ++ double PixelClock, ++ double WritebackHRatio, ++ double WritebackVRatio, ++ unsigned int WritebackLumaHTaps, ++ unsigned int WritebackLumaVTaps, ++ unsigned int WritebackChromaHTaps, ++ unsigned int WritebackChromaVTaps, ++ double WritebackDestinationWidth, ++ unsigned int HTotal, ++ unsigned int WritebackChromaLineBufferWidth); ++static void CalculateActiveRowBandwidth( ++ bool VirtualMemoryEnable, ++ enum source_format_class SourcePixelFormat, ++ double VRatio, ++ bool DCCEnable, ++ double LineTime, ++ unsigned int MetaRowByteLuma, ++ unsigned int MetaRowByteChroma, ++ unsigned int meta_row_height_luma, ++ unsigned int meta_row_height_chroma, ++ unsigned int PixelPTEBytesPerRowLuma, ++ unsigned int PixelPTEBytesPerRowChroma, ++ unsigned int dpte_row_height_luma, ++ unsigned int dpte_row_height_chroma, ++ double *meta_row_bw, ++ double *dpte_row_bw, ++ double *qual_row_bw); ++static void CalculateFlipSchedule( ++ struct display_mode_lib *mode_lib, ++ double UrgentExtraLatency, ++ double UrgentLatency, ++ unsigned int MaxPageTableLevels, ++ bool VirtualMemoryEnable, ++ double BandwidthAvailableForImmediateFlip, ++ unsigned int TotImmediateFlipBytes, ++ enum source_format_class SourcePixelFormat, ++ unsigned int ImmediateFlipBytes, ++ double LineTime, ++ double Tno_bw, ++ double VRatio, ++ double PDEAndMetaPTEBytesFrame, ++ unsigned int MetaRowByte, ++ unsigned int PixelPTEBytesPerRow, ++ bool DCCEnable, ++ unsigned int dpte_row_height, ++ unsigned int meta_row_height, ++ double qual_row_bw, ++ double *DestinationLinesToRequestVMInImmediateFlip, ++ double *DestinationLinesToRequestRowInImmediateFlip, ++ double *final_flip_bw, ++ bool *ImmediateFlipSupportedForPipe); ++static double CalculateWriteBackDelay( ++ enum source_format_class WritebackPixelFormat, ++ double WritebackHRatio, ++ double WritebackVRatio, ++ unsigned int WritebackLumaHTaps, ++ unsigned int WritebackLumaVTaps, ++ unsigned int WritebackChromaHTaps, ++ unsigned int WritebackChromaVTaps, ++ unsigned int WritebackDestinationWidth); + static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct display_mode_lib *mode_lib); + static unsigned int CursorBppEnumToBits(enum cursor_bpp ebpp); +- +-void set_prefetch_mode(struct display_mode_lib *mode_lib, +- bool cstate_en, +- bool pstate_en, +- bool ignore_viewport_pos, +- bool immediate_flip_support) ++static void ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib); ++ ++void set_prefetch_mode( ++ struct display_mode_lib *mode_lib, ++ bool cstate_en, ++ bool pstate_en, ++ bool ignore_viewport_pos, ++ bool immediate_flip_support) + { + unsigned int prefetch_mode; + +@@ -211,11 +229,13 @@ void set_prefetch_mode(struct display_mode_lib *mode_lib, + prefetch_mode = 1; + else + prefetch_mode = 2; +- if (prefetch_mode != mode_lib->vba.PrefetchMode || ignore_viewport_pos != mode_lib->vba.IgnoreViewportPositioning +- || immediate_flip_support != mode_lib->vba.ImmediateFlipSupport) { +- DTRACE(" Prefetch mode has changed from %i to %i. Recalculating.", +- prefetch_mode, +- mode_lib->vba.PrefetchMode); ++ if (prefetch_mode != mode_lib->vba.PrefetchMode ++ || ignore_viewport_pos != mode_lib->vba.IgnoreViewportPositioning ++ || immediate_flip_support != mode_lib->vba.ImmediateFlipSupport) { ++ DTRACE( ++ " Prefetch mode has changed from %i to %i. Recalculating.", ++ prefetch_mode, ++ mode_lib->vba.PrefetchMode); + mode_lib->vba.PrefetchMode = prefetch_mode; + mode_lib->vba.IgnoreViewportPositioning = ignore_viewport_pos; + mode_lib->vba.ImmediateFlipSupport = immediate_flip_support; +@@ -223,6 +243,39 @@ void set_prefetch_mode(struct display_mode_lib *mode_lib, + } + } + ++unsigned int dml_get_voltage_level( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes) ++{ ++ bool need_recalculate = memcmp( ++ &mode_lib->soc, ++ &mode_lib->vba.soc, ++ sizeof(mode_lib->vba.soc)) != 0 ++ || memcmp(&mode_lib->ip, &mode_lib->vba.ip, sizeof(mode_lib->vba.ip)) != 0 ++ || memcmp(&mode_lib->me, &mode_lib->vba.me, sizeof(mode_lib->vba.me)) != 0 ++ || num_pipes != mode_lib->vba.cache_num_pipes ++ || memcmp(pipes, mode_lib->vba.cache_pipes, ++ sizeof(display_e2e_pipe_params_st) * num_pipes) != 0; ++ ++ mode_lib->vba.soc = mode_lib->soc; ++ mode_lib->vba.ip = mode_lib->ip; ++ mode_lib->vba.me = mode_lib->me; ++ memcpy(mode_lib->vba.cache_pipes, pipes, sizeof(*pipes) * num_pipes); ++ mode_lib->vba.cache_num_pipes = num_pipes; ++ ++ if (need_recalculate) ++ recalculate(mode_lib); ++ else { ++ fetch_socbb_params(mode_lib); ++ fetch_ip_params(mode_lib); ++ fetch_pipe_params(mode_lib); ++ } ++ ModeSupportAndSystemConfigurationFull(mode_lib); ++ ++ return mode_lib->vba.VoltageLevel; ++} ++ + #define dml_get_attr_func(attr, var) double get_##attr(struct display_mode_lib *mode_lib, const display_e2e_pipe_params_st *pipes, unsigned int num_pipes) \ + { \ + recalculate_params(mode_lib, pipes, num_pipes); \ +@@ -243,7 +296,9 @@ dml_get_attr_func(stutter_efficiency_no_vblank, mode_lib->vba.StutterEfficiencyN + dml_get_attr_func(urgent_latency, mode_lib->vba.MinUrgentLatencySupportUs); + dml_get_attr_func(urgent_extra_latency, mode_lib->vba.UrgentExtraLatency); + dml_get_attr_func(nonurgent_latency, mode_lib->vba.NonUrgentLatencyTolerance); +-dml_get_attr_func(dram_clock_change_latency, mode_lib->vba.MinActiveDRAMClockChangeLatencySupported); ++dml_get_attr_func( ++ dram_clock_change_latency, ++ mode_lib->vba.MinActiveDRAMClockChangeLatencySupported); + dml_get_attr_func(dispclk_calculated, mode_lib->vba.DISPCLK_calculated); + dml_get_attr_func(total_data_read_bw, mode_lib->vba.TotalDataReadBandwidth); + dml_get_attr_func(return_bw, mode_lib->vba.ReturnBW); +@@ -269,17 +324,20 @@ dml_get_pipe_attr_func(dst_y_per_vm_vblank, mode_lib->vba.DestinationLinesToRequ + dml_get_pipe_attr_func(dst_y_per_row_vblank, mode_lib->vba.DestinationLinesToRequestRowInVBlank); + dml_get_pipe_attr_func(dst_y_prefetch, mode_lib->vba.DestinationLinesForPrefetch); + dml_get_pipe_attr_func(dst_y_per_vm_flip, mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip); +-dml_get_pipe_attr_func(dst_y_per_row_flip, mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip); ++dml_get_pipe_attr_func( ++ dst_y_per_row_flip, ++ mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip); + + dml_get_pipe_attr_func(xfc_transfer_delay, mode_lib->vba.XFCTransferDelay); + dml_get_pipe_attr_func(xfc_precharge_delay, mode_lib->vba.XFCPrechargeDelay); + dml_get_pipe_attr_func(xfc_remote_surface_flip_latency, mode_lib->vba.XFCRemoteSurfaceFlipLatency); + dml_get_pipe_attr_func(xfc_prefetch_margin, mode_lib->vba.XFCPrefetchMargin); + +-unsigned int get_vstartup_calculated(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes, +- unsigned int which_pipe) ++unsigned int get_vstartup_calculated( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes, ++ unsigned int which_pipe) + { + unsigned int which_plane; + +@@ -288,25 +346,28 @@ unsigned int get_vstartup_calculated(struct display_mode_lib *mode_lib, + return mode_lib->vba.VStartup[which_plane]; + } + +-double get_total_immediate_flip_bytes(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes) ++double get_total_immediate_flip_bytes( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes) + { + recalculate_params(mode_lib, pipes, num_pipes); + return mode_lib->vba.TotImmediateFlipBytes; + } + +-double get_total_immediate_flip_bw(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes) ++double get_total_immediate_flip_bw( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes) + { + recalculate_params(mode_lib, pipes, num_pipes); + return mode_lib->vba.ImmediateFlipBW; + } + +-double get_total_prefetch_bw(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes) ++double get_total_prefetch_bw( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes) + { + unsigned int k; + double total_prefetch_bw = 0.0; +@@ -326,10 +387,11 @@ static void fetch_socbb_params(struct display_mode_lib *mode_lib) + mode_lib->vba.ReturnBusWidth = soc->return_bus_width_bytes; + mode_lib->vba.NumberOfChannels = soc->num_chans; + mode_lib->vba.PercentOfIdealDRAMAndFabricBWReceivedAfterUrgLatency = +- soc->ideal_dram_bw_after_urgent_percent; // there's always that one bastard variable that's so long it throws everything out of alignment! ++ soc->ideal_dram_bw_after_urgent_percent; // there's always that one bastard variable that's so long it throws everything out of alignment! + mode_lib->vba.UrgentLatency = soc->urgent_latency_us; + mode_lib->vba.RoundTripPingLatencyCycles = soc->round_trip_ping_latency_dcfclk_cycles; +- mode_lib->vba.UrgentOutOfOrderReturnPerChannel = soc->urgent_out_of_order_return_per_channel_bytes; ++ mode_lib->vba.UrgentOutOfOrderReturnPerChannel = ++ soc->urgent_out_of_order_return_per_channel_bytes; + mode_lib->vba.WritebackLatency = soc->writeback_latency_us; + mode_lib->vba.SRExitTime = soc->sr_exit_time_us; + mode_lib->vba.SREnterPlusExitTime = soc->sr_enter_plus_exit_time_us; +@@ -342,7 +404,7 @@ static void fetch_socbb_params(struct display_mode_lib *mode_lib) + mode_lib->vba.VMMPageSize = soc->vmm_page_size_bytes; + // Set the voltage scaling clocks as the defaults. Most of these will + // be set to different values by the test +- for (i = 0; i < DC__VOLTAGE_STATES; ++i) ++ for (i = 0; i < DC__VOLTAGE_STATES; i++) + if (soc->clock_limits[i].state == mode_lib->vba.VoltageLevel) + break; + +@@ -353,6 +415,23 @@ static void fetch_socbb_params(struct display_mode_lib *mode_lib) + + mode_lib->vba.XFCBusTransportTime = soc->xfc_bus_transport_time_us; + mode_lib->vba.XFCXBUFLatencyTolerance = soc->xfc_xbuf_latency_tolerance_us; ++ ++ mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp = false; ++ mode_lib->vba.MaxHSCLRatio = 4; ++ mode_lib->vba.MaxVSCLRatio = 4; ++ mode_lib->vba.MaxNumWriteback = 0; /*TODO*/ ++ mode_lib->vba.WritebackLumaAndChromaScalingSupported = true; ++ mode_lib->vba.Cursor64BppSupport = true; ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.DCFCLKPerState[i] = soc->clock_limits[i].dcfclk_mhz; ++ mode_lib->vba.FabricClockPerState[i] = soc->clock_limits[i].fabricclk_mhz; ++ mode_lib->vba.SOCCLKPerState[i] = soc->clock_limits[i].socclk_mhz; ++ mode_lib->vba.PHYCLKPerState[i] = soc->clock_limits[i].phyclk_mhz; ++ mode_lib->vba.MaxDppclk[i] = soc->clock_limits[i].dppclk_mhz; ++ mode_lib->vba.MaxDSCCLK[i] = soc->clock_limits[i].dscclk_mhz; ++ mode_lib->vba.DRAMSpeedPerState[i] = soc->clock_limits[i].dram_speed_mhz; ++ mode_lib->vba.MaxDispclk[i] = soc->clock_limits[i].dispclk_mhz; ++ } + } + + static void fetch_ip_params(struct display_mode_lib *mode_lib) +@@ -360,6 +439,11 @@ static void fetch_ip_params(struct display_mode_lib *mode_lib) + ip_params_st *ip = &mode_lib->vba.ip; + + // IP Parameters ++ mode_lib->vba.MaxNumDPP = ip->max_num_dpp; ++ mode_lib->vba.MaxNumOTG = ip->max_num_otg; ++ mode_lib->vba.CursorChunkSize = ip->cursor_chunk_size; ++ mode_lib->vba.CursorBufferSize = ip->cursor_buffer_size; ++ + mode_lib->vba.MaxDCHUBToPSCLThroughput = ip->max_dchub_pscl_bw_pix_per_clk; + mode_lib->vba.MaxPSCLToLBThroughput = ip->max_pscl_lb_bw_pix_per_clk; + mode_lib->vba.ROBBufferSizeInKByte = ip->rob_buffer_size_kbytes; +@@ -375,7 +459,8 @@ static void fetch_ip_params(struct display_mode_lib *mode_lib) + mode_lib->vba.OPPOutputBufferLines = ip->opp_output_buffer_lines; + mode_lib->vba.WritebackInterfaceLumaBufferSize = ip->writeback_luma_buffer_size_kbytes; + mode_lib->vba.WritebackInterfaceChromaBufferSize = ip->writeback_chroma_buffer_size_kbytes; +- mode_lib->vba.WritebackChromaLineBufferWidth = ip->writeback_chroma_line_buffer_width_pixels; ++ mode_lib->vba.WritebackChromaLineBufferWidth = ++ ip->writeback_chroma_line_buffer_width_pixels; + mode_lib->vba.MaxPageTableLevels = ip->max_page_table_levels; + mode_lib->vba.MaxInterDCNTileRepeaters = ip->max_inter_dcn_tile_repeaters; + mode_lib->vba.NumberOfDSC = ip->num_dsc; +@@ -402,10 +487,10 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + display_e2e_pipe_params_st *pipes = mode_lib->vba.cache_pipes; + ip_params_st *ip = &mode_lib->vba.ip; + +- unsigned int OTGInstPlane[DC__NUM_DPP]; ++ unsigned int OTGInstPlane[DC__NUM_DPP__MAX]; + unsigned int j, k; +- bool PlaneVisited[DC__NUM_DPP]; +- bool visited[DC__NUM_PIPES__MAX]; ++ bool PlaneVisited[DC__NUM_DPP__MAX]; ++ bool visited[DC__NUM_DPP__MAX]; + + // Convert Pipes to Planes + for (k = 0; k < mode_lib->vba.cache_num_pipes; ++k) +@@ -427,11 +512,16 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + mode_lib->vba.pipe_plane[j] = mode_lib->vba.NumberOfActivePlanes; + + mode_lib->vba.DPPPerPlane[mode_lib->vba.NumberOfActivePlanes] = 1; +- mode_lib->vba.SourceScan[mode_lib->vba.NumberOfActivePlanes] = (enum scan_direction_class)(src->source_scan); +- mode_lib->vba.ViewportWidth[mode_lib->vba.NumberOfActivePlanes] = src->viewport_width; +- mode_lib->vba.ViewportHeight[mode_lib->vba.NumberOfActivePlanes] = src->viewport_height; +- mode_lib->vba.ViewportYStartY[mode_lib->vba.NumberOfActivePlanes] = src->viewport_y_y; +- mode_lib->vba.ViewportYStartC[mode_lib->vba.NumberOfActivePlanes] = src->viewport_y_c; ++ mode_lib->vba.SourceScan[mode_lib->vba.NumberOfActivePlanes] = ++ (enum scan_direction_class) (src->source_scan); ++ mode_lib->vba.ViewportWidth[mode_lib->vba.NumberOfActivePlanes] = ++ src->viewport_width; ++ mode_lib->vba.ViewportHeight[mode_lib->vba.NumberOfActivePlanes] = ++ src->viewport_height; ++ mode_lib->vba.ViewportYStartY[mode_lib->vba.NumberOfActivePlanes] = ++ src->viewport_y_y; ++ mode_lib->vba.ViewportYStartC[mode_lib->vba.NumberOfActivePlanes] = ++ src->viewport_y_c; + mode_lib->vba.PitchY[mode_lib->vba.NumberOfActivePlanes] = src->data_pitch; + mode_lib->vba.PitchC[mode_lib->vba.NumberOfActivePlanes] = src->data_pitch_c; + mode_lib->vba.DCCMetaPitchY[mode_lib->vba.NumberOfActivePlanes] = src->meta_pitch; +@@ -448,40 +538,62 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + mode_lib->vba.HTotal[mode_lib->vba.NumberOfActivePlanes] = dst->htotal; + mode_lib->vba.VTotal[mode_lib->vba.NumberOfActivePlanes] = dst->vtotal; + mode_lib->vba.DCCEnable[mode_lib->vba.NumberOfActivePlanes] = +- src->dcc_use_global ? ip->dcc_supported : src->dcc & ip->dcc_supported; ++ src->dcc_use_global ? ++ ip->dcc_supported : src->dcc && ip->dcc_supported; + mode_lib->vba.DCCRate[mode_lib->vba.NumberOfActivePlanes] = src->dcc_rate; +- mode_lib->vba.SourcePixelFormat[mode_lib->vba.NumberOfActivePlanes] = (enum source_format_class)(src->source_format); ++ mode_lib->vba.SourcePixelFormat[mode_lib->vba.NumberOfActivePlanes] = ++ (enum source_format_class) (src->source_format); + mode_lib->vba.HActive[mode_lib->vba.NumberOfActivePlanes] = dst->hactive; + mode_lib->vba.VActive[mode_lib->vba.NumberOfActivePlanes] = dst->vactive; +- mode_lib->vba.SurfaceTiling[mode_lib->vba.NumberOfActivePlanes] = (enum dm_swizzle_mode)(src->sw_mode); +- mode_lib->vba.ScalerRecoutWidth[mode_lib->vba.NumberOfActivePlanes] = dst->recout_width; // TODO: or should this be full_recout_width???...maybe only when in hsplit mode? +- mode_lib->vba.ODMCombineEnabled[mode_lib->vba.NumberOfActivePlanes] = dst->odm_combine; +- mode_lib->vba.OutputFormat[mode_lib->vba.NumberOfActivePlanes] = (enum output_format_class)(dout->output_format); +- mode_lib->vba.Output[mode_lib->vba.NumberOfActivePlanes] = (enum output_encoder_class)(dout->output_type); ++ mode_lib->vba.SurfaceTiling[mode_lib->vba.NumberOfActivePlanes] = ++ (enum dm_swizzle_mode) (src->sw_mode); ++ mode_lib->vba.ScalerRecoutWidth[mode_lib->vba.NumberOfActivePlanes] = ++ dst->recout_width; // TODO: or should this be full_recout_width???...maybe only when in hsplit mode? ++ mode_lib->vba.ODMCombineEnabled[mode_lib->vba.NumberOfActivePlanes] = ++ dst->odm_combine; ++ mode_lib->vba.OutputFormat[mode_lib->vba.NumberOfActivePlanes] = ++ (enum output_format_class) (dout->output_format); ++ mode_lib->vba.Output[mode_lib->vba.NumberOfActivePlanes] = ++ (enum output_encoder_class) (dout->output_type); + mode_lib->vba.OutputBpp[mode_lib->vba.NumberOfActivePlanes] = dout->output_bpp; ++ mode_lib->vba.OutputLinkDPLanes[mode_lib->vba.NumberOfActivePlanes] = ++ dout->dp_lanes; + mode_lib->vba.DSCEnabled[mode_lib->vba.NumberOfActivePlanes] = dout->dsc_enable; +- mode_lib->vba.NumberOfDSCSlices[mode_lib->vba.NumberOfActivePlanes] = dout->dsc_slices; ++ mode_lib->vba.NumberOfDSCSlices[mode_lib->vba.NumberOfActivePlanes] = ++ dout->dsc_slices; + mode_lib->vba.DSCInputBitPerComponent[mode_lib->vba.NumberOfActivePlanes] = +- dout->output_bpc == 0 ? 12 : dout->output_bpc; ++ dout->output_bpc == 0 ? 12 : dout->output_bpc; + mode_lib->vba.WritebackEnable[mode_lib->vba.NumberOfActivePlanes] = dout->wb_enable; +- mode_lib->vba.WritebackSourceHeight[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_src_height; +- mode_lib->vba.WritebackDestinationWidth[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_dst_width; +- mode_lib->vba.WritebackDestinationHeight[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_dst_height; +- mode_lib->vba.WritebackPixelFormat[mode_lib->vba.NumberOfActivePlanes] = (enum source_format_class)(dout->wb.wb_pixel_format); +- mode_lib->vba.WritebackLumaHTaps[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_htaps_luma; +- mode_lib->vba.WritebackLumaVTaps[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_vtaps_luma; +- mode_lib->vba.WritebackChromaHTaps[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_htaps_chroma; +- mode_lib->vba.WritebackChromaVTaps[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_vtaps_chroma; +- mode_lib->vba.WritebackHRatio[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_hratio; +- mode_lib->vba.WritebackVRatio[mode_lib->vba.NumberOfActivePlanes] = dout->wb.wb_vratio; +- +- mode_lib->vba.DynamicMetadataEnable[mode_lib->vba.NumberOfActivePlanes] = src->dynamic_metadata_enable; ++ mode_lib->vba.WritebackSourceHeight[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_src_height; ++ mode_lib->vba.WritebackDestinationWidth[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_dst_width; ++ mode_lib->vba.WritebackDestinationHeight[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_dst_height; ++ mode_lib->vba.WritebackPixelFormat[mode_lib->vba.NumberOfActivePlanes] = ++ (enum source_format_class) (dout->wb.wb_pixel_format); ++ mode_lib->vba.WritebackLumaHTaps[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_htaps_luma; ++ mode_lib->vba.WritebackLumaVTaps[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_vtaps_luma; ++ mode_lib->vba.WritebackChromaHTaps[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_htaps_chroma; ++ mode_lib->vba.WritebackChromaVTaps[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_vtaps_chroma; ++ mode_lib->vba.WritebackHRatio[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_hratio; ++ mode_lib->vba.WritebackVRatio[mode_lib->vba.NumberOfActivePlanes] = ++ dout->wb.wb_vratio; ++ ++ mode_lib->vba.DynamicMetadataEnable[mode_lib->vba.NumberOfActivePlanes] = ++ src->dynamic_metadata_enable; + mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[mode_lib->vba.NumberOfActivePlanes] = +- src->dynamic_metadata_lines_before_active; ++ src->dynamic_metadata_lines_before_active; + mode_lib->vba.DynamicMetadataTransmittedBytes[mode_lib->vba.NumberOfActivePlanes] = +- src->dynamic_metadata_xmit_bytes; ++ src->dynamic_metadata_xmit_bytes; + +- mode_lib->vba.XFCEnabled[mode_lib->vba.NumberOfActivePlanes] = src->xfc_enable && ip->xfc_supported; ++ mode_lib->vba.XFCEnabled[mode_lib->vba.NumberOfActivePlanes] = src->xfc_enable ++ && ip->xfc_supported; + mode_lib->vba.XFCSlvChunkSize = src->xfc_params.xfc_slv_chunk_size_bytes; + mode_lib->vba.XFCTSlvVupdateOffset = src->xfc_params.xfc_tslv_vupdate_offset_us; + mode_lib->vba.XFCTSlvVupdateWidth = src->xfc_params.xfc_tslv_vupdate_width_us; +@@ -489,7 +601,8 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + mode_lib->vba.PixelClock[mode_lib->vba.NumberOfActivePlanes] = dst->pixel_rate_mhz; + mode_lib->vba.DPPCLK[mode_lib->vba.NumberOfActivePlanes] = clks->dppclk_mhz; + if (ip->is_line_buffer_bpp_fixed) +- mode_lib->vba.LBBitPerPixel[mode_lib->vba.NumberOfActivePlanes] = ip->line_buffer_fixed_bpp; ++ mode_lib->vba.LBBitPerPixel[mode_lib->vba.NumberOfActivePlanes] = ++ ip->line_buffer_fixed_bpp; + else { + unsigned int lb_depth; + +@@ -520,27 +633,36 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + for (k = 0; k < DC__NUM_CURSOR; ++k) { + switch (k) { + case 0: +- mode_lib->vba.CursorBPP[mode_lib->vba.NumberOfActivePlanes][0] = CursorBppEnumToBits((enum cursor_bpp)(src->cur0_bpp)); +- mode_lib->vba.CursorWidth[mode_lib->vba.NumberOfActivePlanes][0] = src->cur0_src_width; ++ mode_lib->vba.CursorBPP[mode_lib->vba.NumberOfActivePlanes][0] = ++ CursorBppEnumToBits( ++ (enum cursor_bpp) (src->cur0_bpp)); ++ mode_lib->vba.CursorWidth[mode_lib->vba.NumberOfActivePlanes][0] = ++ src->cur0_src_width; + if (src->cur0_src_width > 0) + mode_lib->vba.NumberOfCursors[mode_lib->vba.NumberOfActivePlanes]++; + break; + case 1: +- mode_lib->vba.CursorBPP[mode_lib->vba.NumberOfActivePlanes][1] = CursorBppEnumToBits((enum cursor_bpp)(src->cur1_bpp)); +- mode_lib->vba.CursorWidth[mode_lib->vba.NumberOfActivePlanes][1] = src->cur1_src_width; ++ mode_lib->vba.CursorBPP[mode_lib->vba.NumberOfActivePlanes][1] = ++ CursorBppEnumToBits( ++ (enum cursor_bpp) (src->cur1_bpp)); ++ mode_lib->vba.CursorWidth[mode_lib->vba.NumberOfActivePlanes][1] = ++ src->cur1_src_width; + if (src->cur1_src_width > 0) + mode_lib->vba.NumberOfCursors[mode_lib->vba.NumberOfActivePlanes]++; + break; + default: +- dml_print("ERROR: Number of cursors specified exceeds supported maximum\n"); ++ dml_print( ++ "ERROR: Number of cursors specified exceeds supported maximum\n") ++ ; + } + } + + OTGInstPlane[mode_lib->vba.NumberOfActivePlanes] = dst->otg_inst; + + if (dst->odm_combine && !src->is_hsplit) +- dml_print("ERROR: ODM Combine is specified but is_hsplit has not be specified for pipe %i\n", +- j); ++ dml_print( ++ "ERROR: ODM Combine is specified but is_hsplit has not be specified for pipe %i\n", ++ j); + + if (src->is_hsplit) { + for (k = j + 1; k < mode_lib->vba.cache_num_pipes; ++k) { +@@ -548,18 +670,20 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + display_output_params_st *dout_k = &pipes[k].dout; + + if (src_k->is_hsplit && !visited[k] +- && src->hsplit_grp == src_k->hsplit_grp) { +- mode_lib->vba.pipe_plane[k] = mode_lib->vba.NumberOfActivePlanes; ++ && src->hsplit_grp == src_k->hsplit_grp) { ++ mode_lib->vba.pipe_plane[k] = ++ mode_lib->vba.NumberOfActivePlanes; + mode_lib->vba.DPPPerPlane[mode_lib->vba.NumberOfActivePlanes]++; +- if (mode_lib->vba.SourceScan[mode_lib->vba.NumberOfActivePlanes] == dm_horz) ++ if (mode_lib->vba.SourceScan[mode_lib->vba.NumberOfActivePlanes] ++ == dm_horz) + mode_lib->vba.ViewportWidth[mode_lib->vba.NumberOfActivePlanes] += +- src_k->viewport_width; ++ src_k->viewport_width; + else + mode_lib->vba.ViewportHeight[mode_lib->vba.NumberOfActivePlanes] += +- src_k->viewport_height; ++ src_k->viewport_height; + + mode_lib->vba.NumberOfDSCSlices[mode_lib->vba.NumberOfActivePlanes] += +- dout_k->dsc_slices; ++ dout_k->dsc_slices; + visited[k] = true; + } + } +@@ -598,26 +722,30 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + for (k = 1; k < mode_lib->vba.cache_num_pipes; ++k) + ASSERT(mode_lib->vba.SynchronizedVBlank == pipes[k].pipe.dest.synchronized_vblank_all_planes); + +- mode_lib->vba.VirtualMemoryEnable = 0; ++ mode_lib->vba.VirtualMemoryEnable = false; + mode_lib->vba.OverridePageTableLevels = 0; + + for (k = 0; k < mode_lib->vba.cache_num_pipes; ++k) { +- mode_lib->vba.VirtualMemoryEnable |= pipes[k].pipe.src.vm; ++ mode_lib->vba.VirtualMemoryEnable = mode_lib->vba.VirtualMemoryEnable ++ || !!pipes[k].pipe.src.vm; + mode_lib->vba.OverridePageTableLevels = +- (pipes[k].pipe.src.vm_levels_force_en +- && mode_lib->vba.OverridePageTableLevels +- < pipes[k].pipe.src.vm_levels_force) ? +- pipes[k].pipe.src.vm_levels_force : +- mode_lib->vba.OverridePageTableLevels; ++ (pipes[k].pipe.src.vm_levels_force_en ++ && mode_lib->vba.OverridePageTableLevels ++ < pipes[k].pipe.src.vm_levels_force) ? ++ pipes[k].pipe.src.vm_levels_force : ++ mode_lib->vba.OverridePageTableLevels; + } + + if (mode_lib->vba.OverridePageTableLevels) + mode_lib->vba.MaxPageTableLevels = mode_lib->vba.OverridePageTableLevels; + +- mode_lib->vba.VirtualMemoryEnable &= ip->pte_enable; ++ mode_lib->vba.VirtualMemoryEnable = mode_lib->vba.VirtualMemoryEnable && !!ip->pte_enable; + +- mode_lib->vba.FabricAndDRAMBandwidth = dml_min(mode_lib->vba.DRAMSpeed * mode_lib->vba.NumberOfChannels * mode_lib->vba.DRAMChannelWidth, +- mode_lib->vba.FabricClock * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000.0; ++ mode_lib->vba.FabricAndDRAMBandwidth = dml_min( ++ mode_lib->vba.DRAMSpeed * mode_lib->vba.NumberOfChannels ++ * mode_lib->vba.DRAMChannelWidth, ++ mode_lib->vba.FabricClock * mode_lib->vba.FabricDatapathToDCNDataReturn) ++ / 1000.0; + + // TODO: Must be consistent across all pipes + // DCCProgrammingAssumesScanDirectionUnknown = src.dcc_scan_dir_unknown; +@@ -633,16 +761,20 @@ static void recalculate(struct display_mode_lib *mode_lib) + + // in wm mode we pull the parameters needed from the display_e2e_pipe_params_st structs + // rather than working them out as in recalculate_ms +-static void recalculate_params(struct display_mode_lib *mode_lib, +- const display_e2e_pipe_params_st *pipes, +- unsigned int num_pipes) ++static void recalculate_params( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes) + { + // This is only safe to use memcmp because there are non-POD types in struct display_mode_lib + if (memcmp(&mode_lib->soc, &mode_lib->vba.soc, sizeof(mode_lib->vba.soc)) != 0 + || memcmp(&mode_lib->ip, &mode_lib->vba.ip, sizeof(mode_lib->vba.ip)) != 0 + || memcmp(&mode_lib->me, &mode_lib->vba.me, sizeof(mode_lib->vba.me)) != 0 + || num_pipes != mode_lib->vba.cache_num_pipes +- || memcmp(pipes, mode_lib->vba.cache_pipes, sizeof(display_e2e_pipe_params_st) * num_pipes) != 0) { ++ || memcmp( ++ pipes, ++ mode_lib->vba.cache_pipes, ++ sizeof(display_e2e_pipe_params_st) * num_pipes) != 0) { + mode_lib->vba.soc = mode_lib->soc; + mode_lib->vba.ip = mode_lib->ip; + mode_lib->vba.me = mode_lib->me; +@@ -677,55 +809,70 @@ static void ModeSupportAndSystemConfiguration(struct display_mode_lib *mode_lib) + // Total Available Pipes Support Check + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) + total_pipes += mode_lib->vba.DPPPerPlane[k]; +- ASSERT(total_pipes <= DC__NUM_DPP); ++ ASSERT(total_pipes <= DC__NUM_DPP__MAX); + } + +-static double adjust_ReturnBW(struct display_mode_lib *mode_lib, double ReturnBW, bool DCCEnabledAnyPlane, double ReturnBandwidthToDCN) ++static double adjust_ReturnBW( ++ struct display_mode_lib *mode_lib, ++ double ReturnBW, ++ bool DCCEnabledAnyPlane, ++ double ReturnBandwidthToDCN) + { + double CriticalCompression; + +- if (DCCEnabledAnyPlane && ReturnBandwidthToDCN > mode_lib->vba.DCFCLK * mode_lib->vba.ReturnBusWidth / 4.0) ++ if (DCCEnabledAnyPlane ++ && ReturnBandwidthToDCN ++ > mode_lib->vba.DCFCLK * mode_lib->vba.ReturnBusWidth / 4.0) + ReturnBW = +- dml_min(ReturnBW, +- ReturnBandwidthToDCN * 4 +- * (1.0 +- - mode_lib->vba.UrgentLatency +- / ((mode_lib->vba.ROBBufferSizeInKByte +- - mode_lib->vba.PixelChunkSizeInKByte) +- * 1024 +- / ReturnBandwidthToDCN +- - mode_lib->vba.DCFCLK +- * mode_lib->vba.ReturnBusWidth +- / 4) +- + mode_lib->vba.UrgentLatency)); +- +- CriticalCompression = 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK * mode_lib->vba.UrgentLatency +- / (ReturnBandwidthToDCN * mode_lib->vba.UrgentLatency +- + (mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024); ++ dml_min( ++ ReturnBW, ++ ReturnBandwidthToDCN * 4 ++ * (1.0 ++ - mode_lib->vba.UrgentLatency ++ / ((mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024 ++ / ReturnBandwidthToDCN ++ - mode_lib->vba.DCFCLK ++ * mode_lib->vba.ReturnBusWidth ++ / 4) ++ + mode_lib->vba.UrgentLatency)); ++ ++ CriticalCompression = 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK ++ * mode_lib->vba.UrgentLatency ++ / (ReturnBandwidthToDCN * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024); + + if (DCCEnabledAnyPlane && CriticalCompression > 1.0 && CriticalCompression < 4.0) + ReturnBW = +- dml_min(ReturnBW, +- 4.0 * ReturnBandwidthToDCN +- * (mode_lib->vba.ROBBufferSizeInKByte +- - mode_lib->vba.PixelChunkSizeInKByte) +- * 1024 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK +- * mode_lib->vba.UrgentLatency +- / dml_pow((ReturnBandwidthToDCN +- * mode_lib->vba.UrgentLatency +- + (mode_lib->vba.ROBBufferSizeInKByte +- - mode_lib->vba.PixelChunkSizeInKByte) +- * 1024), +- 2)); ++ dml_min( ++ ReturnBW, ++ 4.0 * ReturnBandwidthToDCN ++ * (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024 ++ * mode_lib->vba.ReturnBusWidth ++ * mode_lib->vba.DCFCLK ++ * mode_lib->vba.UrgentLatency ++ / dml_pow( ++ (ReturnBandwidthToDCN ++ * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024), ++ 2)); + + return ReturnBW; + } + +-static unsigned int dscceComputeDelay(unsigned int bpc, +- double bpp, +- unsigned int sliceWidth, +- unsigned int numSlices, +- enum output_format_class pixelFormat) ++static unsigned int dscceComputeDelay( ++ unsigned int bpc, ++ double bpp, ++ unsigned int sliceWidth, ++ unsigned int numSlices, ++ enum output_format_class pixelFormat) + { + // valid bpc = source bits per component in the set of {8, 10, 12} + // valid bpp = increments of 1/16 of a bit +@@ -739,12 +886,12 @@ static unsigned int dscceComputeDelay(unsigned int bpc, + unsigned int rcModelSize = 8192; + + // N422/N420 operate at 2 pixels per clock +- unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, l, Delay, +- pixels; ++ unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, l, ++ Delay, pixels; + + if (pixelFormat == dm_n422 || pixelFormat == dm_420) + pixelsPerClock = 2; +- // #all other modes operate at 1 pixel per clock ++ // #all other modes operate at 1 pixel per clock + else + pixelsPerClock = 1; + +@@ -859,66 +1006,67 @@ static unsigned int dscComputeDelay(enum output_format_class pixelFormat) + return Delay; + } + +-static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, +- double DPPCLK, +- double DISPCLK, +- double PixelClock, +- double DCFClkDeepSleep, +- unsigned int DSCDelay, +- unsigned int DPPPerPlane, +- bool ScalerEnabled, +- unsigned int NumberOfCursors, +- double DPPCLKDelaySubtotal, +- double DPPCLKDelaySCL, +- double DPPCLKDelaySCLLBOnly, +- double DPPCLKDelayCNVCFormater, +- double DPPCLKDelayCNVCCursor, +- double DISPCLKDelaySubtotal, +- unsigned int ScalerRecoutWidth, +- enum output_format_class OutputFormat, +- unsigned int VBlank, +- unsigned int HTotal, +- unsigned int MaxInterDCNTileRepeaters, +- unsigned int VStartup, +- unsigned int PageTableLevels, +- bool VirtualMemoryEnable, +- bool DynamicMetadataEnable, +- unsigned int DynamicMetadataLinesBeforeActiveRequired, +- unsigned int DynamicMetadataTransmittedBytes, +- bool DCCEnable, +- double UrgentLatency, +- double UrgentExtraLatency, +- double TCalc, +- unsigned int PDEAndMetaPTEBytesFrame, +- unsigned int MetaRowByte, +- unsigned int PixelPTEBytesPerRow, +- double PrefetchSourceLinesY, +- unsigned int SwathWidthY, +- double BytePerPixelDETY, +- double VInitPreFillY, +- unsigned int MaxNumSwathY, +- double PrefetchSourceLinesC, +- double BytePerPixelDETC, +- double VInitPreFillC, +- unsigned int MaxNumSwathC, +- unsigned int SwathHeightY, +- unsigned int SwathHeightC, +- double TWait, +- bool XFCEnabled, +- double XFCRemoteSurfaceFlipDelay, +- bool InterlaceEnable, +- bool ProgressiveToInterlaceUnitInOPP, +- double *DSTXAfterScaler, +- double *DSTYAfterScaler, +- double *DestinationLinesForPrefetch, +- double *PrefetchBandwidth, +- double *DestinationLinesToRequestVMInVBlank, +- double *DestinationLinesToRequestRowInVBlank, +- double *VRatioPrefetchY, +- double *VRatioPrefetchC, +- double *RequiredPrefetchPixDataBW, +- unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, +- double *Tno_bw) ++static bool CalculatePrefetchSchedule( ++ struct display_mode_lib *mode_lib, ++ double DPPCLK, ++ double DISPCLK, ++ double PixelClock, ++ double DCFClkDeepSleep, ++ unsigned int DSCDelay, ++ unsigned int DPPPerPlane, ++ bool ScalerEnabled, ++ unsigned int NumberOfCursors, ++ double DPPCLKDelaySubtotal, ++ double DPPCLKDelaySCL, ++ double DPPCLKDelaySCLLBOnly, ++ double DPPCLKDelayCNVCFormater, ++ double DPPCLKDelayCNVCCursor, ++ double DISPCLKDelaySubtotal, ++ unsigned int ScalerRecoutWidth, ++ enum output_format_class OutputFormat, ++ unsigned int VBlank, ++ unsigned int HTotal, ++ unsigned int MaxInterDCNTileRepeaters, ++ unsigned int VStartup, ++ unsigned int PageTableLevels, ++ bool VirtualMemoryEnable, ++ bool DynamicMetadataEnable, ++ unsigned int DynamicMetadataLinesBeforeActiveRequired, ++ unsigned int DynamicMetadataTransmittedBytes, ++ bool DCCEnable, ++ double UrgentLatency, ++ double UrgentExtraLatency, ++ double TCalc, ++ unsigned int PDEAndMetaPTEBytesFrame, ++ unsigned int MetaRowByte, ++ unsigned int PixelPTEBytesPerRow, ++ double PrefetchSourceLinesY, ++ unsigned int SwathWidthY, ++ double BytePerPixelDETY, ++ double VInitPreFillY, ++ unsigned int MaxNumSwathY, ++ double PrefetchSourceLinesC, ++ double BytePerPixelDETC, ++ double VInitPreFillC, ++ unsigned int MaxNumSwathC, ++ unsigned int SwathHeightY, ++ unsigned int SwathHeightC, ++ double TWait, ++ bool XFCEnabled, ++ double XFCRemoteSurfaceFlipDelay, ++ bool InterlaceEnable, ++ bool ProgressiveToInterlaceUnitInOPP, ++ double *DSTXAfterScaler, ++ double *DSTYAfterScaler, ++ double *DestinationLinesForPrefetch, ++ double *PrefetchBandwidth, ++ double *DestinationLinesToRequestVMInVBlank, ++ double *DestinationLinesToRequestRowInVBlank, ++ double *VRatioPrefetchY, ++ double *VRatioPrefetchC, ++ double *RequiredPrefetchPixDataBW, ++ unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, ++ double *Tno_bw) + { + bool MyError = false; + unsigned int DPPCycles, DISPCLKCycles, VUpdateOffsetPix, VUpdateWidthPix, VReadyOffsetPix; +@@ -948,7 +1096,7 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + return true; + + *DSTXAfterScaler = DPPCycles * PixelClock / DPPCLK + DISPCLKCycles * PixelClock / DISPCLK +- + DSCDelay; ++ + DSCDelay; + + if (DPPPerPlane > 1) + *DSTXAfterScaler = *DSTXAfterScaler + ScalerRecoutWidth; +@@ -958,22 +1106,23 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + else + *DSTYAfterScaler = 0; + +- DSTTotalPixelsAfterScaler = ((double)(*DSTYAfterScaler * HTotal)) + *DSTXAfterScaler; ++ DSTTotalPixelsAfterScaler = ((double) (*DSTYAfterScaler * HTotal)) + *DSTXAfterScaler; + *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / HTotal, 1); +- *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double)(*DSTYAfterScaler * HTotal)); ++ *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * HTotal)); + + VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1); + TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2.0 / DPPCLK + 3.0 / DISPCLK); + VUpdateWidthPix = (14.0 / DCFClkDeepSleep + 12.0 / DPPCLK + TotalRepeaterDelayTime) +- * PixelClock; ++ * PixelClock; + +- VReadyOffsetPix = dml_max(150.0 / DPPCLK, +- TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / DPPCLK) +- * PixelClock; ++ VReadyOffsetPix = dml_max( ++ 150.0 / DPPCLK, ++ TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / DPPCLK) ++ * PixelClock; + +- Tsetup = (double)(VUpdateOffsetPix + VUpdateWidthPix + VReadyOffsetPix) / PixelClock; ++ Tsetup = (double) (VUpdateOffsetPix + VUpdateWidthPix + VReadyOffsetPix) / PixelClock; + +- LineTime = (double)HTotal / PixelClock; ++ LineTime = (double) HTotal / PixelClock; + + if (DynamicMetadataEnable) { + double Tdmbf, Tdmec, Tdmsks; +@@ -988,10 +1137,10 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + if (InterlaceEnable && !ProgressiveToInterlaceUnitInOPP) + Tdmsks = Tdmsks / 2; + if (VStartup * LineTime +- < Tsetup + TWait + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) { ++ < Tsetup + TWait + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) { + MyError = true; + *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = (Tsetup + TWait +- + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) / LineTime; ++ + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) / LineTime; + } else + *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = 0.0; + } else +@@ -1010,30 +1159,33 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + *Tno_bw = LineTime / 4; + + dst_y_prefetch_equ = VStartup - dml_max(TCalc + TWait, XFCRemoteSurfaceFlipDelay) / LineTime +- - (Tsetup + Tdm) / LineTime +- - (*DSTYAfterScaler + *DSTXAfterScaler / HTotal); ++ - (Tsetup + Tdm) / LineTime ++ - (*DSTYAfterScaler + *DSTXAfterScaler / HTotal); + + Tsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime; + + prefetch_bw_oto = (MetaRowByte + PixelPTEBytesPerRow +- + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) +- + PrefetchSourceLinesC * SwathWidthY / 2 * dml_ceil(BytePerPixelDETC, 2)) +- / Tsw_oto; ++ + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) ++ + PrefetchSourceLinesC * SwathWidthY / 2 * dml_ceil(BytePerPixelDETC, 2)) ++ / Tsw_oto; + + if (VirtualMemoryEnable == true) { + Tvm_oto = +- dml_max(*Tno_bw + PDEAndMetaPTEBytesFrame / prefetch_bw_oto, +- dml_max(UrgentExtraLatency +- + UrgentLatency +- * (PageTableLevels +- - 1), +- LineTime / 4.0)); ++ dml_max( ++ *Tno_bw + PDEAndMetaPTEBytesFrame / prefetch_bw_oto, ++ dml_max( ++ UrgentExtraLatency ++ + UrgentLatency ++ * (PageTableLevels ++ - 1), ++ LineTime / 4.0)); + } else + Tvm_oto = LineTime / 4.0; + + if ((VirtualMemoryEnable == true || DCCEnable == true)) { +- Tr0_oto = dml_max((MetaRowByte + PixelPTEBytesPerRow) / prefetch_bw_oto, +- dml_max(UrgentLatency, dml_max(LineTime - Tvm_oto, LineTime / 4))); ++ Tr0_oto = dml_max( ++ (MetaRowByte + PixelPTEBytesPerRow) / prefetch_bw_oto, ++ dml_max(UrgentLatency, dml_max(LineTime - Tvm_oto, LineTime / 4))); + } else + Tr0_oto = LineTime - Tvm_oto; + +@@ -1046,7 +1198,8 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + else + *DestinationLinesForPrefetch = dst_y_prefetch_equ; + +- *DestinationLinesForPrefetch = dml_floor(4.0 * (*DestinationLinesForPrefetch + 0.125), 1) / 4; ++ *DestinationLinesForPrefetch = dml_floor(4.0 * (*DestinationLinesForPrefetch + 0.125), 1) ++ / 4; + + dml_print("DML: VStartup: %d\n", VStartup); + dml_print("DML: TCalc: %f\n", TCalc); +@@ -1067,21 +1220,23 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + *RequiredPrefetchPixDataBW = 0; + if (*DestinationLinesForPrefetch > 1) { + *PrefetchBandwidth = (PDEAndMetaPTEBytesFrame + 2 * MetaRowByte +- + 2 * PixelPTEBytesPerRow +- + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) +- + PrefetchSourceLinesC * SwathWidthY / 2 +- * dml_ceil(BytePerPixelDETC, 2)) +- / (*DestinationLinesForPrefetch * LineTime - *Tno_bw); ++ + 2 * PixelPTEBytesPerRow ++ + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) ++ + PrefetchSourceLinesC * SwathWidthY / 2 ++ * dml_ceil(BytePerPixelDETC, 2)) ++ / (*DestinationLinesForPrefetch * LineTime - *Tno_bw); + if (VirtualMemoryEnable) { + TimeForFetchingMetaPTE = +- dml_max(*Tno_bw +- + (double)PDEAndMetaPTEBytesFrame +- / *PrefetchBandwidth, +- dml_max(UrgentExtraLatency +- + UrgentLatency +- * (PageTableLevels +- - 1), +- LineTime / 4)); ++ dml_max( ++ *Tno_bw ++ + (double) PDEAndMetaPTEBytesFrame ++ / *PrefetchBandwidth, ++ dml_max( ++ UrgentExtraLatency ++ + UrgentLatency ++ * (PageTableLevels ++ - 1), ++ LineTime / 4)); + } else { + if (NumberOfCursors > 0 || XFCEnabled) + TimeForFetchingMetaPTE = LineTime / 4; +@@ -1091,13 +1246,16 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + + if ((VirtualMemoryEnable == true || DCCEnable == true)) { + TimeForFetchingRowInVBlank = +- dml_max((MetaRowByte + PixelPTEBytesPerRow) +- / *PrefetchBandwidth, +- dml_max(UrgentLatency, +- dml_max(LineTime +- - TimeForFetchingMetaPTE, +- LineTime +- / 4.0))); ++ dml_max( ++ (MetaRowByte + PixelPTEBytesPerRow) ++ / *PrefetchBandwidth, ++ dml_max( ++ UrgentLatency, ++ dml_max( ++ LineTime ++ - TimeForFetchingMetaPTE, ++ LineTime ++ / 4.0))); + } else { + if (NumberOfCursors > 0 || XFCEnabled) + TimeForFetchingRowInVBlank = LineTime - TimeForFetchingMetaPTE; +@@ -1105,36 +1263,39 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + TimeForFetchingRowInVBlank = 0.0; + } + +- *DestinationLinesToRequestVMInVBlank = dml_floor(4.0 * (TimeForFetchingMetaPTE / LineTime + 0.125), +- 1) / 4.0; ++ *DestinationLinesToRequestVMInVBlank = dml_floor( ++ 4.0 * (TimeForFetchingMetaPTE / LineTime + 0.125), ++ 1) / 4.0; + +- *DestinationLinesToRequestRowInVBlank = dml_floor(4.0 * (TimeForFetchingRowInVBlank / LineTime + 0.125), +- 1) / 4.0; ++ *DestinationLinesToRequestRowInVBlank = dml_floor( ++ 4.0 * (TimeForFetchingRowInVBlank / LineTime + 0.125), ++ 1) / 4.0; + + LinesToRequestPrefetchPixelData = +- *DestinationLinesForPrefetch +- - ((NumberOfCursors > 0 || VirtualMemoryEnable +- || DCCEnable) ? +- (*DestinationLinesToRequestVMInVBlank +- + *DestinationLinesToRequestRowInVBlank) : +- 0.0); ++ *DestinationLinesForPrefetch ++ - ((NumberOfCursors > 0 || VirtualMemoryEnable ++ || DCCEnable) ? ++ (*DestinationLinesToRequestVMInVBlank ++ + *DestinationLinesToRequestRowInVBlank) : ++ 0.0); + + if (LinesToRequestPrefetchPixelData > 0) { + +- *VRatioPrefetchY = (double)PrefetchSourceLinesY +- / LinesToRequestPrefetchPixelData; ++ *VRatioPrefetchY = (double) PrefetchSourceLinesY ++ / LinesToRequestPrefetchPixelData; + *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); + if ((SwathHeightY > 4) && (VInitPreFillY > 3)) { + if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) { + *VRatioPrefetchY = +- dml_max((double)PrefetchSourceLinesY +- / LinesToRequestPrefetchPixelData, +- (double)MaxNumSwathY +- * SwathHeightY +- / (LinesToRequestPrefetchPixelData +- - (VInitPreFillY +- - 3.0) +- / 2.0)); ++ dml_max( ++ (double) PrefetchSourceLinesY ++ / LinesToRequestPrefetchPixelData, ++ (double) MaxNumSwathY ++ * SwathHeightY ++ / (LinesToRequestPrefetchPixelData ++ - (VInitPreFillY ++ - 3.0) ++ / 2.0)); + *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); + } else { + MyError = true; +@@ -1142,20 +1303,21 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + } + } + +- *VRatioPrefetchC = (double)PrefetchSourceLinesC +- / LinesToRequestPrefetchPixelData; ++ *VRatioPrefetchC = (double) PrefetchSourceLinesC ++ / LinesToRequestPrefetchPixelData; + *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); + + if ((SwathHeightC > 4)) { + if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) { + *VRatioPrefetchC = +- dml_max(*VRatioPrefetchC, +- (double)MaxNumSwathC +- * SwathHeightC +- / (LinesToRequestPrefetchPixelData +- - (VInitPreFillC +- - 3.0) +- / 2.0)); ++ dml_max( ++ *VRatioPrefetchC, ++ (double) MaxNumSwathC ++ * SwathHeightC ++ / (LinesToRequestPrefetchPixelData ++ - (VInitPreFillC ++ - 3.0) ++ / 2.0)); + *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); + } else { + MyError = true; +@@ -1164,17 +1326,19 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + } + + *RequiredPrefetchPixDataBW = +- DPPPerPlane +- * ((double)PrefetchSourceLinesY +- / LinesToRequestPrefetchPixelData +- * dml_ceil(BytePerPixelDETY, +- 1) +- + (double)PrefetchSourceLinesC +- / LinesToRequestPrefetchPixelData +- * dml_ceil(BytePerPixelDETC, +- 2) +- / 2) +- * SwathWidthY / LineTime; ++ DPPPerPlane ++ * ((double) PrefetchSourceLinesY ++ / LinesToRequestPrefetchPixelData ++ * dml_ceil( ++ BytePerPixelDETY, ++ 1) ++ + (double) PrefetchSourceLinesC ++ / LinesToRequestPrefetchPixelData ++ * dml_ceil( ++ BytePerPixelDETC, ++ 2) ++ / 2) ++ * SwathWidthY / LineTime; + } else { + MyError = true; + *VRatioPrefetchY = 0; +@@ -1202,25 +1366,26 @@ static bool CalculatePrefetchSchedule(struct display_mode_lib *mode_lib, + return MyError; + } + +-static double CeilToDFSGranularity(double Clock, double VCOSpeed) ++static double RoundToDFSGranularityUp(double Clock, double VCOSpeed) + { + return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1); + } + +-static double FloorToDFSGranularity(double Clock, double VCOSpeed) ++static double RoundToDFSGranularityDown(double Clock, double VCOSpeed) + { + return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4 / Clock, 1); + } + +-static double CalculatePrefetchSourceLines(struct display_mode_lib *mode_lib, +- double VRatio, +- double vtaps, +- bool Interlace, +- bool ProgressiveToInterlaceUnitInOPP, +- unsigned int SwathHeight, +- unsigned int ViewportYStart, +- double *VInitPreFill, +- unsigned int *MaxNumSwath) ++static double CalculatePrefetchSourceLines( ++ struct display_mode_lib *mode_lib, ++ double VRatio, ++ double vtaps, ++ bool Interlace, ++ bool ProgressiveToInterlaceUnitInOPP, ++ unsigned int SwathHeight, ++ unsigned int ViewportYStart, ++ double *VInitPreFill, ++ unsigned int *MaxNumSwath) + { + unsigned int MaxPartialSwath; + +@@ -1234,50 +1399,54 @@ static double CalculatePrefetchSourceLines(struct display_mode_lib *mode_lib, + *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0; + + if (*VInitPreFill > 1.0) +- MaxPartialSwath = (unsigned int)(*VInitPreFill - 2) % SwathHeight; ++ MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight; + else +- MaxPartialSwath = (unsigned int)(*VInitPreFill + SwathHeight - 2) % SwathHeight; ++ MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2) ++ % SwathHeight; + MaxPartialSwath = dml_max(1U, MaxPartialSwath); + + } else { + + if (ViewportYStart != 0) +- dml_print("WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n"); ++ dml_print( ++ "WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n"); + + *MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1); + + if (*VInitPreFill > 1.0) +- MaxPartialSwath = (unsigned int)(*VInitPreFill - 1) % SwathHeight; ++ MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight; + else +- MaxPartialSwath = (unsigned int)(*VInitPreFill + SwathHeight - 1) % SwathHeight; ++ MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1) ++ % SwathHeight; + } + + return *MaxNumSwath * SwathHeight + MaxPartialSwath; + } + +-static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, +- bool DCCEnable, +- unsigned int BlockHeight256Bytes, +- unsigned int BlockWidth256Bytes, +- enum source_format_class SourcePixelFormat, +- unsigned int SurfaceTiling, +- unsigned int BytePerPixel, +- enum scan_direction_class ScanDirection, +- unsigned int ViewportWidth, +- unsigned int ViewportHeight, +- unsigned int SwathWidth, +- bool VirtualMemoryEnable, +- unsigned int VMMPageSize, +- unsigned int PTEBufferSizeInRequests, +- unsigned int PDEProcessingBufIn64KBReqs, +- unsigned int Pitch, +- unsigned int DCCMetaPitch, +- unsigned int *MacroTileWidth, +- unsigned int *MetaRowByte, +- unsigned int *PixelPTEBytesPerRow, +- bool *PTEBufferSizeNotExceeded, +- unsigned int *dpte_row_height, +- unsigned int *meta_row_height) ++static unsigned int CalculateVMAndRowBytes( ++ struct display_mode_lib *mode_lib, ++ bool DCCEnable, ++ unsigned int BlockHeight256Bytes, ++ unsigned int BlockWidth256Bytes, ++ enum source_format_class SourcePixelFormat, ++ unsigned int SurfaceTiling, ++ unsigned int BytePerPixel, ++ enum scan_direction_class ScanDirection, ++ unsigned int ViewportWidth, ++ unsigned int ViewportHeight, ++ unsigned int SwathWidth, ++ bool VirtualMemoryEnable, ++ unsigned int VMMPageSize, ++ unsigned int PTEBufferSizeInRequests, ++ unsigned int PDEProcessingBufIn64KBReqs, ++ unsigned int Pitch, ++ unsigned int DCCMetaPitch, ++ unsigned int *MacroTileWidth, ++ unsigned int *MetaRowByte, ++ unsigned int *PixelPTEBytesPerRow, ++ bool *PTEBufferSizeNotExceeded, ++ unsigned int *dpte_row_height, ++ unsigned int *meta_row_height) + { + unsigned int MetaRequestHeight; + unsigned int MetaRequestWidth; +@@ -1298,31 +1467,33 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + MetaRequestWidth = 8 * BlockWidth256Bytes; + if (ScanDirection == dm_horz) { + *meta_row_height = MetaRequestHeight; +- MetaSurfWidth = dml_ceil((double)SwathWidth - 1, MetaRequestWidth) +- + MetaRequestWidth; ++ MetaSurfWidth = dml_ceil((double) SwathWidth - 1, MetaRequestWidth) ++ + MetaRequestWidth; + *MetaRowByte = MetaSurfWidth * MetaRequestHeight * BytePerPixel / 256.0; + } else { + *meta_row_height = MetaRequestWidth; +- MetaSurfHeight = dml_ceil((double)SwathWidth - 1, MetaRequestHeight) +- + MetaRequestHeight; ++ MetaSurfHeight = dml_ceil((double) SwathWidth - 1, MetaRequestHeight) ++ + MetaRequestHeight; + *MetaRowByte = MetaSurfHeight * MetaRequestWidth * BytePerPixel / 256.0; + } + if (ScanDirection == dm_horz) { + DCCMetaSurfaceBytes = DCCMetaPitch +- * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) +- + 64 * BlockHeight256Bytes) * BytePerPixel +- / 256; ++ * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) ++ + 64 * BlockHeight256Bytes) * BytePerPixel ++ / 256; + } else { + DCCMetaSurfaceBytes = DCCMetaPitch +- * (dml_ceil((double)ViewportHeight - 1, +- 64 * BlockHeight256Bytes) +- + 64 * BlockHeight256Bytes) * BytePerPixel +- / 256; ++ * (dml_ceil( ++ (double) ViewportHeight - 1, ++ 64 * BlockHeight256Bytes) ++ + 64 * BlockHeight256Bytes) * BytePerPixel ++ / 256; + } + if (VirtualMemoryEnable == true) { +- MetaPTEBytesFrame = (dml_ceil((double)(DCCMetaSurfaceBytes - VMMPageSize) +- / (8 * VMMPageSize), +- 1) + 1) * 64; ++ MetaPTEBytesFrame = (dml_ceil( ++ (double) (DCCMetaSurfaceBytes - VMMPageSize) ++ / (8 * VMMPageSize), ++ 1) + 1) * 64; + MPDEBytesFrame = 128 * (mode_lib->vba.MaxPageTableLevels - 1); + } else { + MetaPTEBytesFrame = 0; +@@ -1338,13 +1509,13 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + MacroTileSizeBytes = 256; + MacroTileHeight = 1; + } else if (SurfaceTiling == dm_sw_4kb_s || SurfaceTiling == dm_sw_4kb_s_x +- || SurfaceTiling == dm_sw_4kb_d || SurfaceTiling == dm_sw_4kb_d_x) { ++ || SurfaceTiling == dm_sw_4kb_d || SurfaceTiling == dm_sw_4kb_d_x) { + MacroTileSizeBytes = 4096; + MacroTileHeight = 4 * BlockHeight256Bytes; + } else if (SurfaceTiling == dm_sw_64kb_s || SurfaceTiling == dm_sw_64kb_s_t +- || SurfaceTiling == dm_sw_64kb_s_x || SurfaceTiling == dm_sw_64kb_d +- || SurfaceTiling == dm_sw_64kb_d_t || SurfaceTiling == dm_sw_64kb_d_x +- || SurfaceTiling == dm_sw_64kb_r_x) { ++ || SurfaceTiling == dm_sw_64kb_s_x || SurfaceTiling == dm_sw_64kb_d ++ || SurfaceTiling == dm_sw_64kb_d_t || SurfaceTiling == dm_sw_64kb_d_x ++ || SurfaceTiling == dm_sw_64kb_r_x) { + MacroTileSizeBytes = 65536; + MacroTileHeight = 16 * BlockHeight256Bytes; + } else { +@@ -1356,30 +1527,34 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + if (VirtualMemoryEnable == true && mode_lib->vba.MaxPageTableLevels > 1) { + if (ScanDirection == dm_horz) { + DPDE0BytesFrame = +- 64 +- * (dml_ceil(((Pitch +- * (dml_ceil(ViewportHeight +- - 1, +- MacroTileHeight) +- + MacroTileHeight) +- * BytePerPixel) +- - MacroTileSizeBytes) +- / (8 +- * 2097152), +- 1) + 1); ++ 64 ++ * (dml_ceil( ++ ((Pitch ++ * (dml_ceil( ++ ViewportHeight ++ - 1, ++ MacroTileHeight) ++ + MacroTileHeight) ++ * BytePerPixel) ++ - MacroTileSizeBytes) ++ / (8 ++ * 2097152), ++ 1) + 1); + } else { + DPDE0BytesFrame = +- 64 +- * (dml_ceil(((Pitch +- * (dml_ceil((double)SwathWidth +- - 1, +- MacroTileHeight) +- + MacroTileHeight) +- * BytePerPixel) +- - MacroTileSizeBytes) +- / (8 +- * 2097152), +- 1) + 1); ++ 64 ++ * (dml_ceil( ++ ((Pitch ++ * (dml_ceil( ++ (double) SwathWidth ++ - 1, ++ MacroTileHeight) ++ + MacroTileHeight) ++ * BytePerPixel) ++ - MacroTileSizeBytes) ++ / (8 ++ * 2097152), ++ 1) + 1); + } + ExtraDPDEBytesFrame = 128 * (mode_lib->vba.MaxPageTableLevels - 2); + } else { +@@ -1388,7 +1563,7 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + } + + PDEAndMetaPTEBytesFrame = MetaPTEBytesFrame + MPDEBytesFrame + DPDE0BytesFrame +- + ExtraDPDEBytesFrame; ++ + ExtraDPDEBytesFrame; + + if (VirtualMemoryEnable == true) { + unsigned int PTERequestSize; +@@ -1429,33 +1604,39 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + + if (SurfaceTiling == dm_sw_linear) { + *dpte_row_height = +- dml_min(128, +- 1 +- << (unsigned int)dml_floor(dml_log2(dml_min((double)PTEBufferSizeInRequests +- * PixelPTEReqWidth, +- EffectivePDEProcessingBufIn64KBReqs +- * 65536.0 +- / BytePerPixel) +- / Pitch), +- 1)); ++ dml_min( ++ 128, ++ 1 ++ << (unsigned int) dml_floor( ++ dml_log2( ++ dml_min( ++ (double) PTEBufferSizeInRequests ++ * PixelPTEReqWidth, ++ EffectivePDEProcessingBufIn64KBReqs ++ * 65536.0 ++ / BytePerPixel) ++ / Pitch), ++ 1)); + *PixelPTEBytesPerRow = PTERequestSize +- * (dml_ceil((double)(Pitch * *dpte_row_height - 1) +- / PixelPTEReqWidth, +- 1) + 1); ++ * (dml_ceil( ++ (double) (Pitch * *dpte_row_height - 1) ++ / PixelPTEReqWidth, ++ 1) + 1); + } else if (ScanDirection == dm_horz) { + *dpte_row_height = PixelPTEReqHeight; + *PixelPTEBytesPerRow = PTERequestSize +- * (dml_ceil(((double)SwathWidth - 1) / PixelPTEReqWidth, 1) +- + 1); ++ * (dml_ceil(((double) SwathWidth - 1) / PixelPTEReqWidth, 1) ++ + 1); + } else { + *dpte_row_height = dml_min(PixelPTEReqWidth, *MacroTileWidth); + *PixelPTEBytesPerRow = PTERequestSize +- * (dml_ceil(((double)SwathWidth - 1) +- / PixelPTEReqHeight, +- 1) + 1); ++ * (dml_ceil( ++ ((double) SwathWidth - 1) ++ / PixelPTEReqHeight, ++ 1) + 1); + } + if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop) +- <= 64 * PTEBufferSizeInRequests) { ++ <= 64 * PTEBufferSizeInRequests) { + *PTEBufferSizeNotExceeded = true; + } else { + *PTEBufferSizeNotExceeded = false; +@@ -1468,7 +1649,8 @@ static unsigned int CalculateVMAndRowBytes(struct display_mode_lib *mode_lib, + return PDEAndMetaPTEBytesFrame; + } + +-static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(struct display_mode_lib *mode_lib) ++static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation( ++ struct display_mode_lib *mode_lib) + { + unsigned int j, k; + +@@ -1481,81 +1663,107 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + // + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.WritebackEnable[k]) { +- mode_lib->vba.WritebackDISPCLK = dml_max(mode_lib->vba.WritebackDISPCLK, +- CalculateWriteBackDISPCLK(mode_lib->vba.WritebackPixelFormat[k], +- mode_lib->vba.PixelClock[k], +- mode_lib->vba.WritebackHRatio[k], +- mode_lib->vba.WritebackVRatio[k], +- mode_lib->vba.WritebackLumaHTaps[k], +- mode_lib->vba.WritebackLumaVTaps[k], +- mode_lib->vba.WritebackChromaHTaps[k], +- mode_lib->vba.WritebackChromaVTaps[k], +- mode_lib->vba.WritebackDestinationWidth[k], +- mode_lib->vba.HTotal[k], +- mode_lib->vba.WritebackChromaLineBufferWidth)); ++ mode_lib->vba.WritebackDISPCLK = ++ dml_max( ++ mode_lib->vba.WritebackDISPCLK, ++ CalculateWriteBackDISPCLK( ++ mode_lib->vba.WritebackPixelFormat[k], ++ mode_lib->vba.PixelClock[k], ++ mode_lib->vba.WritebackHRatio[k], ++ mode_lib->vba.WritebackVRatio[k], ++ mode_lib->vba.WritebackLumaHTaps[k], ++ mode_lib->vba.WritebackLumaVTaps[k], ++ mode_lib->vba.WritebackChromaHTaps[k], ++ mode_lib->vba.WritebackChromaVTaps[k], ++ mode_lib->vba.WritebackDestinationWidth[k], ++ mode_lib->vba.HTotal[k], ++ mode_lib->vba.WritebackChromaLineBufferWidth)); + } + } + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.HRatio[k] > 1) { +- mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(mode_lib->vba.MaxDCHUBToPSCLThroughput, +- mode_lib->vba.MaxPSCLToLBThroughput * mode_lib->vba.HRatio[k] +- / dml_ceil(mode_lib->vba.htaps[k] / 6.0, 1)); ++ mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput ++ * mode_lib->vba.HRatio[k] ++ / dml_ceil( ++ mode_lib->vba.htaps[k] ++ / 6.0, ++ 1)); + } else { +- mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(mode_lib->vba.MaxDCHUBToPSCLThroughput, +- mode_lib->vba.MaxPSCLToLBThroughput); ++ mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput); + } + + mode_lib->vba.DPPCLKUsingSingleDPPLuma = +- mode_lib->vba.PixelClock[k] +- * dml_max(mode_lib->vba.vtaps[k] / 6.0 +- * dml_min(1.0, +- mode_lib->vba.HRatio[k]), +- dml_max(mode_lib->vba.HRatio[k] +- * mode_lib->vba.VRatio[k] +- / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k], +- 1.0)); ++ mode_lib->vba.PixelClock[k] ++ * dml_max( ++ mode_lib->vba.vtaps[k] / 6.0 ++ * dml_min( ++ 1.0, ++ mode_lib->vba.HRatio[k]), ++ dml_max( ++ mode_lib->vba.HRatio[k] ++ * mode_lib->vba.VRatio[k] ++ / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k], ++ 1.0)); + + if ((mode_lib->vba.htaps[k] > 6 || mode_lib->vba.vtaps[k] > 6) +- && mode_lib->vba.DPPCLKUsingSingleDPPLuma < 2 * mode_lib->vba.PixelClock[k]) { ++ && mode_lib->vba.DPPCLKUsingSingleDPPLuma ++ < 2 * mode_lib->vba.PixelClock[k]) { + mode_lib->vba.DPPCLKUsingSingleDPPLuma = 2 * mode_lib->vba.PixelClock[k]; + } + +- if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { ++ if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { + mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = 0.0; +- mode_lib->vba.DPPCLKUsingSingleDPP[k] = mode_lib->vba.DPPCLKUsingSingleDPPLuma; ++ mode_lib->vba.DPPCLKUsingSingleDPP[k] = ++ mode_lib->vba.DPPCLKUsingSingleDPPLuma; + } else { + if (mode_lib->vba.HRatio[k] > 1) { + mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = +- dml_min(mode_lib->vba.MaxDCHUBToPSCLThroughput, +- mode_lib->vba.MaxPSCLToLBThroughput * mode_lib->vba.HRatio[k] +- / 2 +- / dml_ceil(mode_lib->vba.HTAPsChroma[k] +- / 6.0, +- 1.0)); ++ dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput ++ * mode_lib->vba.HRatio[k] ++ / 2 ++ / dml_ceil( ++ mode_lib->vba.HTAPsChroma[k] ++ / 6.0, ++ 1.0)); + } else { +- mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = dml_min(mode_lib->vba.MaxDCHUBToPSCLThroughput, +- mode_lib->vba.MaxPSCLToLBThroughput); ++ mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput); + } + mode_lib->vba.DPPCLKUsingSingleDPPChroma = +- mode_lib->vba.PixelClock[k] +- * dml_max(mode_lib->vba.VTAPsChroma[k] / 6.0 +- * dml_min(1.0, +- mode_lib->vba.HRatio[k] +- / 2), +- dml_max(mode_lib->vba.HRatio[k] +- * mode_lib->vba.VRatio[k] +- / 4 +- / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k], +- 1.0)); ++ mode_lib->vba.PixelClock[k] ++ * dml_max( ++ mode_lib->vba.VTAPsChroma[k] ++ / 6.0 ++ * dml_min( ++ 1.0, ++ mode_lib->vba.HRatio[k] ++ / 2), ++ dml_max( ++ mode_lib->vba.HRatio[k] ++ * mode_lib->vba.VRatio[k] ++ / 4 ++ / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k], ++ 1.0)); + + if ((mode_lib->vba.HTAPsChroma[k] > 6 || mode_lib->vba.VTAPsChroma[k] > 6) +- && mode_lib->vba.DPPCLKUsingSingleDPPChroma < 2 * mode_lib->vba.PixelClock[k]) { +- mode_lib->vba.DPPCLKUsingSingleDPPChroma = 2 * mode_lib->vba.PixelClock[k]; ++ && mode_lib->vba.DPPCLKUsingSingleDPPChroma ++ < 2 * mode_lib->vba.PixelClock[k]) { ++ mode_lib->vba.DPPCLKUsingSingleDPPChroma = 2 ++ * mode_lib->vba.PixelClock[k]; + } + +- mode_lib->vba.DPPCLKUsingSingleDPP[k] = dml_max(mode_lib->vba.DPPCLKUsingSingleDPPLuma, +- mode_lib->vba.DPPCLKUsingSingleDPPChroma); ++ mode_lib->vba.DPPCLKUsingSingleDPP[k] = dml_max( ++ mode_lib->vba.DPPCLKUsingSingleDPPLuma, ++ mode_lib->vba.DPPCLKUsingSingleDPPChroma); + } + } + +@@ -1564,67 +1772,90 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + continue; + if (mode_lib->vba.ODMCombineEnabled[k]) { + mode_lib->vba.DISPCLKWithRamping = +- dml_max(mode_lib->vba.DISPCLKWithRamping, +- mode_lib->vba.PixelClock[k] / 2 +- * (1 +- + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading +- / 100) +- * (1 +- + mode_lib->vba.DISPCLKRampingMargin +- / 100)); ++ dml_max( ++ mode_lib->vba.DISPCLKWithRamping, ++ mode_lib->vba.PixelClock[k] / 2 ++ * (1 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100) ++ * (1 ++ + mode_lib->vba.DISPCLKRampingMargin ++ / 100)); + mode_lib->vba.DISPCLKWithoutRamping = +- dml_max(mode_lib->vba.DISPCLKWithoutRamping, +- mode_lib->vba.PixelClock[k] / 2 +- * (1 +- + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading +- / 100)); ++ dml_max( ++ mode_lib->vba.DISPCLKWithoutRamping, ++ mode_lib->vba.PixelClock[k] / 2 ++ * (1 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100)); + } else if (!mode_lib->vba.ODMCombineEnabled[k]) { +- mode_lib->vba.DISPCLKWithRamping = dml_max(mode_lib->vba.DISPCLKWithRamping, +- mode_lib->vba.PixelClock[k] * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100) +- * (1 + mode_lib->vba.DISPCLKRampingMargin / 100)); ++ mode_lib->vba.DISPCLKWithRamping = ++ dml_max( ++ mode_lib->vba.DISPCLKWithRamping, ++ mode_lib->vba.PixelClock[k] ++ * (1 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100) ++ * (1 ++ + mode_lib->vba.DISPCLKRampingMargin ++ / 100)); + mode_lib->vba.DISPCLKWithoutRamping = +- dml_max(mode_lib->vba.DISPCLKWithoutRamping, +- mode_lib->vba.PixelClock[k] +- * (1 +- + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading +- / 100)); ++ dml_max( ++ mode_lib->vba.DISPCLKWithoutRamping, ++ mode_lib->vba.PixelClock[k] ++ * (1 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100)); + } + } + +- mode_lib->vba.DISPCLKWithRamping = dml_max(mode_lib->vba.DISPCLKWithRamping, mode_lib->vba.WritebackDISPCLK); +- mode_lib->vba.DISPCLKWithoutRamping = dml_max(mode_lib->vba.DISPCLKWithoutRamping, mode_lib->vba.WritebackDISPCLK); ++ mode_lib->vba.DISPCLKWithRamping = dml_max( ++ mode_lib->vba.DISPCLKWithRamping, ++ mode_lib->vba.WritebackDISPCLK); ++ mode_lib->vba.DISPCLKWithoutRamping = dml_max( ++ mode_lib->vba.DISPCLKWithoutRamping, ++ mode_lib->vba.WritebackDISPCLK); + +- mode_lib->vba.MaxDispclk = mode_lib->vba.soc.clock_limits[NumberOfStates - 1].dispclk_mhz; + ASSERT(mode_lib->vba.DISPCLKDPPCLKVCOSpeed != 0); +- mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity = CeilToDFSGranularity( ++ mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp( + mode_lib->vba.DISPCLKWithRamping, + mode_lib->vba.DISPCLKDPPCLKVCOSpeed); +- mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity = CeilToDFSGranularity( ++ mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp( + mode_lib->vba.DISPCLKWithoutRamping, + mode_lib->vba.DISPCLKDPPCLKVCOSpeed); +- mode_lib->vba.MaxDispclkRoundedToDFSGranularity = FloorToDFSGranularity( +- mode_lib->vba.MaxDispclk, ++ mode_lib->vba.MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown( ++ mode_lib->vba.soc.clock_limits[NumberOfStates - 1].dispclk_mhz, + mode_lib->vba.DISPCLKDPPCLKVCOSpeed); + if (mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity +- > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { +- mode_lib->vba.DISPCLK_calculated = mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity; ++ > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { ++ mode_lib->vba.DISPCLK_calculated = ++ mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity; + } else if (mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity +- > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { ++ > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { + mode_lib->vba.DISPCLK_calculated = mode_lib->vba.MaxDispclkRoundedToDFSGranularity; + } else { +- mode_lib->vba.DISPCLK_calculated = mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity; ++ mode_lib->vba.DISPCLK_calculated = ++ mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity; + } + DTRACE(" dispclk_mhz (calculated) = %f", mode_lib->vba.DISPCLK_calculated); + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.DPPCLKUsingSingleDPP[k] / mode_lib->vba.DPPPerPlane[k] +- * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100); +- mode_lib->vba.GlobalDPPCLK = dml_max(mode_lib->vba.GlobalDPPCLK, mode_lib->vba.DPPCLK_calculated[k]); ++ mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.DPPCLKUsingSingleDPP[k] ++ / mode_lib->vba.DPPPerPlane[k] ++ * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100); ++ mode_lib->vba.GlobalDPPCLK = dml_max( ++ mode_lib->vba.GlobalDPPCLK, ++ mode_lib->vba.DPPCLK_calculated[k]); + } +- mode_lib->vba.GlobalDPPCLK = CeilToDFSGranularity(mode_lib->vba.GlobalDPPCLK, mode_lib->vba.DISPCLKDPPCLKVCOSpeed); ++ mode_lib->vba.GlobalDPPCLK = RoundToDFSGranularityUp( ++ mode_lib->vba.GlobalDPPCLK, ++ mode_lib->vba.DISPCLKDPPCLKVCOSpeed); + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.GlobalDPPCLK / 255 +- * dml_ceil(mode_lib->vba.DPPCLK_calculated[k] * 255 / mode_lib->vba.GlobalDPPCLK, 1); ++ * dml_ceil( ++ mode_lib->vba.DPPCLK_calculated[k] * 255 ++ / mode_lib->vba.GlobalDPPCLK, ++ 1); + DTRACE(" dppclk_mhz[%i] (calculated) = %f", k, mode_lib->vba.DPPCLK_calculated[k]); + } + +@@ -1634,15 +1865,27 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + if (mode_lib->vba.DCCEnable[k]) + mode_lib->vba.DCCEnabledAnyPlane = true; + +- mode_lib->vba.ReturnBandwidthToDCN = dml_min(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, mode_lib->vba.FabricAndDRAMBandwidth * 1000) +- * mode_lib->vba.PercentOfIdealDRAMAndFabricBWReceivedAfterUrgLatency / 100; ++ mode_lib->vba.ReturnBandwidthToDCN = dml_min( ++ mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, ++ mode_lib->vba.FabricAndDRAMBandwidth * 1000) ++ * mode_lib->vba.PercentOfIdealDRAMAndFabricBWReceivedAfterUrgLatency / 100; + + mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBandwidthToDCN; +- mode_lib->vba.ReturnBW = adjust_ReturnBW(mode_lib, mode_lib->vba.ReturnBW, mode_lib->vba.DCCEnabledAnyPlane, mode_lib->vba.ReturnBandwidthToDCN); ++ mode_lib->vba.ReturnBW = adjust_ReturnBW( ++ mode_lib, ++ mode_lib->vba.ReturnBW, ++ mode_lib->vba.DCCEnabledAnyPlane, ++ mode_lib->vba.ReturnBandwidthToDCN); + + // Let's do this calculation again?? +- mode_lib->vba.ReturnBandwidthToDCN = dml_min(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, mode_lib->vba.FabricAndDRAMBandwidth * 1000); +- mode_lib->vba.ReturnBW = adjust_ReturnBW(mode_lib, mode_lib->vba.ReturnBW, mode_lib->vba.DCCEnabledAnyPlane, mode_lib->vba.ReturnBandwidthToDCN); ++ mode_lib->vba.ReturnBandwidthToDCN = dml_min( ++ mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, ++ mode_lib->vba.FabricAndDRAMBandwidth * 1000); ++ mode_lib->vba.ReturnBW = adjust_ReturnBW( ++ mode_lib, ++ mode_lib->vba.ReturnBW, ++ mode_lib->vba.DCCEnabledAnyPlane, ++ mode_lib->vba.ReturnBandwidthToDCN); + + DTRACE(" dcfclk_mhz = %f", mode_lib->vba.DCFCLK); + DTRACE(" return_bw_to_dcn = %f", mode_lib->vba.ReturnBandwidthToDCN); +@@ -1659,14 +1902,19 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + if (mode_lib->vba.ODMCombineEnabled[k] == true) + MainPlaneDoesODMCombine = true; + for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) +- if (mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.ODMCombineEnabled[j] == true) ++ if (mode_lib->vba.BlendingAndTiming[k] == j ++ && mode_lib->vba.ODMCombineEnabled[j] == true) + MainPlaneDoesODMCombine = true; + + if (MainPlaneDoesODMCombine == true) +- mode_lib->vba.SwathWidthY[k] = dml_min((double)mode_lib->vba.SwathWidthSingleDPPY[k], +- dml_round(mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k])); ++ mode_lib->vba.SwathWidthY[k] = dml_min( ++ (double) mode_lib->vba.SwathWidthSingleDPPY[k], ++ dml_round( ++ mode_lib->vba.HActive[k] / 2.0 ++ * mode_lib->vba.HRatio[k])); + else +- mode_lib->vba.SwathWidthY[k] = mode_lib->vba.SwathWidthSingleDPPY[k] / mode_lib->vba.DPPPerPlane[k]; ++ mode_lib->vba.SwathWidthY[k] = mode_lib->vba.SwathWidthSingleDPPY[k] ++ / mode_lib->vba.DPPPerPlane[k]; + } + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +@@ -1694,76 +1942,104 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + mode_lib->vba.TotalDataReadBandwidth = 0.0; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.ReadBandwidthPlaneLuma[k] = mode_lib->vba.SwathWidthSingleDPPY[k] +- * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) +- * mode_lib->vba.VRatio[k]; +- mode_lib->vba.ReadBandwidthPlaneChroma[k] = mode_lib->vba.SwathWidthSingleDPPY[k] / 2 +- * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) +- * mode_lib->vba.VRatio[k] / 2; +- DTRACE(" read_bw[%i] = %fBps", +- k, +- mode_lib->vba.ReadBandwidthPlaneLuma[k] + mode_lib->vba.ReadBandwidthPlaneChroma[k]); ++ * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) ++ / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ * mode_lib->vba.VRatio[k]; ++ mode_lib->vba.ReadBandwidthPlaneChroma[k] = mode_lib->vba.SwathWidthSingleDPPY[k] ++ / 2 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) ++ / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ * mode_lib->vba.VRatio[k] / 2; ++ DTRACE( ++ " read_bw[%i] = %fBps", ++ k, ++ mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k]); + mode_lib->vba.TotalDataReadBandwidth += mode_lib->vba.ReadBandwidthPlaneLuma[k] +- + mode_lib->vba.ReadBandwidthPlaneChroma[k]; ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k]; + } + + mode_lib->vba.TotalDCCActiveDPP = 0; + mode_lib->vba.TotalActiveDPP = 0; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + mode_lib->vba.DPPPerPlane[k]; ++ mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP ++ + mode_lib->vba.DPPPerPlane[k]; + if (mode_lib->vba.DCCEnable[k]) +- mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP + mode_lib->vba.DPPPerPlane[k]; ++ mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP ++ + mode_lib->vba.DPPPerPlane[k]; + } + +- mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency = (mode_lib->vba.RoundTripPingLatencyCycles + 32) / mode_lib->vba.DCFCLK +- + mode_lib->vba.UrgentOutOfOrderReturnPerChannel * mode_lib->vba.NumberOfChannels / mode_lib->vba.ReturnBW; ++ mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency = ++ (mode_lib->vba.RoundTripPingLatencyCycles + 32) / mode_lib->vba.DCFCLK ++ + mode_lib->vba.UrgentOutOfOrderReturnPerChannel ++ * mode_lib->vba.NumberOfChannels ++ / mode_lib->vba.ReturnBW; + + mode_lib->vba.LastPixelOfLineExtraWatermark = 0; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + double DataFabricLineDeliveryTimeLuma, DataFabricLineDeliveryTimeChroma; + + if (mode_lib->vba.VRatio[k] <= 1.0) +- mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = (double)mode_lib->vba.SwathWidthY[k] +- * mode_lib->vba.DPPPerPlane[k] / mode_lib->vba.HRatio[k] / mode_lib->vba.PixelClock[k]; ++ mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = ++ (double) mode_lib->vba.SwathWidthY[k] ++ * mode_lib->vba.DPPPerPlane[k] ++ / mode_lib->vba.HRatio[k] ++ / mode_lib->vba.PixelClock[k]; + else +- mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = (double)mode_lib->vba.SwathWidthY[k] +- / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] / mode_lib->vba.DPPCLK[k]; +- +- DataFabricLineDeliveryTimeLuma = +- mode_lib->vba.SwathWidthSingleDPPY[k] * mode_lib->vba.SwathHeightY[k] +- * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) +- / (mode_lib->vba.ReturnBW * mode_lib->vba.ReadBandwidthPlaneLuma[k] +- / mode_lib->vba.TotalDataReadBandwidth); +- mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max(mode_lib->vba.LastPixelOfLineExtraWatermark, +- DataFabricLineDeliveryTimeLuma +- - mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]); ++ mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = ++ (double) mode_lib->vba.SwathWidthY[k] ++ / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] ++ / mode_lib->vba.DPPCLK[k]; ++ ++ DataFabricLineDeliveryTimeLuma = mode_lib->vba.SwathWidthSingleDPPY[k] ++ * mode_lib->vba.SwathHeightY[k] ++ * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) ++ / (mode_lib->vba.ReturnBW * mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ / mode_lib->vba.TotalDataReadBandwidth); ++ mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max( ++ mode_lib->vba.LastPixelOfLineExtraWatermark, ++ DataFabricLineDeliveryTimeLuma ++ - mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]); + + if (mode_lib->vba.BytePerPixelDETC[k] == 0) + mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 0.0; + else if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) +- mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = mode_lib->vba.SwathWidthY[k] / 2.0 +- * mode_lib->vba.DPPPerPlane[k] / (mode_lib->vba.HRatio[k] / 2.0) / mode_lib->vba.PixelClock[k]; ++ mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = ++ mode_lib->vba.SwathWidthY[k] / 2.0 ++ * mode_lib->vba.DPPPerPlane[k] ++ / (mode_lib->vba.HRatio[k] / 2.0) ++ / mode_lib->vba.PixelClock[k]; + else +- mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = mode_lib->vba.SwathWidthY[k] / 2.0 +- / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] / mode_lib->vba.DPPCLK[k]; ++ mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = ++ mode_lib->vba.SwathWidthY[k] / 2.0 ++ / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] ++ / mode_lib->vba.DPPCLK[k]; + + DataFabricLineDeliveryTimeChroma = mode_lib->vba.SwathWidthSingleDPPY[k] / 2.0 +- * mode_lib->vba.SwathHeightC[k] * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) +- / (mode_lib->vba.ReturnBW * mode_lib->vba.ReadBandwidthPlaneChroma[k] +- / mode_lib->vba.TotalDataReadBandwidth); +- mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max(mode_lib->vba.LastPixelOfLineExtraWatermark, +- DataFabricLineDeliveryTimeChroma +- - mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); ++ * mode_lib->vba.SwathHeightC[k] ++ * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) ++ / (mode_lib->vba.ReturnBW ++ * mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ / mode_lib->vba.TotalDataReadBandwidth); ++ mode_lib->vba.LastPixelOfLineExtraWatermark = ++ dml_max( ++ mode_lib->vba.LastPixelOfLineExtraWatermark, ++ DataFabricLineDeliveryTimeChroma ++ - mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); + } + + mode_lib->vba.UrgentExtraLatency = mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency +- + (mode_lib->vba.TotalActiveDPP * mode_lib->vba.PixelChunkSizeInKByte +- + mode_lib->vba.TotalDCCActiveDPP * mode_lib->vba.MetaChunkSize) * 1024.0 +- / mode_lib->vba.ReturnBW; ++ + (mode_lib->vba.TotalActiveDPP * mode_lib->vba.PixelChunkSizeInKByte ++ + mode_lib->vba.TotalDCCActiveDPP ++ * mode_lib->vba.MetaChunkSize) * 1024.0 ++ / mode_lib->vba.ReturnBW; + + if (mode_lib->vba.VirtualMemoryEnable) +- mode_lib->vba.UrgentExtraLatency += mode_lib->vba.TotalActiveDPP * mode_lib->vba.PTEChunkSize * 1024.0 / mode_lib->vba.ReturnBW; ++ mode_lib->vba.UrgentExtraLatency += mode_lib->vba.TotalActiveDPP ++ * mode_lib->vba.PTEChunkSize * 1024.0 / mode_lib->vba.ReturnBW; + +- mode_lib->vba.UrgentWatermark = mode_lib->vba.UrgentLatency + mode_lib->vba.LastPixelOfLineExtraWatermark + mode_lib->vba.UrgentExtraLatency; ++ mode_lib->vba.UrgentWatermark = mode_lib->vba.UrgentLatency ++ + mode_lib->vba.LastPixelOfLineExtraWatermark ++ + mode_lib->vba.UrgentExtraLatency; + + DTRACE(" urgent_extra_latency = %fus", mode_lib->vba.UrgentExtraLatency); + DTRACE(" wm_urgent = %fus", mode_lib->vba.UrgentWatermark); +@@ -1780,12 +2056,14 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency; + else + mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency +- + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 / mode_lib->vba.SOCCLK; ++ + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 ++ / mode_lib->vba.SOCCLK; + + DTRACE(" wm_wb_urgent = %fus", mode_lib->vba.WritebackUrgentWatermark); + + // NB P-State/DRAM Clock Change Watermark +- mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency + mode_lib->vba.UrgentWatermark; ++ mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency ++ + mode_lib->vba.UrgentWatermark; + + DTRACE(" wm_pstate_change = %fus", mode_lib->vba.DRAMClockChangeWatermark); + +@@ -1794,28 +2072,42 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + DTRACE(" socclk frequency %f Mhz", mode_lib->vba.SOCCLK); + + if (mode_lib->vba.TotalActiveWriteback <= 1) +- mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency + mode_lib->vba.WritebackLatency; ++ mode_lib->vba.WritebackDRAMClockChangeWatermark = ++ mode_lib->vba.DRAMClockChangeLatency ++ + mode_lib->vba.WritebackLatency; + else +- mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency + mode_lib->vba.WritebackLatency +- + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 / mode_lib->vba.SOCCLK; ++ mode_lib->vba.WritebackDRAMClockChangeWatermark = ++ mode_lib->vba.DRAMClockChangeLatency ++ + mode_lib->vba.WritebackLatency ++ + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 ++ / mode_lib->vba.SOCCLK; + + DTRACE(" wm_wb_pstate %fus", mode_lib->vba.WritebackDRAMClockChangeWatermark); + + // Stutter Efficiency + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- mode_lib->vba.LinesInDETY[k] = mode_lib->vba.DETBufferSizeY[k] / mode_lib->vba.BytePerPixelDETY[k] +- / mode_lib->vba.SwathWidthY[k]; +- mode_lib->vba.LinesInDETYRoundedDownToSwath[k] = dml_floor(mode_lib->vba.LinesInDETY[k], +- mode_lib->vba.SwathHeightY[k]); +- mode_lib->vba.FullDETBufferingTimeY[k] = mode_lib->vba.LinesInDETYRoundedDownToSwath[k] +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) / mode_lib->vba.VRatio[k]; ++ mode_lib->vba.LinesInDETY[k] = mode_lib->vba.DETBufferSizeY[k] ++ / mode_lib->vba.BytePerPixelDETY[k] / mode_lib->vba.SwathWidthY[k]; ++ mode_lib->vba.LinesInDETYRoundedDownToSwath[k] = dml_floor( ++ mode_lib->vba.LinesInDETY[k], ++ mode_lib->vba.SwathHeightY[k]); ++ mode_lib->vba.FullDETBufferingTimeY[k] = ++ mode_lib->vba.LinesInDETYRoundedDownToSwath[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / mode_lib->vba.VRatio[k]; + if (mode_lib->vba.BytePerPixelDETC[k] > 0) { +- mode_lib->vba.LinesInDETC[k] = mode_lib->vba.DETBufferSizeC[k] / mode_lib->vba.BytePerPixelDETC[k] +- / (mode_lib->vba.SwathWidthY[k] / 2); +- mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = dml_floor(mode_lib->vba.LinesInDETC[k], +- mode_lib->vba.SwathHeightC[k]); +- mode_lib->vba.FullDETBufferingTimeC[k] = mode_lib->vba.LinesInDETCRoundedDownToSwath[k] +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) / (mode_lib->vba.VRatio[k] / 2); ++ mode_lib->vba.LinesInDETC[k] = mode_lib->vba.DETBufferSizeC[k] ++ / mode_lib->vba.BytePerPixelDETC[k] ++ / (mode_lib->vba.SwathWidthY[k] / 2); ++ mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = dml_floor( ++ mode_lib->vba.LinesInDETC[k], ++ mode_lib->vba.SwathHeightC[k]); ++ mode_lib->vba.FullDETBufferingTimeC[k] = ++ mode_lib->vba.LinesInDETCRoundedDownToSwath[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / (mode_lib->vba.VRatio[k] / 2); + } else { + mode_lib->vba.LinesInDETC[k] = 0; + mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = 0; +@@ -1825,15 +2117,21 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + + mode_lib->vba.MinFullDETBufferingTime = 999999.0; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- if (mode_lib->vba.FullDETBufferingTimeY[k] < mode_lib->vba.MinFullDETBufferingTime) { +- mode_lib->vba.MinFullDETBufferingTime = mode_lib->vba.FullDETBufferingTimeY[k]; +- mode_lib->vba.FrameTimeForMinFullDETBufferingTime = (double)mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]; ++ if (mode_lib->vba.FullDETBufferingTimeY[k] ++ < mode_lib->vba.MinFullDETBufferingTime) { ++ mode_lib->vba.MinFullDETBufferingTime = ++ mode_lib->vba.FullDETBufferingTimeY[k]; ++ mode_lib->vba.FrameTimeForMinFullDETBufferingTime = ++ (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]; + } +- if (mode_lib->vba.FullDETBufferingTimeC[k] < mode_lib->vba.MinFullDETBufferingTime) { +- mode_lib->vba.MinFullDETBufferingTime = mode_lib->vba.FullDETBufferingTimeC[k]; +- mode_lib->vba.FrameTimeForMinFullDETBufferingTime = (double)mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]; ++ if (mode_lib->vba.FullDETBufferingTimeC[k] ++ < mode_lib->vba.MinFullDETBufferingTime) { ++ mode_lib->vba.MinFullDETBufferingTime = ++ mode_lib->vba.FullDETBufferingTimeC[k]; ++ mode_lib->vba.FrameTimeForMinFullDETBufferingTime = ++ (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]; + } + } + +@@ -1841,45 +2139,58 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.DCCEnable[k]) { + mode_lib->vba.AverageReadBandwidthGBytePerSecond = +- mode_lib->vba.AverageReadBandwidthGBytePerSecond +- + mode_lib->vba.ReadBandwidthPlaneLuma[k] / mode_lib->vba.DCCRate[k] +- / 1000 +- + mode_lib->vba.ReadBandwidthPlaneChroma[k] +- / mode_lib->vba.DCCRate[k] / 1000; ++ mode_lib->vba.AverageReadBandwidthGBytePerSecond ++ + mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ / mode_lib->vba.DCCRate[k] ++ / 1000 ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ / mode_lib->vba.DCCRate[k] ++ / 1000; + } else { + mode_lib->vba.AverageReadBandwidthGBytePerSecond = +- mode_lib->vba.AverageReadBandwidthGBytePerSecond +- + mode_lib->vba.ReadBandwidthPlaneLuma[k] / 1000 +- + mode_lib->vba.ReadBandwidthPlaneChroma[k] / 1000; ++ mode_lib->vba.AverageReadBandwidthGBytePerSecond ++ + mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ / 1000 ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ / 1000; + } + if (mode_lib->vba.DCCEnable[k]) { + mode_lib->vba.AverageReadBandwidthGBytePerSecond = +- mode_lib->vba.AverageReadBandwidthGBytePerSecond +- + mode_lib->vba.ReadBandwidthPlaneLuma[k] / 1000 / 256 +- + mode_lib->vba.ReadBandwidthPlaneChroma[k] / 1000 +- / 256; ++ mode_lib->vba.AverageReadBandwidthGBytePerSecond ++ + mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ / 1000 / 256 ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ / 1000 / 256; + } + if (mode_lib->vba.VirtualMemoryEnable) { + mode_lib->vba.AverageReadBandwidthGBytePerSecond = +- mode_lib->vba.AverageReadBandwidthGBytePerSecond +- + mode_lib->vba.ReadBandwidthPlaneLuma[k] / 1000 / 512 +- + mode_lib->vba.ReadBandwidthPlaneChroma[k] / 1000 +- / 512; ++ mode_lib->vba.AverageReadBandwidthGBytePerSecond ++ + mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ / 1000 / 512 ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ / 1000 / 512; + } + } + +- mode_lib->vba.PartOfBurstThatFitsInROB = dml_min(mode_lib->vba.MinFullDETBufferingTime * mode_lib->vba.TotalDataReadBandwidth, +- mode_lib->vba.ROBBufferSizeInKByte * 1024 * mode_lib->vba.TotalDataReadBandwidth +- / (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000)); ++ mode_lib->vba.PartOfBurstThatFitsInROB = ++ dml_min( ++ mode_lib->vba.MinFullDETBufferingTime ++ * mode_lib->vba.TotalDataReadBandwidth, ++ mode_lib->vba.ROBBufferSizeInKByte * 1024 ++ * mode_lib->vba.TotalDataReadBandwidth ++ / (mode_lib->vba.AverageReadBandwidthGBytePerSecond ++ * 1000)); + mode_lib->vba.StutterBurstTime = mode_lib->vba.PartOfBurstThatFitsInROB +- * (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000) / mode_lib->vba.TotalDataReadBandwidth +- / mode_lib->vba.ReturnBW +- + (mode_lib->vba.MinFullDETBufferingTime * mode_lib->vba.TotalDataReadBandwidth +- - mode_lib->vba.PartOfBurstThatFitsInROB) / (mode_lib->vba.DCFCLK * 64); ++ * (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000) ++ / mode_lib->vba.TotalDataReadBandwidth / mode_lib->vba.ReturnBW ++ + (mode_lib->vba.MinFullDETBufferingTime ++ * mode_lib->vba.TotalDataReadBandwidth ++ - mode_lib->vba.PartOfBurstThatFitsInROB) ++ / (mode_lib->vba.DCFCLK * 64); + if (mode_lib->vba.TotalActiveWriteback == 0) { + mode_lib->vba.StutterEfficiencyNotIncludingVBlank = (1 +- - (mode_lib->vba.SRExitTime + mode_lib->vba.StutterBurstTime) / mode_lib->vba.MinFullDETBufferingTime) +- * 100; ++ - (mode_lib->vba.SRExitTime + mode_lib->vba.StutterBurstTime) ++ / mode_lib->vba.MinFullDETBufferingTime) * 100; + } else { + mode_lib->vba.StutterEfficiencyNotIncludingVBlank = 0; + } +@@ -1887,47 +2198,66 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + mode_lib->vba.SmallestVBlank = 999999; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) { +- mode_lib->vba.VBlankTime = (double)(mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]; ++ mode_lib->vba.VBlankTime = (double) (mode_lib->vba.VTotal[k] ++ - mode_lib->vba.VActive[k]) * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]; + } else { + mode_lib->vba.VBlankTime = 0; + } +- mode_lib->vba.SmallestVBlank = dml_min(mode_lib->vba.SmallestVBlank, mode_lib->vba.VBlankTime); ++ mode_lib->vba.SmallestVBlank = dml_min( ++ mode_lib->vba.SmallestVBlank, ++ mode_lib->vba.VBlankTime); + } + + mode_lib->vba.StutterEfficiency = (mode_lib->vba.StutterEfficiencyNotIncludingVBlank / 100 +- * (mode_lib->vba.FrameTimeForMinFullDETBufferingTime - mode_lib->vba.SmallestVBlank) +- + mode_lib->vba.SmallestVBlank) / mode_lib->vba.FrameTimeForMinFullDETBufferingTime * 100; ++ * (mode_lib->vba.FrameTimeForMinFullDETBufferingTime ++ - mode_lib->vba.SmallestVBlank) ++ + mode_lib->vba.SmallestVBlank) ++ / mode_lib->vba.FrameTimeForMinFullDETBufferingTime * 100; + + // dml_ml->vba.DCFCLK Deep Sleep + mode_lib->vba.DCFClkDeepSleep = 8.0; + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++) { + if (mode_lib->vba.BytePerPixelDETC[k] > 0) { +- mode_lib->vba.DCFCLKDeepSleepPerPlane = dml_max(1.1 * mode_lib->vba.SwathWidthY[k] +- * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 32 +- / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k], +- 1.1 * mode_lib->vba.SwathWidthY[k] / 2.0 +- * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) / 32 +- / mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); ++ mode_lib->vba.DCFCLKDeepSleepPerPlane = ++ dml_max( ++ 1.1 * mode_lib->vba.SwathWidthY[k] ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelDETY[k], ++ 1) / 32 ++ / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k], ++ 1.1 * mode_lib->vba.SwathWidthY[k] / 2.0 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelDETC[k], ++ 2) / 32 ++ / mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); + } else + mode_lib->vba.DCFCLKDeepSleepPerPlane = 1.1 * mode_lib->vba.SwathWidthY[k] +- * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 64.0 +- / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]; +- mode_lib->vba.DCFCLKDeepSleepPerPlane = dml_max(mode_lib->vba.DCFCLKDeepSleepPerPlane, +- mode_lib->vba.PixelClock[k] / 16.0); +- mode_lib->vba.DCFClkDeepSleep = dml_max(mode_lib->vba.DCFClkDeepSleep, mode_lib->vba.DCFCLKDeepSleepPerPlane); ++ * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 64.0 ++ / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]; ++ mode_lib->vba.DCFCLKDeepSleepPerPlane = dml_max( ++ mode_lib->vba.DCFCLKDeepSleepPerPlane, ++ mode_lib->vba.PixelClock[k] / 16.0); ++ mode_lib->vba.DCFClkDeepSleep = dml_max( ++ mode_lib->vba.DCFClkDeepSleep, ++ mode_lib->vba.DCFCLKDeepSleepPerPlane); + +- DTRACE(" dcfclk_deepsleep_per_plane[%i] = %fMHz", k, mode_lib->vba.DCFCLKDeepSleepPerPlane); ++ DTRACE( ++ " dcfclk_deepsleep_per_plane[%i] = %fMHz", ++ k, ++ mode_lib->vba.DCFCLKDeepSleepPerPlane); + } + + DTRACE(" dcfclk_deepsleep_mhz = %fMHz", mode_lib->vba.DCFClkDeepSleep); + + // Stutter Watermark +- mode_lib->vba.StutterExitWatermark = mode_lib->vba.SRExitTime + mode_lib->vba.LastPixelOfLineExtraWatermark + mode_lib->vba.UrgentExtraLatency +- + 10 / mode_lib->vba.DCFClkDeepSleep; +- mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.SREnterPlusExitTime + mode_lib->vba.LastPixelOfLineExtraWatermark +- + mode_lib->vba.UrgentExtraLatency; ++ mode_lib->vba.StutterExitWatermark = mode_lib->vba.SRExitTime ++ + mode_lib->vba.LastPixelOfLineExtraWatermark ++ + mode_lib->vba.UrgentExtraLatency + 10 / mode_lib->vba.DCFClkDeepSleep; ++ mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.SREnterPlusExitTime ++ + mode_lib->vba.LastPixelOfLineExtraWatermark ++ + mode_lib->vba.UrgentExtraLatency; + + DTRACE(" wm_cstate_exit = %fus", mode_lib->vba.StutterExitWatermark); + DTRACE(" wm_cstate_enter_exit = %fus", mode_lib->vba.StutterEnterPlusExitWatermark); +@@ -1935,72 +2265,95 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + // Urgent Latency Supported + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.EffectiveDETPlusLBLinesLuma = +- dml_floor(mode_lib->vba.LinesInDETY[k] +- + dml_min(mode_lib->vba.LinesInDETY[k] +- * mode_lib->vba.DPPCLK[k] +- * mode_lib->vba.BytePerPixelDETY[k] +- * mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] +- / (mode_lib->vba.ReturnBW +- / mode_lib->vba.DPPPerPlane[k]), +- (double)mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma), +- mode_lib->vba.SwathHeightY[k]); ++ dml_floor( ++ mode_lib->vba.LinesInDETY[k] ++ + dml_min( ++ mode_lib->vba.LinesInDETY[k] ++ * mode_lib->vba.DPPCLK[k] ++ * mode_lib->vba.BytePerPixelDETY[k] ++ * mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] ++ / (mode_lib->vba.ReturnBW ++ / mode_lib->vba.DPPPerPlane[k]), ++ (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma), ++ mode_lib->vba.SwathHeightY[k]); + + mode_lib->vba.UrgentLatencySupportUsLuma = mode_lib->vba.EffectiveDETPlusLBLinesLuma +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) / mode_lib->vba.VRatio[k] +- - mode_lib->vba.EffectiveDETPlusLBLinesLuma * mode_lib->vba.SwathWidthY[k] +- * mode_lib->vba.BytePerPixelDETY[k] +- / (mode_lib->vba.ReturnBW / mode_lib->vba.DPPPerPlane[k]); ++ * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ / mode_lib->vba.VRatio[k] ++ - mode_lib->vba.EffectiveDETPlusLBLinesLuma ++ * mode_lib->vba.SwathWidthY[k] ++ * mode_lib->vba.BytePerPixelDETY[k] ++ / (mode_lib->vba.ReturnBW ++ / mode_lib->vba.DPPPerPlane[k]); + + if (mode_lib->vba.BytePerPixelDETC[k] > 0) { + mode_lib->vba.EffectiveDETPlusLBLinesChroma = +- dml_floor(mode_lib->vba.LinesInDETC[k] +- + dml_min(mode_lib->vba.LinesInDETC[k] +- * mode_lib->vba.DPPCLK[k] +- * mode_lib->vba.BytePerPixelDETC[k] +- * mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] +- / (mode_lib->vba.ReturnBW +- / mode_lib->vba.DPPPerPlane[k]), +- (double)mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma), +- mode_lib->vba.SwathHeightC[k]); +- mode_lib->vba.UrgentLatencySupportUsChroma = mode_lib->vba.EffectiveDETPlusLBLinesChroma +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) / (mode_lib->vba.VRatio[k] / 2) +- - mode_lib->vba.EffectiveDETPlusLBLinesChroma +- * (mode_lib->vba.SwathWidthY[k] / 2) +- * mode_lib->vba.BytePerPixelDETC[k] +- / (mode_lib->vba.ReturnBW / mode_lib->vba.DPPPerPlane[k]); +- mode_lib->vba.UrgentLatencySupportUs[k] = dml_min(mode_lib->vba.UrgentLatencySupportUsLuma, +- mode_lib->vba.UrgentLatencySupportUsChroma); ++ dml_floor( ++ mode_lib->vba.LinesInDETC[k] ++ + dml_min( ++ mode_lib->vba.LinesInDETC[k] ++ * mode_lib->vba.DPPCLK[k] ++ * mode_lib->vba.BytePerPixelDETC[k] ++ * mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] ++ / (mode_lib->vba.ReturnBW ++ / mode_lib->vba.DPPPerPlane[k]), ++ (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma), ++ mode_lib->vba.SwathHeightC[k]); ++ mode_lib->vba.UrgentLatencySupportUsChroma = ++ mode_lib->vba.EffectiveDETPlusLBLinesChroma ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / (mode_lib->vba.VRatio[k] / 2) ++ - mode_lib->vba.EffectiveDETPlusLBLinesChroma ++ * (mode_lib->vba.SwathWidthY[k] ++ / 2) ++ * mode_lib->vba.BytePerPixelDETC[k] ++ / (mode_lib->vba.ReturnBW ++ / mode_lib->vba.DPPPerPlane[k]); ++ mode_lib->vba.UrgentLatencySupportUs[k] = dml_min( ++ mode_lib->vba.UrgentLatencySupportUsLuma, ++ mode_lib->vba.UrgentLatencySupportUsChroma); + } else { +- mode_lib->vba.UrgentLatencySupportUs[k] = mode_lib->vba.UrgentLatencySupportUsLuma; ++ mode_lib->vba.UrgentLatencySupportUs[k] = ++ mode_lib->vba.UrgentLatencySupportUsLuma; + } + } + + mode_lib->vba.MinUrgentLatencySupportUs = 999999; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- mode_lib->vba.MinUrgentLatencySupportUs = dml_min(mode_lib->vba.MinUrgentLatencySupportUs, +- mode_lib->vba.UrgentLatencySupportUs[k]); ++ mode_lib->vba.MinUrgentLatencySupportUs = dml_min( ++ mode_lib->vba.MinUrgentLatencySupportUs, ++ mode_lib->vba.UrgentLatencySupportUs[k]); + } + + // Non-Urgent Latency Tolerance +- mode_lib->vba.NonUrgentLatencyTolerance = mode_lib->vba.MinUrgentLatencySupportUs - mode_lib->vba.UrgentWatermark; ++ mode_lib->vba.NonUrgentLatencyTolerance = mode_lib->vba.MinUrgentLatencySupportUs ++ - mode_lib->vba.UrgentWatermark; + + // DSCCLK + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) { + mode_lib->vba.DSCCLK_calculated[k] = 0.0; + } else { +- if (mode_lib->vba.OutputFormat[k] == dm_420 || mode_lib->vba.OutputFormat[k] == dm_n422) ++ if (mode_lib->vba.OutputFormat[k] == dm_420 ++ || mode_lib->vba.OutputFormat[k] == dm_n422) + mode_lib->vba.DSCFormatFactor = 2; + else + mode_lib->vba.DSCFormatFactor = 1; + if (mode_lib->vba.ODMCombineEnabled[k]) +- mode_lib->vba.DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 6 +- / mode_lib->vba.DSCFormatFactor +- / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100); ++ mode_lib->vba.DSCCLK_calculated[k] = ++ mode_lib->vba.PixelClockBackEnd[k] / 6 ++ / mode_lib->vba.DSCFormatFactor ++ / (1 ++ - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100); + else +- mode_lib->vba.DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 3 +- / mode_lib->vba.DSCFormatFactor +- / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100); ++ mode_lib->vba.DSCCLK_calculated[k] = ++ mode_lib->vba.PixelClockBackEnd[k] / 3 ++ / mode_lib->vba.DSCFormatFactor ++ / (1 ++ - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100); + } + } + +@@ -2013,27 +2366,35 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + if (mode_lib->vba.DSCEnabled[k] && bpp != 0) { + if (!mode_lib->vba.ODMCombineEnabled[k]) { + mode_lib->vba.DSCDelay[k] = +- dscceComputeDelay(mode_lib->vba.DSCInputBitPerComponent[k], +- bpp, +- dml_ceil((double)mode_lib->vba.HActive[k] +- / mode_lib->vba.NumberOfDSCSlices[k], +- 1), +- slices, +- mode_lib->vba.OutputFormat[k]) +- + dscComputeDelay(mode_lib->vba.OutputFormat[k]); ++ dscceComputeDelay( ++ mode_lib->vba.DSCInputBitPerComponent[k], ++ bpp, ++ dml_ceil( ++ (double) mode_lib->vba.HActive[k] ++ / mode_lib->vba.NumberOfDSCSlices[k], ++ 1), ++ slices, ++ mode_lib->vba.OutputFormat[k]) ++ + dscComputeDelay( ++ mode_lib->vba.OutputFormat[k]); + } else { + mode_lib->vba.DSCDelay[k] = +- 2 +- * (dscceComputeDelay(mode_lib->vba.DSCInputBitPerComponent[k], +- bpp, +- dml_ceil((double)mode_lib->vba.HActive[k] +- / mode_lib->vba.NumberOfDSCSlices[k], +- 1), +- slices / 2.0, +- mode_lib->vba.OutputFormat[k]) +- + dscComputeDelay(mode_lib->vba.OutputFormat[k])); +- } +- mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[k] * mode_lib->vba.PixelClock[k] / mode_lib->vba.PixelClockBackEnd[k]; ++ 2 ++ * (dscceComputeDelay( ++ mode_lib->vba.DSCInputBitPerComponent[k], ++ bpp, ++ dml_ceil( ++ (double) mode_lib->vba.HActive[k] ++ / mode_lib->vba.NumberOfDSCSlices[k], ++ 1), ++ slices / 2.0, ++ mode_lib->vba.OutputFormat[k]) ++ + dscComputeDelay( ++ mode_lib->vba.OutputFormat[k])); ++ } ++ mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[k] ++ * mode_lib->vba.PixelClock[k] ++ / mode_lib->vba.PixelClockBackEnd[k]; + } else { + mode_lib->vba.DSCDelay[k] = 0; + } +@@ -2041,7 +2402,8 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) + for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) // NumberOfPlanes +- if (j != k && mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.DSCEnabled[j]) ++ if (j != k && mode_lib->vba.BlendingAndTiming[k] == j ++ && mode_lib->vba.DSCEnabled[j]) + mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[j]; + + // Prefetch +@@ -2053,82 +2415,91 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + unsigned int PDEAndMetaPTEBytesFrameC; + unsigned int PixelPTEBytesPerRowC; + +- Calculate256BBlockSizes(mode_lib->vba.SourcePixelFormat[k], +- mode_lib->vba.SurfaceTiling[k], +- dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), +- dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2), +- &mode_lib->vba.BlockHeight256BytesY[k], +- &mode_lib->vba.BlockHeight256BytesC[k], +- &mode_lib->vba.BlockWidth256BytesY[k], +- &mode_lib->vba.BlockWidth256BytesC[k]); +- PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(mode_lib, +- mode_lib->vba.DCCEnable[k], +- mode_lib->vba.BlockHeight256BytesY[k], +- mode_lib->vba.BlockWidth256BytesY[k], +- mode_lib->vba.SourcePixelFormat[k], +- mode_lib->vba.SurfaceTiling[k], +- dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), +- mode_lib->vba.SourceScan[k], +- mode_lib->vba.ViewportWidth[k], +- mode_lib->vba.ViewportHeight[k], +- mode_lib->vba.SwathWidthY[k], +- mode_lib->vba.VirtualMemoryEnable, +- mode_lib->vba.VMMPageSize, +- mode_lib->vba.PTEBufferSizeInRequests, +- mode_lib->vba.PDEProcessingBufIn64KBReqs, +- mode_lib->vba.PitchY[k], +- mode_lib->vba.DCCMetaPitchY[k], +- &mode_lib->vba.MacroTileWidthY, +- &MetaRowByteY, +- &PixelPTEBytesPerRowY, +- &mode_lib->vba.PTEBufferSizeNotExceeded, +- &mode_lib->vba.dpte_row_height[k], +- &mode_lib->vba.meta_row_height[k]); +- mode_lib->vba.PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(mode_lib, +- mode_lib->vba.VRatio[k], +- mode_lib->vba.vtaps[k], +- mode_lib->vba.Interlace[k], +- mode_lib->vba.ProgressiveToInterlaceUnitInOPP, +- mode_lib->vba.SwathHeightY[k], +- mode_lib->vba.ViewportYStartY[k], +- &mode_lib->vba.VInitPreFillY[k], +- &mode_lib->vba.MaxNumSwathY[k]); +- +- if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 +- && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 +- && mode_lib->vba.SourcePixelFormat[k] != dm_444_8)) { +- PDEAndMetaPTEBytesFrameC = CalculateVMAndRowBytes(mode_lib, +- mode_lib->vba.DCCEnable[k], +- mode_lib->vba.BlockHeight256BytesC[k], +- mode_lib->vba.BlockWidth256BytesC[k], ++ Calculate256BBlockSizes( + mode_lib->vba.SourcePixelFormat[k], + mode_lib->vba.SurfaceTiling[k], ++ dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), + dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2), ++ &mode_lib->vba.BlockHeight256BytesY[k], ++ &mode_lib->vba.BlockHeight256BytesC[k], ++ &mode_lib->vba.BlockWidth256BytesY[k], ++ &mode_lib->vba.BlockWidth256BytesC[k]); ++ PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes( ++ mode_lib, ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.BlockHeight256BytesY[k], ++ mode_lib->vba.BlockWidth256BytesY[k], ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.SurfaceTiling[k], ++ dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), + mode_lib->vba.SourceScan[k], +- mode_lib->vba.ViewportWidth[k] / 2, +- mode_lib->vba.ViewportHeight[k] / 2, +- mode_lib->vba.SwathWidthY[k] / 2, ++ mode_lib->vba.ViewportWidth[k], ++ mode_lib->vba.ViewportHeight[k], ++ mode_lib->vba.SwathWidthY[k], + mode_lib->vba.VirtualMemoryEnable, + mode_lib->vba.VMMPageSize, + mode_lib->vba.PTEBufferSizeInRequests, + mode_lib->vba.PDEProcessingBufIn64KBReqs, +- mode_lib->vba.PitchC[k], +- 0, +- &mode_lib->vba.MacroTileWidthC, +- &MetaRowByteC, +- &PixelPTEBytesPerRowC, +- &mode_lib->vba.PTEBufferSizeNotExceeded, +- &mode_lib->vba.dpte_row_height_chroma[k], +- &mode_lib->vba.meta_row_height_chroma[k]); +- mode_lib->vba.PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(mode_lib, +- mode_lib->vba.VRatio[k] / 2, +- mode_lib->vba.VTAPsChroma[k], ++ mode_lib->vba.PitchY[k], ++ mode_lib->vba.DCCMetaPitchY[k], ++ &mode_lib->vba.MacroTileWidthY[k], ++ &MetaRowByteY, ++ &PixelPTEBytesPerRowY, ++ &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel], ++ &mode_lib->vba.dpte_row_height[k], ++ &mode_lib->vba.meta_row_height[k]); ++ mode_lib->vba.PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines( ++ mode_lib, ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.vtaps[k], + mode_lib->vba.Interlace[k], + mode_lib->vba.ProgressiveToInterlaceUnitInOPP, +- mode_lib->vba.SwathHeightC[k], +- mode_lib->vba.ViewportYStartC[k], +- &mode_lib->vba.VInitPreFillC[k], +- &mode_lib->vba.MaxNumSwathC[k]); ++ mode_lib->vba.SwathHeightY[k], ++ mode_lib->vba.ViewportYStartY[k], ++ &mode_lib->vba.VInitPreFillY[k], ++ &mode_lib->vba.MaxNumSwathY[k]); ++ ++ if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_8)) { ++ PDEAndMetaPTEBytesFrameC = ++ CalculateVMAndRowBytes( ++ mode_lib, ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.BlockHeight256BytesC[k], ++ mode_lib->vba.BlockWidth256BytesC[k], ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.SurfaceTiling[k], ++ dml_ceil( ++ mode_lib->vba.BytePerPixelDETC[k], ++ 2), ++ mode_lib->vba.SourceScan[k], ++ mode_lib->vba.ViewportWidth[k] / 2, ++ mode_lib->vba.ViewportHeight[k] / 2, ++ mode_lib->vba.SwathWidthY[k] / 2, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.VMMPageSize, ++ mode_lib->vba.PTEBufferSizeInRequests, ++ mode_lib->vba.PDEProcessingBufIn64KBReqs, ++ mode_lib->vba.PitchC[k], ++ 0, ++ &mode_lib->vba.MacroTileWidthC[k], ++ &MetaRowByteC, ++ &PixelPTEBytesPerRowC, ++ &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel], ++ &mode_lib->vba.dpte_row_height_chroma[k], ++ &mode_lib->vba.meta_row_height_chroma[k]); ++ mode_lib->vba.PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines( ++ mode_lib, ++ mode_lib->vba.VRatio[k] / 2, ++ mode_lib->vba.VTAPsChroma[k], ++ mode_lib->vba.Interlace[k], ++ mode_lib->vba.ProgressiveToInterlaceUnitInOPP, ++ mode_lib->vba.SwathHeightC[k], ++ mode_lib->vba.ViewportYStartC[k], ++ &mode_lib->vba.VInitPreFillC[k], ++ &mode_lib->vba.MaxNumSwathC[k]); + } else { + PixelPTEBytesPerRowC = 0; + PDEAndMetaPTEBytesFrameC = 0; +@@ -2138,25 +2509,27 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + } + + mode_lib->vba.PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC; +- mode_lib->vba.PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY + PDEAndMetaPTEBytesFrameC; ++ mode_lib->vba.PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY ++ + PDEAndMetaPTEBytesFrameC; + mode_lib->vba.MetaRowByte[k] = MetaRowByteY + MetaRowByteC; + +- CalculateActiveRowBandwidth(mode_lib->vba.VirtualMemoryEnable, +- mode_lib->vba.SourcePixelFormat[k], +- mode_lib->vba.VRatio[k], +- mode_lib->vba.DCCEnable[k], +- mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], +- MetaRowByteY, +- MetaRowByteC, +- mode_lib->vba.meta_row_height[k], +- mode_lib->vba.meta_row_height_chroma[k], +- PixelPTEBytesPerRowY, +- PixelPTEBytesPerRowC, +- mode_lib->vba.dpte_row_height[k], +- mode_lib->vba.dpte_row_height_chroma[k], +- &mode_lib->vba.meta_row_bw[k], +- &mode_lib->vba.dpte_row_bw[k], +- &mode_lib->vba.qual_row_bw[k]); ++ CalculateActiveRowBandwidth( ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], ++ MetaRowByteY, ++ MetaRowByteC, ++ mode_lib->vba.meta_row_height[k], ++ mode_lib->vba.meta_row_height_chroma[k], ++ PixelPTEBytesPerRowY, ++ PixelPTEBytesPerRowC, ++ mode_lib->vba.dpte_row_height[k], ++ mode_lib->vba.dpte_row_height_chroma[k], ++ &mode_lib->vba.meta_row_bw[k], ++ &mode_lib->vba.dpte_row_bw[k], ++ &mode_lib->vba.qual_row_bw[k]); + } + + mode_lib->vba.TCalc = 24.0 / mode_lib->vba.DCFClkDeepSleep; +@@ -2164,32 +2537,37 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.BlendingAndTiming[k] == k) { + if (mode_lib->vba.WritebackEnable[k] == true) { +- mode_lib->vba.WritebackDelay[k] = mode_lib->vba.WritebackLatency +- + CalculateWriteBackDelay(mode_lib->vba.WritebackPixelFormat[k], +- mode_lib->vba.WritebackHRatio[k], +- mode_lib->vba.WritebackVRatio[k], +- mode_lib->vba.WritebackLumaHTaps[k], +- mode_lib->vba.WritebackLumaVTaps[k], +- mode_lib->vba.WritebackChromaHTaps[k], +- mode_lib->vba.WritebackChromaVTaps[k], +- mode_lib->vba.WritebackDestinationWidth[k]) +- / mode_lib->vba.DISPCLK; ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = ++ mode_lib->vba.WritebackLatency ++ + CalculateWriteBackDelay( ++ mode_lib->vba.WritebackPixelFormat[k], ++ mode_lib->vba.WritebackHRatio[k], ++ mode_lib->vba.WritebackVRatio[k], ++ mode_lib->vba.WritebackLumaHTaps[k], ++ mode_lib->vba.WritebackLumaVTaps[k], ++ mode_lib->vba.WritebackChromaHTaps[k], ++ mode_lib->vba.WritebackChromaVTaps[k], ++ mode_lib->vba.WritebackDestinationWidth[k]) ++ / mode_lib->vba.DISPCLK; + } else +- mode_lib->vba.WritebackDelay[k] = 0; ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0; + for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) { +- if (mode_lib->vba.BlendingAndTiming[j] == k && mode_lib->vba.WritebackEnable[j] == true) { +- mode_lib->vba.WritebackDelay[k] = +- dml_max(mode_lib->vba.WritebackDelay[k], +- mode_lib->vba.WritebackLatency +- + CalculateWriteBackDelay(mode_lib->vba.WritebackPixelFormat[j], +- mode_lib->vba.WritebackHRatio[j], +- mode_lib->vba.WritebackVRatio[j], +- mode_lib->vba.WritebackLumaHTaps[j], +- mode_lib->vba.WritebackLumaVTaps[j], +- mode_lib->vba.WritebackChromaHTaps[j], +- mode_lib->vba.WritebackChromaVTaps[j], +- mode_lib->vba.WritebackDestinationWidth[j]) +- / mode_lib->vba.DISPCLK); ++ if (mode_lib->vba.BlendingAndTiming[j] == k ++ && mode_lib->vba.WritebackEnable[j] == true) { ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = ++ dml_max( ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k], ++ mode_lib->vba.WritebackLatency ++ + CalculateWriteBackDelay( ++ mode_lib->vba.WritebackPixelFormat[j], ++ mode_lib->vba.WritebackHRatio[j], ++ mode_lib->vba.WritebackVRatio[j], ++ mode_lib->vba.WritebackLumaHTaps[j], ++ mode_lib->vba.WritebackLumaVTaps[j], ++ mode_lib->vba.WritebackChromaHTaps[j], ++ mode_lib->vba.WritebackChromaVTaps[j], ++ mode_lib->vba.WritebackDestinationWidth[j]) ++ / mode_lib->vba.DISPCLK); + } + } + } +@@ -2198,27 +2576,34 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) + for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) + if (mode_lib->vba.BlendingAndTiming[k] == j) +- mode_lib->vba.WritebackDelay[k] = mode_lib->vba.WritebackDelay[j]; ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][j]; + + mode_lib->vba.VStartupLines = 13; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.MaxVStartupLines[k] = +- mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k] +- - dml_max(1.0, +- dml_ceil(mode_lib->vba.WritebackDelay[k] +- / (mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]), +- 1)); ++ mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k] ++ - dml_max( ++ 1.0, ++ dml_ceil( ++ mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] ++ / (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]), ++ 1)); + } + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) +- mode_lib->vba.MaximumMaxVStartupLines = dml_max(mode_lib->vba.MaximumMaxVStartupLines, mode_lib->vba.MaxVStartupLines[k]); ++ mode_lib->vba.MaximumMaxVStartupLines = dml_max( ++ mode_lib->vba.MaximumMaxVStartupLines, ++ mode_lib->vba.MaxVStartupLines[k]); + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.cursor_bw[k] = 0.0; + for (j = 0; j < mode_lib->vba.NumberOfCursors[k]; ++j) +- mode_lib->vba.cursor_bw[k] += mode_lib->vba.CursorWidth[k][j] * mode_lib->vba.CursorBPP[k][j] / 8.0 +- / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]; ++ mode_lib->vba.cursor_bw[k] += mode_lib->vba.CursorWidth[k][j] ++ * mode_lib->vba.CursorBPP[k][j] / 8.0 ++ / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ * mode_lib->vba.VRatio[k]; + } + + do { +@@ -2227,102 +2612,119 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + bool VRatioPrefetchMoreThan4 = false; + bool prefetch_vm_bw_valid = true; + bool prefetch_row_bw_valid = true; +- double TWait = CalculateTWait(mode_lib->vba.PrefetchMode, +- mode_lib->vba.DRAMClockChangeLatency, +- mode_lib->vba.UrgentLatency, +- mode_lib->vba.SREnterPlusExitTime); ++ double TWait = CalculateTWait( ++ mode_lib->vba.PrefetchMode, ++ mode_lib->vba.DRAMClockChangeLatency, ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.SREnterPlusExitTime); + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.XFCEnabled[k] == true) { +- mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay(mode_lib, +- mode_lib->vba.VRatio[k], +- mode_lib->vba.SwathWidthY[k], +- dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), +- mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], +- mode_lib->vba.XFCTSlvVupdateOffset, +- mode_lib->vba.XFCTSlvVupdateWidth, +- mode_lib->vba.XFCTSlvVreadyOffset, +- mode_lib->vba.XFCXBUFLatencyTolerance, +- mode_lib->vba.XFCFillBWOverhead, +- mode_lib->vba.XFCSlvChunkSize, +- mode_lib->vba.XFCBusTransportTime, +- mode_lib->vba.TCalc, +- TWait, +- &mode_lib->vba.SrcActiveDrainRate, +- &mode_lib->vba.TInitXFill, +- &mode_lib->vba.TslvChk); ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay = ++ CalculateRemoteSurfaceFlipDelay( ++ mode_lib, ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.SwathWidthY[k], ++ dml_ceil( ++ mode_lib->vba.BytePerPixelDETY[k], ++ 1), ++ mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k], ++ mode_lib->vba.XFCTSlvVupdateOffset, ++ mode_lib->vba.XFCTSlvVupdateWidth, ++ mode_lib->vba.XFCTSlvVreadyOffset, ++ mode_lib->vba.XFCXBUFLatencyTolerance, ++ mode_lib->vba.XFCFillBWOverhead, ++ mode_lib->vba.XFCSlvChunkSize, ++ mode_lib->vba.XFCBusTransportTime, ++ mode_lib->vba.TCalc, ++ TWait, ++ &mode_lib->vba.SrcActiveDrainRate, ++ &mode_lib->vba.TInitXFill, ++ &mode_lib->vba.TslvChk); + } else { + mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0; + } +- mode_lib->vba.ErrorResult[k] = CalculatePrefetchSchedule(mode_lib, +- mode_lib->vba.DPPCLK[k], +- mode_lib->vba.DISPCLK, +- mode_lib->vba.PixelClock[k], +- mode_lib->vba.DCFClkDeepSleep, +- mode_lib->vba.DSCDelay[k], +- mode_lib->vba.DPPPerPlane[k], +- mode_lib->vba.ScalerEnabled[k], +- mode_lib->vba.NumberOfCursors[k], +- mode_lib->vba.DPPCLKDelaySubtotal, +- mode_lib->vba.DPPCLKDelaySCL, +- mode_lib->vba.DPPCLKDelaySCLLBOnly, +- mode_lib->vba.DPPCLKDelayCNVCFormater, +- mode_lib->vba.DPPCLKDelayCNVCCursor, +- mode_lib->vba.DISPCLKDelaySubtotal, +- (unsigned int)(mode_lib->vba.SwathWidthY[k] / mode_lib->vba.HRatio[k]), +- mode_lib->vba.OutputFormat[k], +- mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k], +- mode_lib->vba.HTotal[k], +- mode_lib->vba.MaxInterDCNTileRepeaters, +- dml_min(mode_lib->vba.VStartupLines, mode_lib->vba.MaxVStartupLines[k]), +- mode_lib->vba.MaxPageTableLevels, +- mode_lib->vba.VirtualMemoryEnable, +- mode_lib->vba.DynamicMetadataEnable[k], +- mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k], +- mode_lib->vba.DynamicMetadataTransmittedBytes[k], +- mode_lib->vba.DCCEnable[k], +- mode_lib->vba.UrgentLatency, +- mode_lib->vba.UrgentExtraLatency, +- mode_lib->vba.TCalc, +- mode_lib->vba.PDEAndMetaPTEBytesFrame[k], +- mode_lib->vba.MetaRowByte[k], +- mode_lib->vba.PixelPTEBytesPerRow[k], +- mode_lib->vba.PrefetchSourceLinesY[k], +- mode_lib->vba.SwathWidthY[k], +- mode_lib->vba.BytePerPixelDETY[k], +- mode_lib->vba.VInitPreFillY[k], +- mode_lib->vba.MaxNumSwathY[k], +- mode_lib->vba.PrefetchSourceLinesC[k], +- mode_lib->vba.BytePerPixelDETC[k], +- mode_lib->vba.VInitPreFillC[k], +- mode_lib->vba.MaxNumSwathC[k], +- mode_lib->vba.SwathHeightY[k], +- mode_lib->vba.SwathHeightC[k], +- TWait, +- mode_lib->vba.XFCEnabled[k], +- mode_lib->vba.XFCRemoteSurfaceFlipDelay, +- mode_lib->vba.Interlace[k], +- mode_lib->vba.ProgressiveToInterlaceUnitInOPP, +- &mode_lib->vba.DSTXAfterScaler[k], +- &mode_lib->vba.DSTYAfterScaler[k], +- &mode_lib->vba.DestinationLinesForPrefetch[k], +- &mode_lib->vba.PrefetchBandwidth[k], +- &mode_lib->vba.DestinationLinesToRequestVMInVBlank[k], +- &mode_lib->vba.DestinationLinesToRequestRowInVBlank[k], +- &mode_lib->vba.VRatioPrefetchY[k], +- &mode_lib->vba.VRatioPrefetchC[k], +- &mode_lib->vba.RequiredPrefetchPixDataBW[k], +- &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, +- &mode_lib->vba.Tno_bw[k]); ++ mode_lib->vba.ErrorResult[k] = ++ CalculatePrefetchSchedule( ++ mode_lib, ++ mode_lib->vba.DPPCLK[k], ++ mode_lib->vba.DISPCLK, ++ mode_lib->vba.PixelClock[k], ++ mode_lib->vba.DCFClkDeepSleep, ++ mode_lib->vba.DSCDelay[k], ++ mode_lib->vba.DPPPerPlane[k], ++ mode_lib->vba.ScalerEnabled[k], ++ mode_lib->vba.NumberOfCursors[k], ++ mode_lib->vba.DPPCLKDelaySubtotal, ++ mode_lib->vba.DPPCLKDelaySCL, ++ mode_lib->vba.DPPCLKDelaySCLLBOnly, ++ mode_lib->vba.DPPCLKDelayCNVCFormater, ++ mode_lib->vba.DPPCLKDelayCNVCCursor, ++ mode_lib->vba.DISPCLKDelaySubtotal, ++ (unsigned int) (mode_lib->vba.SwathWidthY[k] ++ / mode_lib->vba.HRatio[k]), ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.VTotal[k] ++ - mode_lib->vba.VActive[k], ++ mode_lib->vba.HTotal[k], ++ mode_lib->vba.MaxInterDCNTileRepeaters, ++ dml_min( ++ mode_lib->vba.VStartupLines, ++ mode_lib->vba.MaxVStartupLines[k]), ++ mode_lib->vba.MaxPageTableLevels, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.DynamicMetadataEnable[k], ++ mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k], ++ mode_lib->vba.DynamicMetadataTransmittedBytes[k], ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.UrgentExtraLatency, ++ mode_lib->vba.TCalc, ++ mode_lib->vba.PDEAndMetaPTEBytesFrame[k], ++ mode_lib->vba.MetaRowByte[k], ++ mode_lib->vba.PixelPTEBytesPerRow[k], ++ mode_lib->vba.PrefetchSourceLinesY[k], ++ mode_lib->vba.SwathWidthY[k], ++ mode_lib->vba.BytePerPixelDETY[k], ++ mode_lib->vba.VInitPreFillY[k], ++ mode_lib->vba.MaxNumSwathY[k], ++ mode_lib->vba.PrefetchSourceLinesC[k], ++ mode_lib->vba.BytePerPixelDETC[k], ++ mode_lib->vba.VInitPreFillC[k], ++ mode_lib->vba.MaxNumSwathC[k], ++ mode_lib->vba.SwathHeightY[k], ++ mode_lib->vba.SwathHeightC[k], ++ TWait, ++ mode_lib->vba.XFCEnabled[k], ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay, ++ mode_lib->vba.Interlace[k], ++ mode_lib->vba.ProgressiveToInterlaceUnitInOPP, ++ &mode_lib->vba.DSTXAfterScaler[k], ++ &mode_lib->vba.DSTYAfterScaler[k], ++ &mode_lib->vba.DestinationLinesForPrefetch[k], ++ &mode_lib->vba.PrefetchBandwidth[k], ++ &mode_lib->vba.DestinationLinesToRequestVMInVBlank[k], ++ &mode_lib->vba.DestinationLinesToRequestRowInVBlank[k], ++ &mode_lib->vba.VRatioPrefetchY[k], ++ &mode_lib->vba.VRatioPrefetchC[k], ++ &mode_lib->vba.RequiredPrefetchPixDataBW[k], ++ &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, ++ &mode_lib->vba.Tno_bw[k]); + if (mode_lib->vba.BlendingAndTiming[k] == k) { +- mode_lib->vba.VStartup[k] = dml_min(mode_lib->vba.VStartupLines, mode_lib->vba.MaxVStartupLines[k]); +- if (mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata != 0) { ++ mode_lib->vba.VStartup[k] = dml_min( ++ mode_lib->vba.VStartupLines, ++ mode_lib->vba.MaxVStartupLines[k]); ++ if (mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata ++ != 0) { + mode_lib->vba.VStartup[k] = +- mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata; ++ mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata; + } + } else { +- mode_lib->vba.VStartup[k] = dml_min(mode_lib->vba.VStartupLines, +- mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]); ++ mode_lib->vba.VStartup[k] = ++ dml_min( ++ mode_lib->vba.VStartupLines, ++ mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]); + } + } + +@@ -2331,116 +2733,136 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + if (mode_lib->vba.PDEAndMetaPTEBytesFrame[k] == 0) + mode_lib->vba.prefetch_vm_bw[k] = 0; + else if (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] > 0) { +- mode_lib->vba.prefetch_vm_bw[k] = (double)mode_lib->vba.PDEAndMetaPTEBytesFrame[k] +- / (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] +- * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ mode_lib->vba.prefetch_vm_bw[k] = ++ (double) mode_lib->vba.PDEAndMetaPTEBytesFrame[k] ++ / (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); + } else { + mode_lib->vba.prefetch_vm_bw[k] = 0; + prefetch_vm_bw_valid = false; + } +- if (mode_lib->vba.MetaRowByte[k] + mode_lib->vba.PixelPTEBytesPerRow[k] == 0) ++ if (mode_lib->vba.MetaRowByte[k] + mode_lib->vba.PixelPTEBytesPerRow[k] ++ == 0) + mode_lib->vba.prefetch_row_bw[k] = 0; + else if (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] > 0) { +- mode_lib->vba.prefetch_row_bw[k] = (double)(mode_lib->vba.MetaRowByte[k] +- + mode_lib->vba.PixelPTEBytesPerRow[k]) +- / (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] +- * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ mode_lib->vba.prefetch_row_bw[k] = ++ (double) (mode_lib->vba.MetaRowByte[k] ++ + mode_lib->vba.PixelPTEBytesPerRow[k]) ++ / (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); + } else { + mode_lib->vba.prefetch_row_bw[k] = 0; + prefetch_row_bw_valid = false; + } + + MaxTotalRDBandwidth = +- MaxTotalRDBandwidth + mode_lib->vba.cursor_bw[k] +- + dml_max(mode_lib->vba.prefetch_vm_bw[k], +- dml_max(mode_lib->vba.prefetch_row_bw[k], +- dml_max(mode_lib->vba.ReadBandwidthPlaneLuma[k] +- + mode_lib->vba.ReadBandwidthPlaneChroma[k], +- mode_lib->vba.RequiredPrefetchPixDataBW[k]) +- + mode_lib->vba.meta_row_bw[k] +- + mode_lib->vba.dpte_row_bw[k])); ++ MaxTotalRDBandwidth + mode_lib->vba.cursor_bw[k] ++ + dml_max( ++ mode_lib->vba.prefetch_vm_bw[k], ++ dml_max( ++ mode_lib->vba.prefetch_row_bw[k], ++ dml_max( ++ mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k], ++ mode_lib->vba.RequiredPrefetchPixDataBW[k]) ++ + mode_lib->vba.meta_row_bw[k] ++ + mode_lib->vba.dpte_row_bw[k])); + + if (mode_lib->vba.DestinationLinesForPrefetch[k] < 2) + DestinationLineTimesForPrefetchLessThan2 = true; +- if (mode_lib->vba.VRatioPrefetchY[k] > 4 || mode_lib->vba.VRatioPrefetchC[k] > 4) ++ if (mode_lib->vba.VRatioPrefetchY[k] > 4 ++ || mode_lib->vba.VRatioPrefetchC[k] > 4) + VRatioPrefetchMoreThan4 = true; + } + +- if (MaxTotalRDBandwidth <= mode_lib->vba.ReturnBW && prefetch_vm_bw_valid && prefetch_row_bw_valid +- && !VRatioPrefetchMoreThan4 ++ if (MaxTotalRDBandwidth <= mode_lib->vba.ReturnBW && prefetch_vm_bw_valid ++ && prefetch_row_bw_valid && !VRatioPrefetchMoreThan4 + && !DestinationLineTimesForPrefetchLessThan2) + mode_lib->vba.PrefetchModeSupported = true; + else { + mode_lib->vba.PrefetchModeSupported = false; +- dml_print("DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n"); ++ dml_print( ++ "DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n"); + } + + if (mode_lib->vba.PrefetchModeSupported == true) { +- double final_flip_bw[DC__NUM_PIPES__MAX]; +- unsigned int ImmediateFlipBytes[DC__NUM_PIPES__MAX]; ++ double final_flip_bw[DC__NUM_DPP__MAX]; ++ unsigned int ImmediateFlipBytes[DC__NUM_DPP__MAX]; + double total_dcn_read_bw_with_flip = 0; + + mode_lib->vba.BandwidthAvailableForImmediateFlip = mode_lib->vba.ReturnBW; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.BandwidthAvailableForImmediateFlip = +- mode_lib->vba.BandwidthAvailableForImmediateFlip - mode_lib->vba.cursor_bw[k] +- - dml_max(mode_lib->vba.ReadBandwidthPlaneLuma[k] +- + mode_lib->vba.ReadBandwidthPlaneChroma[k] +- + mode_lib->vba.qual_row_bw[k], +- mode_lib->vba.PrefetchBandwidth[k]); ++ mode_lib->vba.BandwidthAvailableForImmediateFlip ++ - mode_lib->vba.cursor_bw[k] ++ - dml_max( ++ mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k] ++ + mode_lib->vba.qual_row_bw[k], ++ mode_lib->vba.PrefetchBandwidth[k]); + } + + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + ImmediateFlipBytes[k] = 0; + if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 +- && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { +- ImmediateFlipBytes[k] = mode_lib->vba.PDEAndMetaPTEBytesFrame[k] +- + mode_lib->vba.MetaRowByte[k] +- + mode_lib->vba.PixelPTEBytesPerRow[k]; ++ && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { ++ ImmediateFlipBytes[k] = ++ mode_lib->vba.PDEAndMetaPTEBytesFrame[k] ++ + mode_lib->vba.MetaRowByte[k] ++ + mode_lib->vba.PixelPTEBytesPerRow[k]; + } + } + mode_lib->vba.TotImmediateFlipBytes = 0; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 +- && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { +- mode_lib->vba.TotImmediateFlipBytes = mode_lib->vba.TotImmediateFlipBytes +- + ImmediateFlipBytes[k]; ++ && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { ++ mode_lib->vba.TotImmediateFlipBytes = ++ mode_lib->vba.TotImmediateFlipBytes ++ + ImmediateFlipBytes[k]; + } + } + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { +- CalculateFlipSchedule(mode_lib, +- mode_lib->vba.UrgentExtraLatency, +- mode_lib->vba.UrgentLatency, +- mode_lib->vba.MaxPageTableLevels, +- mode_lib->vba.VirtualMemoryEnable, +- mode_lib->vba.BandwidthAvailableForImmediateFlip, +- mode_lib->vba.TotImmediateFlipBytes, +- mode_lib->vba.SourcePixelFormat[k], +- ImmediateFlipBytes[k], +- mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], +- mode_lib->vba.VRatio[k], +- mode_lib->vba.Tno_bw[k], +- mode_lib->vba.PDEAndMetaPTEBytesFrame[k], +- mode_lib->vba.MetaRowByte[k], +- mode_lib->vba.PixelPTEBytesPerRow[k], +- mode_lib->vba.DCCEnable[k], +- mode_lib->vba.dpte_row_height[k], +- mode_lib->vba.meta_row_height[k], +- mode_lib->vba.qual_row_bw[k], +- &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k], +- &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k], +- &final_flip_bw[k], +- &mode_lib->vba.ImmediateFlipSupportedForPipe[k]); ++ CalculateFlipSchedule( ++ mode_lib, ++ mode_lib->vba.UrgentExtraLatency, ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.MaxPageTableLevels, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.BandwidthAvailableForImmediateFlip, ++ mode_lib->vba.TotImmediateFlipBytes, ++ mode_lib->vba.SourcePixelFormat[k], ++ ImmediateFlipBytes[k], ++ mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k], ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.Tno_bw[k], ++ mode_lib->vba.PDEAndMetaPTEBytesFrame[k], ++ mode_lib->vba.MetaRowByte[k], ++ mode_lib->vba.PixelPTEBytesPerRow[k], ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.dpte_row_height[k], ++ mode_lib->vba.meta_row_height[k], ++ mode_lib->vba.qual_row_bw[k], ++ &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k], ++ &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k], ++ &final_flip_bw[k], ++ &mode_lib->vba.ImmediateFlipSupportedForPipe[k]); + } + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + total_dcn_read_bw_with_flip = +- total_dcn_read_bw_with_flip + mode_lib->vba.cursor_bw[k] +- + dml_max(mode_lib->vba.prefetch_vm_bw[k], +- dml_max(mode_lib->vba.prefetch_row_bw[k], +- final_flip_bw[k] +- + dml_max(mode_lib->vba.ReadBandwidthPlaneLuma[k] +- + mode_lib->vba.ReadBandwidthPlaneChroma[k], +- mode_lib->vba.RequiredPrefetchPixDataBW[k]))); ++ total_dcn_read_bw_with_flip ++ + mode_lib->vba.cursor_bw[k] ++ + dml_max( ++ mode_lib->vba.prefetch_vm_bw[k], ++ dml_max( ++ mode_lib->vba.prefetch_row_bw[k], ++ final_flip_bw[k] ++ + dml_max( ++ mode_lib->vba.ReadBandwidthPlaneLuma[k] ++ + mode_lib->vba.ReadBandwidthPlaneChroma[k], ++ mode_lib->vba.RequiredPrefetchPixDataBW[k]))); + } + mode_lib->vba.ImmediateFlipSupported = true; + if (total_dcn_read_bw_with_flip > mode_lib->vba.ReturnBW) { +@@ -2458,35 +2880,44 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.ErrorResult[k]) { + mode_lib->vba.PrefetchModeSupported = false; +- dml_print("DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n"); ++ dml_print( ++ "DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n"); + } + } + + mode_lib->vba.VStartupLines = mode_lib->vba.VStartupLines + 1; + } while (!((mode_lib->vba.PrefetchModeSupported +- && (!mode_lib->vba.ImmediateFlipSupport || mode_lib->vba.ImmediateFlipSupported)) +- || mode_lib->vba.MaximumMaxVStartupLines < mode_lib->vba.VStartupLines)); ++ && (!mode_lib->vba.ImmediateFlipSupport ++ || mode_lib->vba.ImmediateFlipSupported)) ++ || mode_lib->vba.MaximumMaxVStartupLines < mode_lib->vba.VStartupLines)); + + //Display Pipeline Delivery Time in Prefetch + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.VRatioPrefetchY[k] <= 1) { +- mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = mode_lib->vba.SwathWidthY[k] +- * mode_lib->vba.DPPPerPlane[k] / mode_lib->vba.HRatio[k] / mode_lib->vba.PixelClock[k]; ++ mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = ++ mode_lib->vba.SwathWidthY[k] * mode_lib->vba.DPPPerPlane[k] ++ / mode_lib->vba.HRatio[k] ++ / mode_lib->vba.PixelClock[k]; + } else { +- mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = mode_lib->vba.SwathWidthY[k] +- / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] / mode_lib->vba.DPPCLK[k]; ++ mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = ++ mode_lib->vba.SwathWidthY[k] ++ / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] ++ / mode_lib->vba.DPPCLK[k]; + } + if (mode_lib->vba.BytePerPixelDETC[k] == 0) { + mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0; + } else { + if (mode_lib->vba.VRatioPrefetchC[k] <= 1) { + mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = +- mode_lib->vba.SwathWidthY[k] * mode_lib->vba.DPPPerPlane[k] / mode_lib->vba.HRatio[k] +- / mode_lib->vba.PixelClock[k]; ++ mode_lib->vba.SwathWidthY[k] ++ * mode_lib->vba.DPPPerPlane[k] ++ / mode_lib->vba.HRatio[k] ++ / mode_lib->vba.PixelClock[k]; + } else { + mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = +- mode_lib->vba.SwathWidthY[k] / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] +- / mode_lib->vba.DPPCLK[k]; ++ mode_lib->vba.SwathWidthY[k] ++ / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] ++ / mode_lib->vba.DPPCLK[k]; + } + } + } +@@ -2496,19 +2927,25 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + if (mode_lib->vba.PrefetchMode == 0) { + mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = true; + mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true; +- mode_lib->vba.MinTTUVBlank[k] = dml_max(mode_lib->vba.DRAMClockChangeWatermark, +- dml_max(mode_lib->vba.StutterEnterPlusExitWatermark, mode_lib->vba.UrgentWatermark)); ++ mode_lib->vba.MinTTUVBlank[k] = dml_max( ++ mode_lib->vba.DRAMClockChangeWatermark, ++ dml_max( ++ mode_lib->vba.StutterEnterPlusExitWatermark, ++ mode_lib->vba.UrgentWatermark)); + } else if (mode_lib->vba.PrefetchMode == 1) { + mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false; + mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true; +- mode_lib->vba.MinTTUVBlank[k] = dml_max(mode_lib->vba.StutterEnterPlusExitWatermark, mode_lib->vba.UrgentWatermark); ++ mode_lib->vba.MinTTUVBlank[k] = dml_max( ++ mode_lib->vba.StutterEnterPlusExitWatermark, ++ mode_lib->vba.UrgentWatermark); + } else { + mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false; + mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = false; + mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.UrgentWatermark; + } + if (!mode_lib->vba.DynamicMetadataEnable[k]) +- mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.TCalc + mode_lib->vba.MinTTUVBlank[k]; ++ mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.TCalc ++ + mode_lib->vba.MinTTUVBlank[k]; + } + + // DCC Configuration +@@ -2528,33 +2965,43 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + double ActiveDRAMClockChangeLatencyMarginY; + + mode_lib->vba.LBLatencyHidingSourceLinesY = +- dml_min(mode_lib->vba.MaxLineBufferLines, +- (unsigned int)dml_floor((double)mode_lib->vba.LineBufferSize +- / mode_lib->vba.LBBitPerPixel[k] +- / (mode_lib->vba.SwathWidthY[k] +- / dml_max(mode_lib->vba.HRatio[k], +- 1.0)), +- 1)) - (mode_lib->vba.vtaps[k] - 1); ++ dml_min( ++ mode_lib->vba.MaxLineBufferLines, ++ (unsigned int) dml_floor( ++ (double) mode_lib->vba.LineBufferSize ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.SwathWidthY[k] ++ / dml_max( ++ mode_lib->vba.HRatio[k], ++ 1.0)), ++ 1)) - (mode_lib->vba.vtaps[k] - 1); + + mode_lib->vba.LBLatencyHidingSourceLinesC = +- dml_min(mode_lib->vba.MaxLineBufferLines, +- (unsigned int)dml_floor((double)mode_lib->vba.LineBufferSize +- / mode_lib->vba.LBBitPerPixel[k] +- / (mode_lib->vba.SwathWidthY[k] +- / 2.0 +- / dml_max(mode_lib->vba.HRatio[k] +- / 2, +- 1.0)), +- 1)) - (mode_lib->vba.VTAPsChroma[k] - 1); +- +- EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY / mode_lib->vba.VRatio[k] +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); +- +- EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC / (mode_lib->vba.VRatio[k] / 2) +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ dml_min( ++ mode_lib->vba.MaxLineBufferLines, ++ (unsigned int) dml_floor( ++ (double) mode_lib->vba.LineBufferSize ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.SwathWidthY[k] ++ / 2.0 ++ / dml_max( ++ mode_lib->vba.HRatio[k] ++ / 2, ++ 1.0)), ++ 1)) ++ - (mode_lib->vba.VTAPsChroma[k] - 1); ++ ++ EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY ++ / mode_lib->vba.VRatio[k] ++ * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ ++ EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC ++ / (mode_lib->vba.VRatio[k] / 2) ++ * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); + + if (mode_lib->vba.SwathWidthY[k] > 2 * mode_lib->vba.DPPOutputBufferPixels) { +- DPPOutputBufferLinesY = mode_lib->vba.DPPOutputBufferPixels / mode_lib->vba.SwathWidthY[k]; ++ DPPOutputBufferLinesY = mode_lib->vba.DPPOutputBufferPixels ++ / mode_lib->vba.SwathWidthY[k]; + } else if (mode_lib->vba.SwathWidthY[k] > mode_lib->vba.DPPOutputBufferPixels) { + DPPOutputBufferLinesY = 0.5; + } else { +@@ -2562,7 +3009,8 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + } + + if (mode_lib->vba.SwathWidthY[k] / 2 > 2 * mode_lib->vba.DPPOutputBufferPixels) { +- DPPOutputBufferLinesC = mode_lib->vba.DPPOutputBufferPixels / (mode_lib->vba.SwathWidthY[k] / 2); ++ DPPOutputBufferLinesC = mode_lib->vba.DPPOutputBufferPixels ++ / (mode_lib->vba.SwathWidthY[k] / 2); + } else if (mode_lib->vba.SwathWidthY[k] / 2 > mode_lib->vba.DPPOutputBufferPixels) { + DPPOutputBufferLinesC = 0.5; + } else { +@@ -2570,46 +3018,59 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + } + + DPPOPPBufferingY = (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) +- * (DPPOutputBufferLinesY + mode_lib->vba.OPPOutputBufferLines); ++ * (DPPOutputBufferLinesY + mode_lib->vba.OPPOutputBufferLines); + MaxDETBufferingTimeY = mode_lib->vba.FullDETBufferingTimeY[k] +- + (mode_lib->vba.LinesInDETY[k] - mode_lib->vba.LinesInDETYRoundedDownToSwath[k]) +- / mode_lib->vba.SwathHeightY[k] * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ + (mode_lib->vba.LinesInDETY[k] ++ - mode_lib->vba.LinesInDETYRoundedDownToSwath[k]) ++ / mode_lib->vba.SwathHeightY[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); + + ActiveDRAMClockChangeLatencyMarginY = DPPOPPBufferingY + EffectiveLBLatencyHidingY +- + MaxDETBufferingTimeY - mode_lib->vba.DRAMClockChangeWatermark; ++ + MaxDETBufferingTimeY - mode_lib->vba.DRAMClockChangeWatermark; + + if (mode_lib->vba.ActiveDPPs > 1) { +- ActiveDRAMClockChangeLatencyMarginY = ActiveDRAMClockChangeLatencyMarginY +- - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1)) * mode_lib->vba.SwathHeightY[k] +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ ActiveDRAMClockChangeLatencyMarginY = ++ ActiveDRAMClockChangeLatencyMarginY ++ - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1)) ++ * mode_lib->vba.SwathHeightY[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); + } + + if (mode_lib->vba.BytePerPixelDETC[k] > 0) { +- double DPPOPPBufferingC = (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) +- * (DPPOutputBufferLinesC + mode_lib->vba.OPPOutputBufferLines); ++ double DPPOPPBufferingC = (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ * (DPPOutputBufferLinesC ++ + mode_lib->vba.OPPOutputBufferLines); + double MaxDETBufferingTimeC = +- mode_lib->vba.FullDETBufferingTimeC[k] +- + (mode_lib->vba.LinesInDETC[k] +- - mode_lib->vba.LinesInDETCRoundedDownToSwath[k]) +- / mode_lib->vba.SwathHeightC[k] +- * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ mode_lib->vba.FullDETBufferingTimeC[k] ++ + (mode_lib->vba.LinesInDETC[k] ++ - mode_lib->vba.LinesInDETCRoundedDownToSwath[k]) ++ / mode_lib->vba.SwathHeightC[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); + double ActiveDRAMClockChangeLatencyMarginC = DPPOPPBufferingC +- + EffectiveLBLatencyHidingC + MaxDETBufferingTimeC +- - mode_lib->vba.DRAMClockChangeWatermark; ++ + EffectiveLBLatencyHidingC + MaxDETBufferingTimeC ++ - mode_lib->vba.DRAMClockChangeWatermark; + + if (mode_lib->vba.ActiveDPPs > 1) { + ActiveDRAMClockChangeLatencyMarginC = +- ActiveDRAMClockChangeLatencyMarginC +- - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1)) +- * mode_lib->vba.SwathHeightC[k] +- * (mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]); +- } +- mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(ActiveDRAMClockChangeLatencyMarginY, +- ActiveDRAMClockChangeLatencyMarginC); ++ ActiveDRAMClockChangeLatencyMarginC ++ - (1 ++ - 1 ++ / (mode_lib->vba.ActiveDPPs ++ - 1)) ++ * mode_lib->vba.SwathHeightC[k] ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); ++ } ++ mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min( ++ ActiveDRAMClockChangeLatencyMarginY, ++ ActiveDRAMClockChangeLatencyMarginC); + } else { + mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = +- ActiveDRAMClockChangeLatencyMarginY; ++ ActiveDRAMClockChangeLatencyMarginY; + } + + if (mode_lib->vba.WritebackEnable[k]) { +@@ -2617,51 +3078,60 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + + if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { + WritebackDRAMClockChangeLatencyMargin = +- (double)(mode_lib->vba.WritebackInterfaceLumaBufferSize +- + mode_lib->vba.WritebackInterfaceChromaBufferSize) +- / (mode_lib->vba.WritebackDestinationWidth[k] +- * mode_lib->vba.WritebackDestinationHeight[k] +- / (mode_lib->vba.WritebackSourceHeight[k] +- * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k]) +- * 4) +- - mode_lib->vba.WritebackDRAMClockChangeWatermark; ++ (double) (mode_lib->vba.WritebackInterfaceLumaBufferSize ++ + mode_lib->vba.WritebackInterfaceChromaBufferSize) ++ / (mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ * 4) ++ - mode_lib->vba.WritebackDRAMClockChangeWatermark; + } else if (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { +- WritebackDRAMClockChangeLatencyMargin = dml_min((double)mode_lib->vba.WritebackInterfaceLumaBufferSize * 8.0 +- / 10, +- 2.0 * mode_lib->vba.WritebackInterfaceChromaBufferSize * 8 / 10) +- / (mode_lib->vba.WritebackDestinationWidth[k] +- * mode_lib->vba.WritebackDestinationHeight[k] +- / (mode_lib->vba.WritebackSourceHeight[k] +- * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k])) +- - mode_lib->vba.WritebackDRAMClockChangeWatermark; ++ WritebackDRAMClockChangeLatencyMargin = ++ dml_min( ++ (double) mode_lib->vba.WritebackInterfaceLumaBufferSize ++ * 8.0 / 10, ++ 2.0 ++ * mode_lib->vba.WritebackInterfaceChromaBufferSize ++ * 8 / 10) ++ / (mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k])) ++ - mode_lib->vba.WritebackDRAMClockChangeWatermark; + } else { +- WritebackDRAMClockChangeLatencyMargin = dml_min((double)mode_lib->vba.WritebackInterfaceLumaBufferSize, +- 2.0 * mode_lib->vba.WritebackInterfaceChromaBufferSize) +- / (mode_lib->vba.WritebackDestinationWidth[k] +- * mode_lib->vba.WritebackDestinationHeight[k] +- / (mode_lib->vba.WritebackSourceHeight[k] +- * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k])) +- - mode_lib->vba.WritebackDRAMClockChangeWatermark; ++ WritebackDRAMClockChangeLatencyMargin = ++ dml_min( ++ (double) mode_lib->vba.WritebackInterfaceLumaBufferSize, ++ 2.0 ++ * mode_lib->vba.WritebackInterfaceChromaBufferSize) ++ / (mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k])) ++ - mode_lib->vba.WritebackDRAMClockChangeWatermark; + } +- mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], +- WritebackDRAMClockChangeLatencyMargin); ++ mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min( ++ mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], ++ WritebackDRAMClockChangeLatencyMargin); + } + } + + mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] +- < mode_lib->vba.MinActiveDRAMClockChangeMargin) { ++ < mode_lib->vba.MinActiveDRAMClockChangeMargin) { + mode_lib->vba.MinActiveDRAMClockChangeMargin = +- mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]; ++ mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]; + } + } + +- mode_lib->vba.MinActiveDRAMClockChangeLatencySupported = mode_lib->vba.MinActiveDRAMClockChangeMargin +- + mode_lib->vba.DRAMClockChangeLatency; ++ mode_lib->vba.MinActiveDRAMClockChangeLatencySupported = ++ mode_lib->vba.MinActiveDRAMClockChangeMargin ++ + mode_lib->vba.DRAMClockChangeLatency; + + if (mode_lib->vba.MinActiveDRAMClockChangeMargin > 0) { + mode_lib->vba.DRAMClockChangeSupport = dm_dram_clock_change_vactive; +@@ -2670,7 +3140,8 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + mode_lib->vba.DRAMClockChangeSupport = dm_dram_clock_change_vblank; + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + if (!mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k]) { +- mode_lib->vba.DRAMClockChangeSupport = dm_dram_clock_change_unsupported; ++ mode_lib->vba.DRAMClockChangeSupport = ++ dm_dram_clock_change_unsupported; + } + } + } else { +@@ -2686,48 +3157,74 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + mode_lib->vba.XFCSlaveVUpdateOffset[k] = mode_lib->vba.XFCTSlvVupdateOffset; + mode_lib->vba.XFCSlaveVupdateWidth[k] = mode_lib->vba.XFCTSlvVupdateWidth; + mode_lib->vba.XFCSlaveVReadyOffset[k] = mode_lib->vba.XFCTSlvVreadyOffset; +- TWait = CalculateTWait(mode_lib->vba.PrefetchMode, +- mode_lib->vba.DRAMClockChangeLatency, +- mode_lib->vba.UrgentLatency, +- mode_lib->vba.SREnterPlusExitTime); +- mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay(mode_lib, +- mode_lib->vba.VRatio[k], +- mode_lib->vba.SwathWidthY[k], +- dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), +- mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], +- mode_lib->vba.XFCTSlvVupdateOffset, +- mode_lib->vba.XFCTSlvVupdateWidth, +- mode_lib->vba.XFCTSlvVreadyOffset, +- mode_lib->vba.XFCXBUFLatencyTolerance, +- mode_lib->vba.XFCFillBWOverhead, +- mode_lib->vba.XFCSlvChunkSize, +- mode_lib->vba.XFCBusTransportTime, +- mode_lib->vba.TCalc, +- TWait, +- &mode_lib->vba.SrcActiveDrainRate, +- &mode_lib->vba.TInitXFill, +- &mode_lib->vba.TslvChk); +- mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = dml_floor(mode_lib->vba.XFCRemoteSurfaceFlipDelay / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), +- 1); +- mode_lib->vba.XFCTransferDelay[k] = dml_ceil(mode_lib->vba.XFCBusTransportTime / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), +- 1); +- mode_lib->vba.XFCPrechargeDelay[k] = dml_ceil((mode_lib->vba.XFCBusTransportTime + mode_lib->vba.TInitXFill + mode_lib->vba.TslvChk) +- / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), +- 1); +- mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance * mode_lib->vba.SrcActiveDrainRate; +- mode_lib->vba.FinalFillMargin = (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] +- + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) * mode_lib->vba.HTotal[k] +- / mode_lib->vba.PixelClock[k] * mode_lib->vba.SrcActiveDrainRate + mode_lib->vba.XFCFillConstant; +- mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay * mode_lib->vba.SrcActiveDrainRate +- + mode_lib->vba.FinalFillMargin; +- mode_lib->vba.RemainingFillLevel = dml_max(0.0, +- mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel); ++ TWait = CalculateTWait( ++ mode_lib->vba.PrefetchMode, ++ mode_lib->vba.DRAMClockChangeLatency, ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.SREnterPlusExitTime); ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay( ++ mode_lib, ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.SwathWidthY[k], ++ dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), ++ mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], ++ mode_lib->vba.XFCTSlvVupdateOffset, ++ mode_lib->vba.XFCTSlvVupdateWidth, ++ mode_lib->vba.XFCTSlvVreadyOffset, ++ mode_lib->vba.XFCXBUFLatencyTolerance, ++ mode_lib->vba.XFCFillBWOverhead, ++ mode_lib->vba.XFCSlvChunkSize, ++ mode_lib->vba.XFCBusTransportTime, ++ mode_lib->vba.TCalc, ++ TWait, ++ &mode_lib->vba.SrcActiveDrainRate, ++ &mode_lib->vba.TInitXFill, ++ &mode_lib->vba.TslvChk); ++ mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = ++ dml_floor( ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay ++ / (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]), ++ 1); ++ mode_lib->vba.XFCTransferDelay[k] = ++ dml_ceil( ++ mode_lib->vba.XFCBusTransportTime ++ / (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]), ++ 1); ++ mode_lib->vba.XFCPrechargeDelay[k] = ++ dml_ceil( ++ (mode_lib->vba.XFCBusTransportTime ++ + mode_lib->vba.TInitXFill ++ + mode_lib->vba.TslvChk) ++ / (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]), ++ 1); ++ mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance ++ * mode_lib->vba.SrcActiveDrainRate; ++ mode_lib->vba.FinalFillMargin = ++ (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] ++ + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k] ++ * mode_lib->vba.SrcActiveDrainRate ++ + mode_lib->vba.XFCFillConstant; ++ mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay ++ * mode_lib->vba.SrcActiveDrainRate ++ + mode_lib->vba.FinalFillMargin; ++ mode_lib->vba.RemainingFillLevel = dml_max( ++ 0.0, ++ mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel); + mode_lib->vba.TFinalxFill = mode_lib->vba.RemainingFillLevel +- / (mode_lib->vba.SrcActiveDrainRate * mode_lib->vba.XFCFillBWOverhead / 100); +- mode_lib->vba.XFCPrefetchMargin[k] = mode_lib->vba.XFCRemoteSurfaceFlipDelay + mode_lib->vba.TFinalxFill +- + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] +- + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) +- * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]; ++ / (mode_lib->vba.SrcActiveDrainRate ++ * mode_lib->vba.XFCFillBWOverhead / 100); ++ mode_lib->vba.XFCPrefetchMargin[k] = ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay ++ + mode_lib->vba.TFinalxFill ++ + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] ++ + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]; + } else { + mode_lib->vba.XFCSlaveVUpdateOffset[k] = 0; + mode_lib->vba.XFCSlaveVupdateWidth[k] = 0; +@@ -2782,21 +3279,22 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + BytePerPixDETC = 8.0 / 3.0; + } + +- if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 +- || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 +- || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { ++ if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { + if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { + Read256BytesBlockHeightY = 1; + } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { + Read256BytesBlockHeightY = 4; + } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32 +- || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) { ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) { + Read256BytesBlockHeightY = 8; + } else { + Read256BytesBlockHeightY = 16; + } + Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1) +- / Read256BytesBlockHeightY; ++ / Read256BytesBlockHeightY; + Read256BytesBlockHeightC = 0; + Read256BytesBlockWidthC = 0; + } else { +@@ -2811,9 +3309,9 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + Read256BytesBlockHeightC = 8; + } + Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1) +- / Read256BytesBlockHeightY; ++ / Read256BytesBlockHeightY; + Read256BytesBlockWidthC = 256 / dml_ceil(BytePerPixDETC, 2) +- / Read256BytesBlockHeightC; ++ / Read256BytesBlockHeightC; + } + + if (mode_lib->vba.SourceScan[k] == dm_horz) { +@@ -2824,27 +3322,30 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + MaximumSwathHeightC = Read256BytesBlockWidthC; + } + +- if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 +- || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 +- || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { ++ if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { + if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear +- || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 +- && (mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_s +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_4kb_s_x +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_64kb_s +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_64kb_s_t +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_64kb_s_x +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_var_s +- || mode_lib->vba.SurfaceTiling[k] +- == dm_sw_var_s_x) +- && mode_lib->vba.SourceScan[k] == dm_horz)) { ++ || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ && (mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_4kb_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_4kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s_t ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_var_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_var_s_x) ++ && mode_lib->vba.SourceScan[k] == dm_horz)) { + MinimumSwathHeightY = MaximumSwathHeightY; +- } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8 && mode_lib->vba.SourceScan[k] != dm_horz) { ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8 ++ && mode_lib->vba.SourceScan[k] != dm_horz) { + MinimumSwathHeightY = MaximumSwathHeightY; + } else { + MinimumSwathHeightY = MaximumSwathHeightY / 2.0; +@@ -2854,10 +3355,12 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { + MinimumSwathHeightY = MaximumSwathHeightY; + MinimumSwathHeightC = MaximumSwathHeightC; +- } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 && mode_lib->vba.SourceScan[k] == dm_horz) { ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 ++ && mode_lib->vba.SourceScan[k] == dm_horz) { + MinimumSwathHeightY = MaximumSwathHeightY / 2.0; + MinimumSwathHeightC = MaximumSwathHeightC; +- } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10 && mode_lib->vba.SourceScan[k] == dm_horz) { ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10 ++ && mode_lib->vba.SourceScan[k] == dm_horz) { + MinimumSwathHeightC = MaximumSwathHeightC / 2.0; + MinimumSwathHeightY = MaximumSwathHeightY; + } else { +@@ -2876,40 +3379,46 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + MainPlaneDoesODMCombine = true; + } + for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) { +- if (mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.ODMCombineEnabled[j] == true) { ++ if (mode_lib->vba.BlendingAndTiming[k] == j ++ && mode_lib->vba.ODMCombineEnabled[j] == true) { + MainPlaneDoesODMCombine = true; + } + } + + if (MainPlaneDoesODMCombine == true) { +- SwathWidth = dml_min(SwathWidth, mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]); ++ SwathWidth = dml_min( ++ SwathWidth, ++ mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]); + } else { + SwathWidth = SwathWidth / mode_lib->vba.DPPPerPlane[k]; + } + + SwathWidthGranularityY = 256 / dml_ceil(BytePerPixDETY, 1) / MaximumSwathHeightY; +- RoundedUpMaxSwathSizeBytesY = (dml_ceil((double)(SwathWidth - 1), +- SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY +- * MaximumSwathHeightY; ++ RoundedUpMaxSwathSizeBytesY = (dml_ceil( ++ (double) (SwathWidth - 1), ++ SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY ++ * MaximumSwathHeightY; + if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { + RoundedUpMaxSwathSizeBytesY = dml_ceil(RoundedUpMaxSwathSizeBytesY, 256) +- + 256; ++ + 256; + } + if (MaximumSwathHeightC > 0) { + SwathWidthGranularityC = 256.0 / dml_ceil(BytePerPixDETC, 2) +- / MaximumSwathHeightC; +- RoundedUpMaxSwathSizeBytesC = (dml_ceil((double)(SwathWidth / 2.0 - 1), +- SwathWidthGranularityC) + SwathWidthGranularityC) +- * BytePerPixDETC * MaximumSwathHeightC; ++ / MaximumSwathHeightC; ++ RoundedUpMaxSwathSizeBytesC = (dml_ceil( ++ (double) (SwathWidth / 2.0 - 1), ++ SwathWidthGranularityC) + SwathWidthGranularityC) ++ * BytePerPixDETC * MaximumSwathHeightC; + if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { +- RoundedUpMaxSwathSizeBytesC = dml_ceil(RoundedUpMaxSwathSizeBytesC, +- 256) + 256; ++ RoundedUpMaxSwathSizeBytesC = dml_ceil( ++ RoundedUpMaxSwathSizeBytesC, ++ 256) + 256; + } + } else + RoundedUpMaxSwathSizeBytesC = 0.0; + + if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC +- <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) { ++ <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) { + mode_lib->vba.SwathHeightY[k] = MaximumSwathHeightY; + mode_lib->vba.SwathHeightC[k] = MaximumSwathHeightC; + } else { +@@ -2921,27 +3430,32 @@ static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib) + mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024; + mode_lib->vba.DETBufferSizeC[k] = 0; + } else if (mode_lib->vba.SwathHeightY[k] <= mode_lib->vba.SwathHeightC[k]) { +- mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2; +- mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2; ++ mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 2; ++ mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 2; + } else { +- mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024.0 * 2 / 3; +- mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 3; ++ mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 * 2 / 3; ++ mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 3; + } + } + } + +-bool Calculate256BBlockSizes(enum source_format_class SourcePixelFormat, +- enum dm_swizzle_mode SurfaceTiling, +- unsigned int BytePerPixelY, +- unsigned int BytePerPixelC, +- unsigned int *BlockHeight256BytesY, +- unsigned int *BlockHeight256BytesC, +- unsigned int *BlockWidth256BytesY, +- unsigned int *BlockWidth256BytesC) ++bool Calculate256BBlockSizes( ++ enum source_format_class SourcePixelFormat, ++ enum dm_swizzle_mode SurfaceTiling, ++ unsigned int BytePerPixelY, ++ unsigned int BytePerPixelC, ++ unsigned int *BlockHeight256BytesY, ++ unsigned int *BlockHeight256BytesC, ++ unsigned int *BlockWidth256BytesY, ++ unsigned int *BlockWidth256BytesC) + { + if ((SourcePixelFormat == dm_444_64 || SourcePixelFormat == dm_444_32 +- || SourcePixelFormat == dm_444_16 || SourcePixelFormat == dm_444_16 +- || SourcePixelFormat == dm_444_8)) { ++ || SourcePixelFormat == dm_444_16 || SourcePixelFormat == dm_444_16 ++ || SourcePixelFormat == dm_444_8)) { + if (SurfaceTiling == dm_sw_linear) { + *BlockHeight256BytesY = 1; + } else if (SourcePixelFormat == dm_444_64) { +@@ -2971,14 +3485,16 @@ bool Calculate256BBlockSizes(enum source_format_class SourcePixelFormat, + return true; + } + +-static double CalculateTWait(unsigned int PrefetchMode, +- double DRAMClockChangeLatency, +- double UrgentLatency, +- double SREnterPlusExitTime) ++static double CalculateTWait( ++ unsigned int PrefetchMode, ++ double DRAMClockChangeLatency, ++ double UrgentLatency, ++ double SREnterPlusExitTime) + { + if (PrefetchMode == 0) { +- return dml_max(DRAMClockChangeLatency + UrgentLatency, +- dml_max(SREnterPlusExitTime, UrgentLatency)); ++ return dml_max( ++ DRAMClockChangeLatency + UrgentLatency, ++ dml_max(SREnterPlusExitTime, UrgentLatency)); + } else if (PrefetchMode == 1) { + return dml_max(SREnterPlusExitTime, UrgentLatency); + } else { +@@ -2986,23 +3502,24 @@ static double CalculateTWait(unsigned int PrefetchMode, + } + } + +-static double CalculateRemoteSurfaceFlipDelay(struct display_mode_lib *mode_lib, +- double VRatio, +- double SwathWidth, +- double Bpp, +- double LineTime, +- double XFCTSlvVupdateOffset, +- double XFCTSlvVupdateWidth, +- double XFCTSlvVreadyOffset, +- double XFCXBUFLatencyTolerance, +- double XFCFillBWOverhead, +- double XFCSlvChunkSize, +- double XFCBusTransportTime, +- double TCalc, +- double TWait, +- double *SrcActiveDrainRate, +- double *TInitXFill, +- double *TslvChk) ++static double CalculateRemoteSurfaceFlipDelay( ++ struct display_mode_lib *mode_lib, ++ double VRatio, ++ double SwathWidth, ++ double Bpp, ++ double LineTime, ++ double XFCTSlvVupdateOffset, ++ double XFCTSlvVupdateWidth, ++ double XFCTSlvVreadyOffset, ++ double XFCXBUFLatencyTolerance, ++ double XFCFillBWOverhead, ++ double XFCSlvChunkSize, ++ double XFCBusTransportTime, ++ double TCalc, ++ double TWait, ++ double *SrcActiveDrainRate, ++ double *TInitXFill, ++ double *TslvChk) + { + double TSlvSetup, AvgfillRate, result; + +@@ -3011,8 +3528,9 @@ static double CalculateRemoteSurfaceFlipDelay(struct display_mode_lib *mode_lib, + *TInitXFill = XFCXBUFLatencyTolerance / (1 + XFCFillBWOverhead / 100); + AvgfillRate = *SrcActiveDrainRate * (1 + XFCFillBWOverhead / 100); + *TslvChk = XFCSlvChunkSize / AvgfillRate; +- dml_print("DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n", +- *SrcActiveDrainRate); ++ dml_print( ++ "DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n", ++ *SrcActiveDrainRate); + dml_print("DML::CalculateRemoteSurfaceFlipDelay: TSlvSetup: %f\n", TSlvSetup); + dml_print("DML::CalculateRemoteSurfaceFlipDelay: TInitXFill: %f\n", *TInitXFill); + dml_print("DML::CalculateRemoteSurfaceFlipDelay: AvgfillRate: %f\n", AvgfillRate); +@@ -3022,99 +3540,192 @@ static double CalculateRemoteSurfaceFlipDelay(struct display_mode_lib *mode_lib, + return result; + } + +-static double CalculateWriteBackDISPCLK(enum source_format_class WritebackPixelFormat, +- double PixelClock, +- double WritebackHRatio, +- double WritebackVRatio, +- unsigned int WritebackLumaHTaps, +- unsigned int WritebackLumaVTaps, +- unsigned int WritebackChromaHTaps, +- unsigned int WritebackChromaVTaps, +- double WritebackDestinationWidth, +- unsigned int HTotal, +- unsigned int WritebackChromaLineBufferWidth) ++static double CalculateWriteBackDISPCLK( ++ enum source_format_class WritebackPixelFormat, ++ double PixelClock, ++ double WritebackHRatio, ++ double WritebackVRatio, ++ unsigned int WritebackLumaHTaps, ++ unsigned int WritebackLumaVTaps, ++ unsigned int WritebackChromaHTaps, ++ unsigned int WritebackChromaVTaps, ++ double WritebackDestinationWidth, ++ unsigned int HTotal, ++ unsigned int WritebackChromaLineBufferWidth) + { +- double CalculateWriteBackDISPCLK = 1.01 * PixelClock +- * dml_max( +- dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio, +- dml_max( +- (WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1) +- * dml_ceil(WritebackDestinationWidth / 4.0, 1) +- + dml_ceil(WritebackDestinationWidth / 4.0, 1)) / (double)HTotal +- + dml_ceil(1.0 / WritebackVRatio, 1) * (dml_ceil(WritebackLumaVTaps / 4.0, 1) + 4.0) +- / (double)HTotal, +- dml_ceil(1.0 / WritebackVRatio, 1) * WritebackDestinationWidth / (double)HTotal)); +- if (WritebackPixelFormat != dm_444_32) { +- CalculateWriteBackDISPCLK = dml_max( +- CalculateWriteBackDISPCLK, ++ double CalculateWriteBackDISPCLK = + 1.01 * PixelClock +- * dml_max( +- dml_ceil(WritebackChromaHTaps / 2.0, 1) / (2 * WritebackHRatio), ++ * dml_max( ++ dml_ceil(WritebackLumaHTaps / 4.0, 1) ++ / WritebackHRatio, ++ dml_max( ++ (WritebackLumaVTaps ++ * dml_ceil( ++ 1.0 ++ / WritebackVRatio, ++ 1) ++ * dml_ceil( ++ WritebackDestinationWidth ++ / 4.0, ++ 1) ++ + dml_ceil( ++ WritebackDestinationWidth ++ / 4.0, ++ 1)) ++ / (double) HTotal ++ + dml_ceil( ++ 1.0 ++ / WritebackVRatio, ++ 1) ++ * (dml_ceil( ++ WritebackLumaVTaps ++ / 4.0, ++ 1) ++ + 4.0) ++ / (double) HTotal, ++ dml_ceil( ++ 1.0 ++ / WritebackVRatio, ++ 1) ++ * WritebackDestinationWidth ++ / (double) HTotal)); ++ if (WritebackPixelFormat != dm_444_32) { ++ CalculateWriteBackDISPCLK = + dml_max( +- (WritebackChromaVTaps * dml_ceil(1 / (2 * WritebackVRatio), 1) +- * dml_ceil(WritebackDestinationWidth / 2.0 / 2.0, 1) +- + dml_ceil(WritebackDestinationWidth / 2.0 / WritebackChromaLineBufferWidth, 1)) +- / HTotal +- + dml_ceil(1 / (2 * WritebackVRatio), 1) +- * (dml_ceil(WritebackChromaVTaps / 4.0, 1) + 4) / HTotal, +- dml_ceil(1.0 / (2 * WritebackVRatio), 1) * WritebackDestinationWidth / 2.0 +- / HTotal))); ++ CalculateWriteBackDISPCLK, ++ 1.01 * PixelClock ++ * dml_max( ++ dml_ceil( ++ WritebackChromaHTaps ++ / 2.0, ++ 1) ++ / (2 ++ * WritebackHRatio), ++ dml_max( ++ (WritebackChromaVTaps ++ * dml_ceil( ++ 1 ++ / (2 ++ * WritebackVRatio), ++ 1) ++ * dml_ceil( ++ WritebackDestinationWidth ++ / 2.0 ++ / 2.0, ++ 1) ++ + dml_ceil( ++ WritebackDestinationWidth ++ / 2.0 ++ / WritebackChromaLineBufferWidth, ++ 1)) ++ / HTotal ++ + dml_ceil( ++ 1 ++ / (2 ++ * WritebackVRatio), ++ 1) ++ * (dml_ceil( ++ WritebackChromaVTaps ++ / 4.0, ++ 1) ++ + 4) ++ / HTotal, ++ dml_ceil( ++ 1.0 ++ / (2 ++ * WritebackVRatio), ++ 1) ++ * WritebackDestinationWidth ++ / 2.0 ++ / HTotal))); + } + return CalculateWriteBackDISPCLK; + } + + static double CalculateWriteBackDelay( +-enum source_format_class WritebackPixelFormat, +- double WritebackHRatio, +- double WritebackVRatio, +- unsigned int WritebackLumaHTaps, +- unsigned int WritebackLumaVTaps, +- unsigned int WritebackChromaHTaps, +- unsigned int WritebackChromaVTaps, +- unsigned int WritebackDestinationWidth) ++ enum source_format_class WritebackPixelFormat, ++ double WritebackHRatio, ++ double WritebackVRatio, ++ unsigned int WritebackLumaHTaps, ++ unsigned int WritebackLumaVTaps, ++ unsigned int WritebackChromaHTaps, ++ unsigned int WritebackChromaVTaps, ++ unsigned int WritebackDestinationWidth) + { +- double CalculateWriteBackDelay = dml_max( +- dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio, +- WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1) +- * dml_ceil(WritebackDestinationWidth / 4.0, 1) +- + dml_ceil(1.0 / WritebackVRatio, 1) * (dml_ceil(WritebackLumaVTaps / 4.0, 1) + 4)); ++ double CalculateWriteBackDelay = ++ dml_max( ++ dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio, ++ WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1) ++ * dml_ceil( ++ WritebackDestinationWidth ++ / 4.0, ++ 1) ++ + dml_ceil(1.0 / WritebackVRatio, 1) ++ * (dml_ceil( ++ WritebackLumaVTaps ++ / 4.0, ++ 1) + 4)); + + if (WritebackPixelFormat != dm_444_32) { +- CalculateWriteBackDelay = dml_max( +- CalculateWriteBackDelay, +- dml_max( +- dml_ceil(WritebackChromaHTaps / 2.0, 1) / (2 * WritebackHRatio), +- WritebackChromaVTaps * dml_ceil(1 / (2 * WritebackVRatio), 1) +- * dml_ceil(WritebackDestinationWidth / 2.0 / 2.0, 1) +- + dml_ceil(1 / (2 * WritebackVRatio), 1) +- * (dml_ceil(WritebackChromaVTaps / 4.0, 1) + 4))); ++ CalculateWriteBackDelay = ++ dml_max( ++ CalculateWriteBackDelay, ++ dml_max( ++ dml_ceil( ++ WritebackChromaHTaps ++ / 2.0, ++ 1) ++ / (2 ++ * WritebackHRatio), ++ WritebackChromaVTaps ++ * dml_ceil( ++ 1 ++ / (2 ++ * WritebackVRatio), ++ 1) ++ * dml_ceil( ++ WritebackDestinationWidth ++ / 2.0 ++ / 2.0, ++ 1) ++ + dml_ceil( ++ 1 ++ / (2 ++ * WritebackVRatio), ++ 1) ++ * (dml_ceil( ++ WritebackChromaVTaps ++ / 4.0, ++ 1) ++ + 4))); + } + return CalculateWriteBackDelay; + } + +-static void CalculateActiveRowBandwidth(bool VirtualMemoryEnable, +- enum source_format_class SourcePixelFormat, +- double VRatio, +- bool DCCEnable, +- double LineTime, +- unsigned int MetaRowByteLuma, +- unsigned int MetaRowByteChroma, +- unsigned int meta_row_height_luma, +- unsigned int meta_row_height_chroma, +- unsigned int PixelPTEBytesPerRowLuma, +- unsigned int PixelPTEBytesPerRowChroma, +- unsigned int dpte_row_height_luma, +- unsigned int dpte_row_height_chroma, +- double *meta_row_bw, +- double *dpte_row_bw, +- double *qual_row_bw) ++static void CalculateActiveRowBandwidth( ++ bool VirtualMemoryEnable, ++ enum source_format_class SourcePixelFormat, ++ double VRatio, ++ bool DCCEnable, ++ double LineTime, ++ unsigned int MetaRowByteLuma, ++ unsigned int MetaRowByteChroma, ++ unsigned int meta_row_height_luma, ++ unsigned int meta_row_height_chroma, ++ unsigned int PixelPTEBytesPerRowLuma, ++ unsigned int PixelPTEBytesPerRowChroma, ++ unsigned int dpte_row_height_luma, ++ unsigned int dpte_row_height_chroma, ++ double *meta_row_bw, ++ double *dpte_row_bw, ++ double *qual_row_bw) + { + if (DCCEnable != true) { + *meta_row_bw = 0; + } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) { + *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime) +- + VRatio / 2 * MetaRowByteChroma +- / (meta_row_height_chroma * LineTime); ++ + VRatio / 2 * MetaRowByteChroma ++ / (meta_row_height_chroma * LineTime); + } else { + *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime); + } +@@ -3123,8 +3734,8 @@ static void CalculateActiveRowBandwidth(bool VirtualMemoryEnable, + *dpte_row_bw = 0; + } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) { + *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime) +- + VRatio / 2 * PixelPTEBytesPerRowChroma +- / (dpte_row_height_chroma * LineTime); ++ + VRatio / 2 * PixelPTEBytesPerRowChroma ++ / (dpte_row_height_chroma * LineTime); + } else { + *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime); + } +@@ -3136,29 +3747,30 @@ static void CalculateActiveRowBandwidth(bool VirtualMemoryEnable, + } + } + +-static void CalculateFlipSchedule(struct display_mode_lib *mode_lib, +- double UrgentExtraLatency, +- double UrgentLatency, +- unsigned int MaxPageTableLevels, +- bool VirtualMemoryEnable, +- double BandwidthAvailableForImmediateFlip, +- unsigned int TotImmediateFlipBytes, +- enum source_format_class SourcePixelFormat, +- unsigned int ImmediateFlipBytes, +- double LineTime, +- double Tno_bw, +- double VRatio, +- double PDEAndMetaPTEBytesFrame, +- unsigned int MetaRowByte, +- unsigned int PixelPTEBytesPerRow, +- bool DCCEnable, +- unsigned int dpte_row_height, +- unsigned int meta_row_height, +- double qual_row_bw, +- double *DestinationLinesToRequestVMInImmediateFlip, +- double *DestinationLinesToRequestRowInImmediateFlip, +- double *final_flip_bw, +- bool *ImmediateFlipSupportedForPipe) ++static void CalculateFlipSchedule( ++ struct display_mode_lib *mode_lib, ++ double UrgentExtraLatency, ++ double UrgentLatency, ++ unsigned int MaxPageTableLevels, ++ bool VirtualMemoryEnable, ++ double BandwidthAvailableForImmediateFlip, ++ unsigned int TotImmediateFlipBytes, ++ enum source_format_class SourcePixelFormat, ++ unsigned int ImmediateFlipBytes, ++ double LineTime, ++ double Tno_bw, ++ double VRatio, ++ double PDEAndMetaPTEBytesFrame, ++ unsigned int MetaRowByte, ++ unsigned int PixelPTEBytesPerRow, ++ bool DCCEnable, ++ unsigned int dpte_row_height, ++ unsigned int meta_row_height, ++ double qual_row_bw, ++ double *DestinationLinesToRequestVMInImmediateFlip, ++ double *DestinationLinesToRequestRowInImmediateFlip, ++ double *final_flip_bw, ++ bool *ImmediateFlipSupportedForPipe) + { + double min_row_time = 0.0; + +@@ -3172,47 +3784,54 @@ static void CalculateFlipSchedule(struct display_mode_lib *mode_lib, + double TimeForFetchingRowInVBlankImmediateFlip; + + if (VirtualMemoryEnable == true) { +- mode_lib->vba.ImmediateFlipBW = BandwidthAvailableForImmediateFlip * ImmediateFlipBytes +- / TotImmediateFlipBytes; ++ mode_lib->vba.ImmediateFlipBW = BandwidthAvailableForImmediateFlip ++ * ImmediateFlipBytes / TotImmediateFlipBytes; + TimeForFetchingMetaPTEImmediateFlip = +- dml_max(Tno_bw +- + PDEAndMetaPTEBytesFrame +- / mode_lib->vba.ImmediateFlipBW, +- dml_max(UrgentExtraLatency +- + UrgentLatency +- * (MaxPageTableLevels +- - 1), +- LineTime / 4.0)); ++ dml_max( ++ Tno_bw ++ + PDEAndMetaPTEBytesFrame ++ / mode_lib->vba.ImmediateFlipBW, ++ dml_max( ++ UrgentExtraLatency ++ + UrgentLatency ++ * (MaxPageTableLevels ++ - 1), ++ LineTime / 4.0)); + } else { + TimeForFetchingMetaPTEImmediateFlip = 0; + } + +- *DestinationLinesToRequestVMInImmediateFlip = dml_floor(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125), +- 1) / 4.0; ++ *DestinationLinesToRequestVMInImmediateFlip = dml_floor( ++ 4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125), ++ 1) / 4.0; + + if ((VirtualMemoryEnable == true || DCCEnable == true)) { +- mode_lib->vba.ImmediateFlipBW = BandwidthAvailableForImmediateFlip * ImmediateFlipBytes +- / TotImmediateFlipBytes; +- TimeForFetchingRowInVBlankImmediateFlip = dml_max((MetaRowByte + PixelPTEBytesPerRow) / mode_lib->vba.ImmediateFlipBW, +- dml_max(UrgentLatency, LineTime / 4.0)); ++ mode_lib->vba.ImmediateFlipBW = BandwidthAvailableForImmediateFlip ++ * ImmediateFlipBytes / TotImmediateFlipBytes; ++ TimeForFetchingRowInVBlankImmediateFlip = dml_max( ++ (MetaRowByte + PixelPTEBytesPerRow) ++ / mode_lib->vba.ImmediateFlipBW, ++ dml_max(UrgentLatency, LineTime / 4.0)); + } else { + TimeForFetchingRowInVBlankImmediateFlip = 0; + } + +- *DestinationLinesToRequestRowInImmediateFlip = dml_floor(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125), +- 1) / 4.0; ++ *DestinationLinesToRequestRowInImmediateFlip = dml_floor( ++ 4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125), ++ 1) / 4.0; + + if (VirtualMemoryEnable == true) { + *final_flip_bw = +- dml_max(PDEAndMetaPTEBytesFrame +- / (*DestinationLinesToRequestVMInImmediateFlip +- * LineTime), +- (MetaRowByte + PixelPTEBytesPerRow) +- / (TimeForFetchingRowInVBlankImmediateFlip +- * LineTime)); ++ dml_max( ++ PDEAndMetaPTEBytesFrame ++ / (*DestinationLinesToRequestVMInImmediateFlip ++ * LineTime), ++ (MetaRowByte + PixelPTEBytesPerRow) ++ / (TimeForFetchingRowInVBlankImmediateFlip ++ * LineTime)); + } else if (MetaRowByte + PixelPTEBytesPerRow > 0) { + *final_flip_bw = (MetaRowByte + PixelPTEBytesPerRow) +- / (TimeForFetchingRowInVBlankImmediateFlip * LineTime); ++ / (TimeForFetchingRowInVBlankImmediateFlip * LineTime); + } else { + *final_flip_bw = 0; + } +@@ -3223,12 +3842,13 @@ static void CalculateFlipSchedule(struct display_mode_lib *mode_lib, + min_row_time = meta_row_height * LineTime / VRatio; + else + min_row_time = dml_min(dpte_row_height, meta_row_height) * LineTime +- / VRatio; ++ / VRatio; + + if (*DestinationLinesToRequestVMInImmediateFlip >= 8 + || *DestinationLinesToRequestRowInImmediateFlip >= 16 + || TimeForFetchingMetaPTEImmediateFlip +- + 2 * TimeForFetchingRowInVBlankImmediateFlip > min_row_time) ++ + 2 * TimeForFetchingRowInVBlankImmediateFlip ++ > min_row_time) + *ImmediateFlipSupportedForPipe = false; + else + *ImmediateFlipSupportedForPipe = true; +@@ -3242,7 +3862,8 @@ static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct display_mod + //Progressive To dml_ml->vba.Interlace Unit Effect + for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { + mode_lib->vba.PixelClockBackEnd[k] = mode_lib->vba.PixelClock[k]; +- if (mode_lib->vba.Interlace[k] == 1 && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true) { ++ if (mode_lib->vba.Interlace[k] == 1 ++ && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true) { + mode_lib->vba.PixelClock[k] = 2 * mode_lib->vba.PixelClock[k]; + } + } +@@ -3261,3 +3882,2211 @@ static unsigned int CursorBppEnumToBits(enum cursor_bpp ebpp) + return 0; + } + } ++ ++static unsigned int TruncToValidBPP( ++ double DecimalBPP, ++ bool DSCEnabled, ++ enum output_encoder_class Output, ++ enum output_format_class Format, ++ unsigned int DSCInputBitPerComponent) ++{ ++ if (Output == dm_hdmi) { ++ if (Format == dm_420) { ++ if (DecimalBPP >= 18) ++ return 18; ++ else if (DecimalBPP >= 15) ++ return 15; ++ else if (DecimalBPP >= 12) ++ return 12; ++ else ++ return 0; ++ } else if (Format == dm_444) { ++ if (DecimalBPP >= 36) ++ return 36; ++ else if (DecimalBPP >= 30) ++ return 30; ++ else if (DecimalBPP >= 24) ++ return 24; ++ else ++ return 0; ++ } else { ++ if (DecimalBPP / 1.5 >= 24) ++ return 24; ++ else if (DecimalBPP / 1.5 >= 20) ++ return 20; ++ else if (DecimalBPP / 1.5 >= 16) ++ return 16; ++ else ++ return 0; ++ } ++ } else { ++ if (DSCEnabled) { ++ if (Format == dm_420) { ++ if (DecimalBPP < 6) ++ return 0; ++ else if (DecimalBPP >= 1.5 * DSCInputBitPerComponent - 1 / 16) ++ return 1.5 * DSCInputBitPerComponent - 1 / 16; ++ else ++ return dml_floor(16 * DecimalBPP, 1) / 16; ++ } else if (Format == dm_n422) { ++ if (DecimalBPP < 7) ++ return 0; ++ else if (DecimalBPP >= 2 * DSCInputBitPerComponent - 1 / 16) ++ return 2 * DSCInputBitPerComponent - 1 / 16; ++ else ++ return dml_floor(16 * DecimalBPP, 1) / 16; ++ } else { ++ if (DecimalBPP < 8) ++ return 0; ++ else if (DecimalBPP >= 3 * DSCInputBitPerComponent - 1 / 16) ++ return 3 * DSCInputBitPerComponent - 1 / 16; ++ else ++ return dml_floor(16 * DecimalBPP, 1) / 16; ++ } ++ } else if (Format == dm_420) { ++ if (DecimalBPP >= 18) ++ return 18; ++ else if (DecimalBPP >= 15) ++ return 15; ++ else if (DecimalBPP >= 12) ++ return 12; ++ else ++ return 0; ++ } else if (Format == dm_s422 || Format == dm_n422) { ++ if (DecimalBPP >= 24) ++ return 24; ++ else if (DecimalBPP >= 20) ++ return 20; ++ else if (DecimalBPP >= 16) ++ return 16; ++ else ++ return 0; ++ } else { ++ if (DecimalBPP >= 36) ++ return 36; ++ else if (DecimalBPP >= 30) ++ return 30; ++ else if (DecimalBPP >= 24) ++ return 24; ++ else ++ return 0; ++ } ++ } ++} ++ ++static void ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib) ++{ ++ int i; ++ unsigned int j, k; ++ /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/ ++ ++ /*Scale Ratio, taps Support Check*/ ++ ++ mode_lib->vba.ScaleRatioAndTapsSupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.ScalerEnabled[k] == false ++ && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) ++ || mode_lib->vba.HRatio[k] != 1.0 ++ || mode_lib->vba.htaps[k] != 1.0 ++ || mode_lib->vba.VRatio[k] != 1.0 ++ || mode_lib->vba.vtaps[k] != 1.0)) { ++ mode_lib->vba.ScaleRatioAndTapsSupport = false; ++ } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0 ++ || mode_lib->vba.htaps[k] < 1.0 || mode_lib->vba.htaps[k] > 8.0 ++ || (mode_lib->vba.htaps[k] > 1.0 ++ && (mode_lib->vba.htaps[k] % 2) == 1) ++ || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio ++ || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio ++ || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k] ++ || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k] ++ || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8 ++ && (mode_lib->vba.HRatio[k] / 2.0 ++ > mode_lib->vba.HTAPsChroma[k] ++ || mode_lib->vba.VRatio[k] / 2.0 ++ > mode_lib->vba.VTAPsChroma[k]))) { ++ mode_lib->vba.ScaleRatioAndTapsSupport = false; ++ } ++ } ++ /*Source Format, Pixel Format and Scan Support Check*/ ++ ++ mode_lib->vba.SourceFormatPixelAndScanSupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if ((mode_lib->vba.SurfaceTiling[k] == dm_sw_linear ++ && mode_lib->vba.SourceScan[k] != dm_horz) ++ || ((mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d_x) ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_64) ++ || (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x ++ && (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8 ++ || mode_lib->vba.SourcePixelFormat[k] ++ == dm_420_8 ++ || mode_lib->vba.SourcePixelFormat[k] ++ == dm_420_10)) ++ || (((mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_gfx7_2d_thin_gl ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_gfx7_2d_thin_lvp) ++ && !((mode_lib->vba.SourcePixelFormat[k] ++ == dm_444_64 ++ || mode_lib->vba.SourcePixelFormat[k] ++ == dm_444_32) ++ && mode_lib->vba.SourceScan[k] ++ == dm_horz ++ && mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp ++ == true ++ && mode_lib->vba.DCCEnable[k] ++ == false)) ++ || (mode_lib->vba.DCCEnable[k] == true ++ && (mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_linear ++ || mode_lib->vba.SourcePixelFormat[k] ++ == dm_420_8 ++ || mode_lib->vba.SourcePixelFormat[k] ++ == dm_420_10)))) { ++ mode_lib->vba.SourceFormatPixelAndScanSupport = false; ++ } ++ } ++ /*Bandwidth Support Check*/ ++ ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.SourceScan[k] == dm_horz) { ++ mode_lib->vba.SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k]; ++ } else { ++ mode_lib->vba.SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k]; ++ } ++ if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { ++ mode_lib->vba.BytePerPixelInDETY[k] = 8.0; ++ mode_lib->vba.BytePerPixelInDETC[k] = 0.0; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) { ++ mode_lib->vba.BytePerPixelInDETY[k] = 4.0; ++ mode_lib->vba.BytePerPixelInDETC[k] = 0.0; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16) { ++ mode_lib->vba.BytePerPixelInDETY[k] = 2.0; ++ mode_lib->vba.BytePerPixelInDETC[k] = 0.0; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8) { ++ mode_lib->vba.BytePerPixelInDETY[k] = 1.0; ++ mode_lib->vba.BytePerPixelInDETC[k] = 0.0; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) { ++ mode_lib->vba.BytePerPixelInDETY[k] = 1.0; ++ mode_lib->vba.BytePerPixelInDETC[k] = 2.0; ++ } else { ++ mode_lib->vba.BytePerPixelInDETY[k] = 4.0 / 3; ++ mode_lib->vba.BytePerPixelInDETC[k] = 8.0 / 3; ++ } ++ } ++ mode_lib->vba.TotalReadBandwidthConsumedGBytePerSecond = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.ReadBandwidth[k] = mode_lib->vba.SwathWidthYSingleDPP[k] ++ * (dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0) ++ * mode_lib->vba.VRatio[k] ++ + dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0) ++ / 2.0 * mode_lib->vba.VRatio[k] / 2) ++ / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); ++ if (mode_lib->vba.DCCEnable[k] == true) { ++ mode_lib->vba.ReadBandwidth[k] = mode_lib->vba.ReadBandwidth[k] ++ * (1 + 1 / 256); ++ } ++ if (mode_lib->vba.VirtualMemoryEnable == true ++ && mode_lib->vba.SourceScan[k] != dm_horz ++ && (mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_s ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x)) { ++ mode_lib->vba.ReadBandwidth[k] = mode_lib->vba.ReadBandwidth[k] ++ * (1 + 1 / 64); ++ } else if (mode_lib->vba.VirtualMemoryEnable == true ++ && mode_lib->vba.SourceScan[k] == dm_horz ++ && (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_32) ++ && (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_s ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_s_t ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x ++ || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x)) { ++ mode_lib->vba.ReadBandwidth[k] = mode_lib->vba.ReadBandwidth[k] ++ * (1 + 1 / 256); ++ } else if (mode_lib->vba.VirtualMemoryEnable == true) { ++ mode_lib->vba.ReadBandwidth[k] = mode_lib->vba.ReadBandwidth[k] ++ * (1 + 1 / 512); ++ } ++ mode_lib->vba.TotalReadBandwidthConsumedGBytePerSecond = ++ mode_lib->vba.TotalReadBandwidthConsumedGBytePerSecond ++ + mode_lib->vba.ReadBandwidth[k] / 1000.0; ++ } ++ mode_lib->vba.TotalWriteBandwidthConsumedGBytePerSecond = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true ++ && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { ++ mode_lib->vba.WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) * 4.0; ++ } else if (mode_lib->vba.WritebackEnable[k] == true ++ && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { ++ mode_lib->vba.WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) * 3.0; ++ } else if (mode_lib->vba.WritebackEnable[k] == true) { ++ mode_lib->vba.WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] ++ * mode_lib->vba.WritebackDestinationHeight[k] ++ / (mode_lib->vba.WritebackSourceHeight[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) * 1.5; ++ } else { ++ mode_lib->vba.WriteBandwidth[k] = 0.0; ++ } ++ mode_lib->vba.TotalWriteBandwidthConsumedGBytePerSecond = ++ mode_lib->vba.TotalWriteBandwidthConsumedGBytePerSecond ++ + mode_lib->vba.WriteBandwidth[k] / 1000.0; ++ } ++ mode_lib->vba.TotalBandwidthConsumedGBytePerSecond = ++ mode_lib->vba.TotalReadBandwidthConsumedGBytePerSecond ++ + mode_lib->vba.TotalWriteBandwidthConsumedGBytePerSecond; ++ mode_lib->vba.DCCEnabledInAnyPlane = false; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.DCCEnable[k] == true) { ++ mode_lib->vba.DCCEnabledInAnyPlane = true; ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.FabricAndDRAMBandwidthPerState[i] = dml_min( ++ mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels ++ * mode_lib->vba.DRAMChannelWidth, ++ mode_lib->vba.FabricClockPerState[i] ++ * mode_lib->vba.FabricDatapathToDCNDataReturn) ++ / 1000; ++ mode_lib->vba.ReturnBWToDCNPerState = dml_min( ++ mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKPerState[i], ++ mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000.0) ++ * mode_lib->vba.PercentOfIdealDRAMAndFabricBWReceivedAfterUrgLatency ++ / 100; ++ mode_lib->vba.ReturnBWPerState[i] = mode_lib->vba.ReturnBWToDCNPerState; ++ if (mode_lib->vba.DCCEnabledInAnyPlane == true ++ && mode_lib->vba.ReturnBWToDCNPerState ++ > mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.ReturnBusWidth ++ / 4.0) { ++ mode_lib->vba.ReturnBWPerState[i] = ++ dml_min( ++ mode_lib->vba.ReturnBWPerState[i], ++ mode_lib->vba.ReturnBWToDCNPerState * 4.0 ++ * (1.0 ++ - mode_lib->vba.UrgentLatency ++ / ((mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0 ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ - mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.ReturnBusWidth ++ / 4.0) ++ + mode_lib->vba.UrgentLatency))); ++ } ++ mode_lib->vba.CriticalPoint = ++ 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.UrgentLatency ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0); ++ if (mode_lib->vba.DCCEnabledInAnyPlane == true && mode_lib->vba.CriticalPoint > 1.0 ++ && mode_lib->vba.CriticalPoint < 4.0) { ++ mode_lib->vba.ReturnBWPerState[i] = ++ dml_min( ++ mode_lib->vba.ReturnBWPerState[i], ++ dml_pow( ++ 4.0 ++ * mode_lib->vba.ReturnBWToDCNPerState ++ * (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0 ++ * mode_lib->vba.ReturnBusWidth ++ * mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.UrgentLatency ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0), ++ 2)); ++ } ++ mode_lib->vba.ReturnBWToDCNPerState = dml_min( ++ mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKPerState[i], ++ mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000.0); ++ if (mode_lib->vba.DCCEnabledInAnyPlane == true ++ && mode_lib->vba.ReturnBWToDCNPerState ++ > mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.ReturnBusWidth ++ / 4.0) { ++ mode_lib->vba.ReturnBWPerState[i] = ++ dml_min( ++ mode_lib->vba.ReturnBWPerState[i], ++ mode_lib->vba.ReturnBWToDCNPerState * 4.0 ++ * (1.0 ++ - mode_lib->vba.UrgentLatency ++ / ((mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0 ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ - mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.ReturnBusWidth ++ / 4.0) ++ + mode_lib->vba.UrgentLatency))); ++ } ++ mode_lib->vba.CriticalPoint = ++ 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.UrgentLatency ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0); ++ if (mode_lib->vba.DCCEnabledInAnyPlane == true && mode_lib->vba.CriticalPoint > 1.0 ++ && mode_lib->vba.CriticalPoint < 4.0) { ++ mode_lib->vba.ReturnBWPerState[i] = ++ dml_min( ++ mode_lib->vba.ReturnBWPerState[i], ++ dml_pow( ++ 4.0 ++ * mode_lib->vba.ReturnBWToDCNPerState ++ * (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0 ++ * mode_lib->vba.ReturnBusWidth ++ * mode_lib->vba.DCFCLKPerState[i] ++ * mode_lib->vba.UrgentLatency ++ / (mode_lib->vba.ReturnBWToDCNPerState ++ * mode_lib->vba.UrgentLatency ++ + (mode_lib->vba.ROBBufferSizeInKByte ++ - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0), ++ 2)); ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ if ((mode_lib->vba.TotalReadBandwidthConsumedGBytePerSecond * 1000.0 ++ <= mode_lib->vba.ReturnBWPerState[i]) ++ && (mode_lib->vba.TotalBandwidthConsumedGBytePerSecond * 1000.0 ++ <= mode_lib->vba.FabricAndDRAMBandwidthPerState[i] ++ * 1000.0 ++ * mode_lib->vba.PercentOfIdealDRAMAndFabricBWReceivedAfterUrgLatency ++ / 100.0)) { ++ mode_lib->vba.BandwidthSupport[i] = true; ++ } else { ++ mode_lib->vba.BandwidthSupport[i] = false; ++ } ++ } ++ /*Writeback Latency support check*/ ++ ++ mode_lib->vba.WritebackLatencySupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true) { ++ if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { ++ if (mode_lib->vba.WriteBandwidth[k] ++ > (mode_lib->vba.WritebackInterfaceLumaBufferSize ++ + mode_lib->vba.WritebackInterfaceChromaBufferSize) ++ / mode_lib->vba.WritebackLatency) { ++ mode_lib->vba.WritebackLatencySupport = false; ++ } ++ } else { ++ if (mode_lib->vba.WriteBandwidth[k] ++ > 1.5 ++ * dml_min( ++ mode_lib->vba.WritebackInterfaceLumaBufferSize, ++ 2.0 ++ * mode_lib->vba.WritebackInterfaceChromaBufferSize) ++ / mode_lib->vba.WritebackLatency) { ++ mode_lib->vba.WritebackLatencySupport = false; ++ } ++ } ++ } ++ } ++ /*Re-ordering Buffer Support Check*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i] = ++ (mode_lib->vba.RoundTripPingLatencyCycles + 32.0) ++ / mode_lib->vba.DCFCLKPerState[i] ++ + mode_lib->vba.UrgentOutOfOrderReturnPerChannel ++ * mode_lib->vba.NumberOfChannels ++ / mode_lib->vba.ReturnBWPerState[i]; ++ if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) ++ * 1024.0 / mode_lib->vba.ReturnBWPerState[i] ++ > mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i]) { ++ mode_lib->vba.ROBSupport[i] = true; ++ } else { ++ mode_lib->vba.ROBSupport[i] = false; ++ } ++ } ++ /*Writeback Mode Support Check*/ ++ ++ mode_lib->vba.TotalNumberOfActiveWriteback = 0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true) { ++ mode_lib->vba.TotalNumberOfActiveWriteback = ++ mode_lib->vba.TotalNumberOfActiveWriteback + 1; ++ } ++ } ++ mode_lib->vba.WritebackModeSupport = true; ++ if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback) { ++ mode_lib->vba.WritebackModeSupport = false; ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true ++ && mode_lib->vba.Writeback10bpc420Supported != true ++ && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { ++ mode_lib->vba.WritebackModeSupport = false; ++ } ++ } ++ /*Writeback Scale Ratio and Taps Support Check*/ ++ ++ mode_lib->vba.WritebackScaleRatioAndTapsSupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true) { ++ if (mode_lib->vba.WritebackLumaAndChromaScalingSupported == false ++ && (mode_lib->vba.WritebackHRatio[k] != 1.0 ++ || mode_lib->vba.WritebackVRatio[k] != 1.0)) { ++ mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; ++ } ++ if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio ++ || mode_lib->vba.WritebackVRatio[k] ++ > mode_lib->vba.WritebackMaxVSCLRatio ++ || mode_lib->vba.WritebackHRatio[k] ++ < mode_lib->vba.WritebackMinHSCLRatio ++ || mode_lib->vba.WritebackVRatio[k] ++ < mode_lib->vba.WritebackMinVSCLRatio ++ || mode_lib->vba.WritebackLumaHTaps[k] ++ > mode_lib->vba.WritebackMaxHSCLTaps ++ || mode_lib->vba.WritebackLumaVTaps[k] ++ > mode_lib->vba.WritebackMaxVSCLTaps ++ || mode_lib->vba.WritebackHRatio[k] ++ > mode_lib->vba.WritebackLumaHTaps[k] ++ || mode_lib->vba.WritebackVRatio[k] ++ > mode_lib->vba.WritebackLumaVTaps[k] ++ || (mode_lib->vba.WritebackLumaHTaps[k] > 2.0 ++ && ((mode_lib->vba.WritebackLumaHTaps[k] % 2) ++ == 1)) ++ || (mode_lib->vba.WritebackPixelFormat[k] != dm_444_32 ++ && (mode_lib->vba.WritebackChromaHTaps[k] ++ > mode_lib->vba.WritebackMaxHSCLTaps ++ || mode_lib->vba.WritebackChromaVTaps[k] ++ > mode_lib->vba.WritebackMaxVSCLTaps ++ || 2.0 ++ * mode_lib->vba.WritebackHRatio[k] ++ > mode_lib->vba.WritebackChromaHTaps[k] ++ || 2.0 ++ * mode_lib->vba.WritebackVRatio[k] ++ > mode_lib->vba.WritebackChromaVTaps[k] ++ || (mode_lib->vba.WritebackChromaHTaps[k] > 2.0 ++ && ((mode_lib->vba.WritebackChromaHTaps[k] % 2) == 1))))) { ++ mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; ++ } ++ if (mode_lib->vba.WritebackVRatio[k] < 1.0) { ++ mode_lib->vba.WritebackLumaVExtra = ++ dml_max(1.0 - 2.0 / dml_ceil(1.0 / mode_lib->vba.WritebackVRatio[k], 1.0), 0.0); ++ } else { ++ mode_lib->vba.WritebackLumaVExtra = -1; ++ } ++ if ((mode_lib->vba.WritebackPixelFormat[k] == dm_444_32 ++ && mode_lib->vba.WritebackLumaVTaps[k] ++ > (mode_lib->vba.WritebackLineBufferLumaBufferSize ++ + mode_lib->vba.WritebackLineBufferChromaBufferSize) ++ / 3.0 ++ / mode_lib->vba.WritebackDestinationWidth[k] ++ - mode_lib->vba.WritebackLumaVExtra) ++ || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_8 ++ && mode_lib->vba.WritebackLumaVTaps[k] ++ > mode_lib->vba.WritebackLineBufferLumaBufferSize ++ / mode_lib->vba.WritebackDestinationWidth[k] ++ - mode_lib->vba.WritebackLumaVExtra) ++ || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10 ++ && mode_lib->vba.WritebackLumaVTaps[k] ++ > mode_lib->vba.WritebackLineBufferLumaBufferSize ++ * 8.0 / 10.0 ++ / mode_lib->vba.WritebackDestinationWidth[k] ++ - mode_lib->vba.WritebackLumaVExtra)) { ++ mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; ++ } ++ if (2.0 * mode_lib->vba.WritebackVRatio[k] < 1) { ++ mode_lib->vba.WritebackChromaVExtra = 0.0; ++ } else { ++ mode_lib->vba.WritebackChromaVExtra = -1; ++ } ++ if ((mode_lib->vba.WritebackPixelFormat[k] == dm_420_8 ++ && mode_lib->vba.WritebackChromaVTaps[k] ++ > mode_lib->vba.WritebackLineBufferChromaBufferSize ++ / mode_lib->vba.WritebackDestinationWidth[k] ++ - mode_lib->vba.WritebackChromaVExtra) ++ || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10 ++ && mode_lib->vba.WritebackChromaVTaps[k] ++ > mode_lib->vba.WritebackLineBufferChromaBufferSize ++ * 8.0 / 10.0 ++ / mode_lib->vba.WritebackDestinationWidth[k] ++ - mode_lib->vba.WritebackChromaVExtra)) { ++ mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; ++ } ++ } ++ } ++ /*Maximum DISPCLK/DPPCLK Support check*/ ++ ++ mode_lib->vba.WritebackRequiredDISPCLK = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.WritebackEnable[k] == true) { ++ mode_lib->vba.WritebackRequiredDISPCLK = ++ dml_max( ++ mode_lib->vba.WritebackRequiredDISPCLK, ++ CalculateWriteBackDISPCLK( ++ mode_lib->vba.WritebackPixelFormat[k], ++ mode_lib->vba.PixelClock[k], ++ mode_lib->vba.WritebackHRatio[k], ++ mode_lib->vba.WritebackVRatio[k], ++ mode_lib->vba.WritebackLumaHTaps[k], ++ mode_lib->vba.WritebackLumaVTaps[k], ++ mode_lib->vba.WritebackChromaHTaps[k], ++ mode_lib->vba.WritebackChromaVTaps[k], ++ mode_lib->vba.WritebackDestinationWidth[k], ++ mode_lib->vba.HTotal[k], ++ mode_lib->vba.WritebackChromaLineBufferWidth)); ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.HRatio[k] > 1.0) { ++ mode_lib->vba.PSCL_FACTOR[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput ++ * mode_lib->vba.HRatio[k] ++ / dml_ceil( ++ mode_lib->vba.htaps[k] ++ / 6.0, ++ 1.0)); ++ } else { ++ mode_lib->vba.PSCL_FACTOR[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput); ++ } ++ if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { ++ mode_lib->vba.PSCL_FACTOR_CHROMA[k] = 0.0; ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] = ++ mode_lib->vba.PixelClock[k] ++ * dml_max3( ++ mode_lib->vba.vtaps[k] / 6.0 ++ * dml_min( ++ 1.0, ++ mode_lib->vba.HRatio[k]), ++ mode_lib->vba.HRatio[k] ++ * mode_lib->vba.VRatio[k] ++ / mode_lib->vba.PSCL_FACTOR[k], ++ 1.0); ++ if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0) ++ && mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ < 2.0 * mode_lib->vba.PixelClock[k]) { ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] = 2.0 ++ * mode_lib->vba.PixelClock[k]; ++ } ++ } else { ++ if (mode_lib->vba.HRatio[k] / 2.0 > 1.0) { ++ mode_lib->vba.PSCL_FACTOR_CHROMA[k] = ++ dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput ++ * mode_lib->vba.HRatio[k] ++ / 2.0 ++ / dml_ceil( ++ mode_lib->vba.HTAPsChroma[k] ++ / 6.0, ++ 1.0)); ++ } else { ++ mode_lib->vba.PSCL_FACTOR_CHROMA[k] = dml_min( ++ mode_lib->vba.MaxDCHUBToPSCLThroughput, ++ mode_lib->vba.MaxPSCLToLBThroughput); ++ } ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] = ++ mode_lib->vba.PixelClock[k] ++ * dml_max5( ++ mode_lib->vba.vtaps[k] / 6.0 ++ * dml_min( ++ 1.0, ++ mode_lib->vba.HRatio[k]), ++ mode_lib->vba.HRatio[k] ++ * mode_lib->vba.VRatio[k] ++ / mode_lib->vba.PSCL_FACTOR[k], ++ mode_lib->vba.VTAPsChroma[k] ++ / 6.0 ++ * dml_min( ++ 1.0, ++ mode_lib->vba.HRatio[k] ++ / 2.0), ++ mode_lib->vba.HRatio[k] ++ * mode_lib->vba.VRatio[k] ++ / 4.0 ++ / mode_lib->vba.PSCL_FACTOR_CHROMA[k], ++ 1.0); ++ if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0 ++ || mode_lib->vba.HTAPsChroma[k] > 6.0 ++ || mode_lib->vba.VTAPsChroma[k] > 6.0) ++ && mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ < 2.0 * mode_lib->vba.PixelClock[k]) { ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] = 2.0 ++ * mode_lib->vba.PixelClock[k]; ++ } ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ Calculate256BBlockSizes( ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.SurfaceTiling[k], ++ dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0), ++ dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0), ++ &mode_lib->vba.Read256BlockHeightY[k], ++ &mode_lib->vba.Read256BlockHeightC[k], ++ &mode_lib->vba.Read256BlockWidthY[k], ++ &mode_lib->vba.Read256BlockWidthC[k]); ++ if (mode_lib->vba.SourceScan[k] == dm_horz) { ++ mode_lib->vba.MaxSwathHeightY[k] = mode_lib->vba.Read256BlockHeightY[k]; ++ mode_lib->vba.MaxSwathHeightC[k] = mode_lib->vba.Read256BlockHeightC[k]; ++ } else { ++ mode_lib->vba.MaxSwathHeightY[k] = mode_lib->vba.Read256BlockWidthY[k]; ++ mode_lib->vba.MaxSwathHeightC[k] = mode_lib->vba.Read256BlockWidthC[k]; ++ } ++ if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16 ++ || mode_lib->vba.SourcePixelFormat[k] == dm_mono_8)) { ++ if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear ++ || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 ++ && (mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_4kb_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_4kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s_t ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_64kb_s_x ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_var_s ++ || mode_lib->vba.SurfaceTiling[k] ++ == dm_sw_var_s_x) ++ && mode_lib->vba.SourceScan[k] == dm_horz)) { ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k]; ++ } else { ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k] ++ / 2.0; ++ } ++ mode_lib->vba.MinSwathHeightC[k] = mode_lib->vba.MaxSwathHeightC[k]; ++ } else { ++ if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k]; ++ mode_lib->vba.MinSwathHeightC[k] = mode_lib->vba.MaxSwathHeightC[k]; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 ++ && mode_lib->vba.SourceScan[k] == dm_horz) { ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k] ++ / 2.0; ++ mode_lib->vba.MinSwathHeightC[k] = mode_lib->vba.MaxSwathHeightC[k]; ++ } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10 ++ && mode_lib->vba.SourceScan[k] == dm_horz) { ++ mode_lib->vba.MinSwathHeightC[k] = mode_lib->vba.MaxSwathHeightC[k] ++ / 2.0; ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k]; ++ } else { ++ mode_lib->vba.MinSwathHeightY[k] = mode_lib->vba.MaxSwathHeightY[k]; ++ mode_lib->vba.MinSwathHeightC[k] = mode_lib->vba.MaxSwathHeightC[k]; ++ } ++ } ++ if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { ++ mode_lib->vba.MaximumSwathWidthSupport = 8192.0; ++ } else { ++ mode_lib->vba.MaximumSwathWidthSupport = 5120.0; ++ } ++ mode_lib->vba.MaximumSwathWidthInDETBuffer = ++ dml_min( ++ mode_lib->vba.MaximumSwathWidthSupport, ++ mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0 ++ / (mode_lib->vba.BytePerPixelInDETY[k] ++ * mode_lib->vba.MinSwathHeightY[k] ++ + mode_lib->vba.BytePerPixelInDETC[k] ++ / 2.0 ++ * mode_lib->vba.MinSwathHeightC[k])); ++ if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { ++ mode_lib->vba.MaximumSwathWidthInLineBuffer = ++ mode_lib->vba.LineBufferSize ++ * dml_max(mode_lib->vba.HRatio[k], 1.0) ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.vtaps[k] ++ + dml_max( ++ dml_ceil( ++ mode_lib->vba.VRatio[k], ++ 1.0) ++ - 2, ++ 0.0)); ++ } else { ++ mode_lib->vba.MaximumSwathWidthInLineBuffer = ++ dml_min( ++ mode_lib->vba.LineBufferSize ++ * dml_max( ++ mode_lib->vba.HRatio[k], ++ 1.0) ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.vtaps[k] ++ + dml_max( ++ dml_ceil( ++ mode_lib->vba.VRatio[k], ++ 1.0) ++ - 2, ++ 0.0)), ++ 2.0 * mode_lib->vba.LineBufferSize ++ * dml_max( ++ mode_lib->vba.HRatio[k] ++ / 2.0, ++ 1.0) ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.VTAPsChroma[k] ++ + dml_max( ++ dml_ceil( ++ mode_lib->vba.VRatio[k] ++ / 2.0, ++ 1.0) ++ - 2, ++ 0.0))); ++ } ++ mode_lib->vba.MaximumSwathWidth[k] = dml_min( ++ mode_lib->vba.MaximumSwathWidthInDETBuffer, ++ mode_lib->vba.MaximumSwathWidthInLineBuffer); ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown( ++ mode_lib->vba.MaxDispclk[i], ++ mode_lib->vba.DISPCLKDPPCLKVCOSpeed); ++ mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown( ++ mode_lib->vba.MaxDppclk[i], ++ mode_lib->vba.DISPCLKDPPCLKVCOSpeed); ++ mode_lib->vba.RequiredDISPCLK[i] = 0.0; ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = ++ mode_lib->vba.PixelClock[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ * (1.0 ++ + mode_lib->vba.DISPCLKRampingMargin ++ / 100.0); ++ if (mode_lib->vba.ODMCapability == true ++ && mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine ++ > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) { ++ mode_lib->vba.ODMCombineEnablePerState[i][k] = true; ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine ++ / 2.0; ++ } else { ++ mode_lib->vba.ODMCombineEnablePerState[i][k] = false; ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine; ++ } ++ if (mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity ++ && mode_lib->vba.SwathWidthYSingleDPP[k] ++ <= mode_lib->vba.MaximumSwathWidth[k] ++ && mode_lib->vba.ODMCombineEnablePerState[i][k] == false) { ++ mode_lib->vba.NoOfDPP[i][k] = 1.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0); ++ } else { ++ mode_lib->vba.NoOfDPP[i][k] = 2.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ / 2.0; ++ } ++ mode_lib->vba.RequiredDISPCLK[i] = dml_max( ++ mode_lib->vba.RequiredDISPCLK[i], ++ mode_lib->vba.PlaneRequiredDISPCLK); ++ if ((mode_lib->vba.MinDPPCLKUsingSingleDPP[k] / mode_lib->vba.NoOfDPP[i][k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity) ++ || (mode_lib->vba.PlaneRequiredDISPCLK ++ > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) { ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = false; ++ } ++ } ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = ++ mode_lib->vba.TotalNumberOfActiveDPP[i] ++ + mode_lib->vba.NoOfDPP[i][k]; ++ } ++ if ((mode_lib->vba.MaxDispclk[i] == mode_lib->vba.MaxDispclk[DC__VOLTAGE_STATES] ++ && mode_lib->vba.MaxDppclk[i] ++ == mode_lib->vba.MaxDppclk[DC__VOLTAGE_STATES]) ++ && (mode_lib->vba.TotalNumberOfActiveDPP[i] ++ > mode_lib->vba.MaxNumDPP ++ || mode_lib->vba.DISPCLK_DPPCLK_Support[i] == false)) { ++ mode_lib->vba.RequiredDISPCLK[i] = 0.0; ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = ++ mode_lib->vba.PixelClock[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0); ++ if (mode_lib->vba.ODMCapability == true ++ && mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine ++ > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) { ++ mode_lib->vba.ODMCombineEnablePerState[i][k] = true; ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine ++ / 2.0; ++ } else { ++ mode_lib->vba.ODMCombineEnablePerState[i][k] = false; ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine; ++ } ++ if (mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity ++ && mode_lib->vba.SwathWidthYSingleDPP[k] ++ <= mode_lib->vba.MaximumSwathWidth[k] ++ && mode_lib->vba.ODMCombineEnablePerState[i][k] ++ == false) { ++ mode_lib->vba.NoOfDPP[i][k] = 1.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0); ++ } else { ++ mode_lib->vba.NoOfDPP[i][k] = 2.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ / 2.0; ++ } ++ mode_lib->vba.RequiredDISPCLK[i] = dml_max( ++ mode_lib->vba.RequiredDISPCLK[i], ++ mode_lib->vba.PlaneRequiredDISPCLK); ++ if ((mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ / mode_lib->vba.NoOfDPP[i][k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity) ++ || (mode_lib->vba.PlaneRequiredDISPCLK ++ > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) { ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = false; ++ } ++ } ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = ++ mode_lib->vba.TotalNumberOfActiveDPP[i] ++ + mode_lib->vba.NoOfDPP[i][k]; ++ } ++ } ++ if (mode_lib->vba.TotalNumberOfActiveDPP[i] > mode_lib->vba.MaxNumDPP) { ++ mode_lib->vba.RequiredDISPCLK[i] = 0.0; ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.ODMCombineEnablePerState[i][k] = false; ++ if (mode_lib->vba.SwathWidthYSingleDPP[k] ++ <= mode_lib->vba.MaximumSwathWidth[k]) { ++ mode_lib->vba.NoOfDPP[i][k] = 1.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0); ++ } else { ++ mode_lib->vba.NoOfDPP[i][k] = 2.0; ++ mode_lib->vba.RequiredDPPCLK[i][k] = ++ mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ / 2.0; ++ } ++ if (!(mode_lib->vba.MaxDispclk[i] ++ == mode_lib->vba.MaxDispclk[DC__VOLTAGE_STATES] ++ && mode_lib->vba.MaxDppclk[i] ++ == mode_lib->vba.MaxDppclk[DC__VOLTAGE_STATES])) { ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PixelClock[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ * (1.0 ++ + mode_lib->vba.DISPCLKRampingMargin ++ / 100.0); ++ } else { ++ mode_lib->vba.PlaneRequiredDISPCLK = ++ mode_lib->vba.PixelClock[k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0); ++ } ++ mode_lib->vba.RequiredDISPCLK[i] = dml_max( ++ mode_lib->vba.RequiredDISPCLK[i], ++ mode_lib->vba.PlaneRequiredDISPCLK); ++ if ((mode_lib->vba.MinDPPCLKUsingSingleDPP[k] ++ / mode_lib->vba.NoOfDPP[i][k] ++ * (1.0 ++ + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity) ++ || (mode_lib->vba.PlaneRequiredDISPCLK ++ > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) { ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = false; ++ } ++ } ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.TotalNumberOfActiveDPP[i] = ++ mode_lib->vba.TotalNumberOfActiveDPP[i] ++ + mode_lib->vba.NoOfDPP[i][k]; ++ } ++ } ++ mode_lib->vba.RequiredDISPCLK[i] = dml_max( ++ mode_lib->vba.RequiredDISPCLK[i], ++ mode_lib->vba.WritebackRequiredDISPCLK); ++ if (mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity ++ < mode_lib->vba.WritebackRequiredDISPCLK) { ++ mode_lib->vba.DISPCLK_DPPCLK_Support[i] = false; ++ } ++ } ++ /*Viewport Size Check*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.ViewportSizeSupport[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.ODMCombineEnablePerState[i][k] == true) { ++ if (dml_min( ++ mode_lib->vba.SwathWidthYSingleDPP[k], ++ dml_round( ++ mode_lib->vba.HActive[k] / 2.0 ++ * mode_lib->vba.HRatio[k])) ++ > mode_lib->vba.MaximumSwathWidth[k]) { ++ mode_lib->vba.ViewportSizeSupport[i] = false; ++ } ++ } else { ++ if (mode_lib->vba.SwathWidthYSingleDPP[k] / 2.0 ++ > mode_lib->vba.MaximumSwathWidth[k]) { ++ mode_lib->vba.ViewportSizeSupport[i] = false; ++ } ++ } ++ } ++ } ++ /*Total Available Pipes Support Check*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ if (mode_lib->vba.TotalNumberOfActiveDPP[i] <= mode_lib->vba.MaxNumDPP) { ++ mode_lib->vba.TotalAvailablePipesSupport[i] = true; ++ } else { ++ mode_lib->vba.TotalAvailablePipesSupport[i] = false; ++ } ++ } ++ /*Total Available OTG Support Check*/ ++ ++ mode_lib->vba.TotalNumberOfActiveOTG = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.BlendingAndTiming[k] == k) { ++ mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG ++ + 1.0; ++ } ++ } ++ if (mode_lib->vba.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG) { ++ mode_lib->vba.NumberOfOTGSupport = true; ++ } else { ++ mode_lib->vba.NumberOfOTGSupport = false; ++ } ++ /*Display IO and DSC Support Check*/ ++ ++ mode_lib->vba.NonsupportedDSCInputBPC = false; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0 ++ || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0 ++ || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)) { ++ mode_lib->vba.NonsupportedDSCInputBPC = true; ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.RequiresDSC[i][k] = 0; ++ mode_lib->vba.RequiresFEC[i][k] = 0; ++ if (mode_lib->vba.BlendingAndTiming[k] == k) { ++ if (mode_lib->vba.Output[k] == dm_hdmi) { ++ mode_lib->vba.RequiresDSC[i][k] = 0; ++ mode_lib->vba.RequiresFEC[i][k] = 0; ++ mode_lib->vba.OutputBppPerState[i][k] = ++ TruncToValidBPP( ++ dml_min( ++ 600.0, ++ mode_lib->vba.PHYCLKPerState[i]) ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 24, ++ false, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ } else if (mode_lib->vba.Output[k] == dm_dp ++ || mode_lib->vba.Output[k] == dm_edp) { ++ if (mode_lib->vba.Output[k] == dm_edp) { ++ mode_lib->vba.EffectiveFECOverhead = 0.0; ++ } else { ++ mode_lib->vba.EffectiveFECOverhead = ++ mode_lib->vba.FECOverhead; ++ } ++ if (mode_lib->vba.PHYCLKPerState[i] >= 270.0) { ++ mode_lib->vba.Outbpp = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * 270.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ false, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ mode_lib->vba.OutbppDSC = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * (1.0 ++ - mode_lib->vba.EffectiveFECOverhead ++ / 100.0) ++ * 270.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ true, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ if (mode_lib->vba.DSCEnabled[k] == true) { ++ mode_lib->vba.RequiresDSC[i][k] = true; ++ if (mode_lib->vba.Output[k] == dm_dp) { ++ mode_lib->vba.RequiresFEC[i][k] = ++ true; ++ } else { ++ mode_lib->vba.RequiresFEC[i][k] = ++ false; ++ } ++ mode_lib->vba.Outbpp = ++ mode_lib->vba.OutbppDSC; ++ } else { ++ mode_lib->vba.RequiresDSC[i][k] = false; ++ mode_lib->vba.RequiresFEC[i][k] = false; ++ } ++ mode_lib->vba.OutputBppPerState[i][k] = ++ mode_lib->vba.Outbpp; ++ } ++ if (mode_lib->vba.Outbpp == 0) { ++ mode_lib->vba.Outbpp = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * 540.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ false, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ mode_lib->vba.OutbppDSC = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * (1.0 ++ - mode_lib->vba.EffectiveFECOverhead ++ / 100.0) ++ * 540.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ true, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ if (mode_lib->vba.DSCEnabled[k] == true) { ++ mode_lib->vba.RequiresDSC[i][k] = true; ++ if (mode_lib->vba.Output[k] == dm_dp) { ++ mode_lib->vba.RequiresFEC[i][k] = ++ true; ++ } else { ++ mode_lib->vba.RequiresFEC[i][k] = ++ false; ++ } ++ mode_lib->vba.Outbpp = ++ mode_lib->vba.OutbppDSC; ++ } else { ++ mode_lib->vba.RequiresDSC[i][k] = false; ++ mode_lib->vba.RequiresFEC[i][k] = false; ++ } ++ mode_lib->vba.OutputBppPerState[i][k] = ++ mode_lib->vba.Outbpp; ++ } ++ if (mode_lib->vba.Outbpp == 0 ++ && mode_lib->vba.PHYCLKPerState[i] ++ >= 810.0) { ++ mode_lib->vba.Outbpp = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * 810.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ false, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ mode_lib->vba.OutbppDSC = ++ TruncToValidBPP( ++ (1.0 ++ - mode_lib->vba.Downspreading ++ / 100.0) ++ * (1.0 ++ - mode_lib->vba.EffectiveFECOverhead ++ / 100.0) ++ * 810.0 ++ * mode_lib->vba.OutputLinkDPLanes[k] ++ / mode_lib->vba.PixelClockBackEnd[k] ++ * 8.0, ++ true, ++ mode_lib->vba.Output[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.DSCInputBitPerComponent[k]); ++ if (mode_lib->vba.DSCEnabled[k] == true ++ || mode_lib->vba.Outbpp == 0) { ++ mode_lib->vba.RequiresDSC[i][k] = true; ++ if (mode_lib->vba.Output[k] == dm_dp) { ++ mode_lib->vba.RequiresFEC[i][k] = ++ true; ++ } else { ++ mode_lib->vba.RequiresFEC[i][k] = ++ false; ++ } ++ mode_lib->vba.Outbpp = ++ mode_lib->vba.OutbppDSC; ++ } else { ++ mode_lib->vba.RequiresDSC[i][k] = false; ++ mode_lib->vba.RequiresFEC[i][k] = false; ++ } ++ mode_lib->vba.OutputBppPerState[i][k] = ++ mode_lib->vba.Outbpp; ++ } ++ } ++ } else { ++ mode_lib->vba.OutputBppPerState[i][k] = 0; ++ } ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.DIOSupport[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.OutputBppPerState[i][k] == 0 ++ || (mode_lib->vba.OutputFormat[k] == dm_420 ++ && mode_lib->vba.ProgressiveToInterlaceUnitInOPP ++ == true)) { ++ mode_lib->vba.DIOSupport[i] = false; ++ } ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = false; ++ if (mode_lib->vba.BlendingAndTiming[k] == k) { ++ if ((mode_lib->vba.Output[k] == dm_dp ++ || mode_lib->vba.Output[k] == dm_edp)) { ++ if (mode_lib->vba.OutputFormat[k] == dm_420 ++ || mode_lib->vba.OutputFormat[k] ++ == dm_n422) { ++ mode_lib->vba.DSCFormatFactor = 2; ++ } else { ++ mode_lib->vba.DSCFormatFactor = 1; ++ } ++ if (mode_lib->vba.RequiresDSC[i][k] == true) { ++ if (mode_lib->vba.ODMCombineEnablePerState[i][k] ++ == true) { ++ if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 ++ / mode_lib->vba.DSCFormatFactor ++ > (1.0 ++ - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ * mode_lib->vba.MaxDSCCLK[i]) { ++ mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = ++ true; ++ } ++ } else { ++ if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 ++ / mode_lib->vba.DSCFormatFactor ++ > (1.0 ++ - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading ++ / 100.0) ++ * mode_lib->vba.MaxDSCCLK[i]) { ++ mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = ++ true; ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.NotEnoughDSCUnits[i] = false; ++ mode_lib->vba.TotalDSCUnitsRequired = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.RequiresDSC[i][k] == true) { ++ if (mode_lib->vba.ODMCombineEnablePerState[i][k] == true) { ++ mode_lib->vba.TotalDSCUnitsRequired = ++ mode_lib->vba.TotalDSCUnitsRequired + 2.0; ++ } else { ++ mode_lib->vba.TotalDSCUnitsRequired = ++ mode_lib->vba.TotalDSCUnitsRequired + 1.0; ++ } ++ } ++ } ++ if (mode_lib->vba.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC) { ++ mode_lib->vba.NotEnoughDSCUnits[i] = true; ++ } ++ } ++ /*DSC Delay per state*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.BlendingAndTiming[k] != k) { ++ mode_lib->vba.slices = 0; ++ } else if (mode_lib->vba.RequiresDSC[i][k] == 0 ++ || mode_lib->vba.RequiresDSC[i][k] == false) { ++ mode_lib->vba.slices = 0; ++ } else if (mode_lib->vba.PixelClockBackEnd[k] > 3200.0) { ++ mode_lib->vba.slices = dml_ceil( ++ mode_lib->vba.PixelClockBackEnd[k] / 400.0, ++ 4.0); ++ } else if (mode_lib->vba.PixelClockBackEnd[k] > 1360.0) { ++ mode_lib->vba.slices = 8.0; ++ } else if (mode_lib->vba.PixelClockBackEnd[k] > 680.0) { ++ mode_lib->vba.slices = 4.0; ++ } else if (mode_lib->vba.PixelClockBackEnd[k] > 340.0) { ++ mode_lib->vba.slices = 2.0; ++ } else { ++ mode_lib->vba.slices = 1.0; ++ } ++ if (mode_lib->vba.OutputBppPerState[i][k] == 0 ++ || mode_lib->vba.OutputBppPerState[i][k] == 0) { ++ mode_lib->vba.bpp = 0.0; ++ } else { ++ mode_lib->vba.bpp = mode_lib->vba.OutputBppPerState[i][k]; ++ } ++ if (mode_lib->vba.RequiresDSC[i][k] == true && mode_lib->vba.bpp != 0.0) { ++ if (mode_lib->vba.ODMCombineEnablePerState[i][k] == false) { ++ mode_lib->vba.DSCDelayPerState[i][k] = ++ dscceComputeDelay( ++ mode_lib->vba.DSCInputBitPerComponent[k], ++ mode_lib->vba.bpp, ++ dml_ceil( ++ mode_lib->vba.HActive[k] ++ / mode_lib->vba.slices, ++ 1.0), ++ mode_lib->vba.slices, ++ mode_lib->vba.OutputFormat[k]) ++ + dscComputeDelay( ++ mode_lib->vba.OutputFormat[k]); ++ } else { ++ mode_lib->vba.DSCDelayPerState[i][k] = ++ 2.0 ++ * (dscceComputeDelay( ++ mode_lib->vba.DSCInputBitPerComponent[k], ++ mode_lib->vba.bpp, ++ dml_ceil( ++ mode_lib->vba.HActive[k] ++ / mode_lib->vba.slices, ++ 1.0), ++ mode_lib->vba.slices ++ / 2, ++ mode_lib->vba.OutputFormat[k]) ++ + dscComputeDelay( ++ mode_lib->vba.OutputFormat[k])); ++ } ++ mode_lib->vba.DSCDelayPerState[i][k] = ++ mode_lib->vba.DSCDelayPerState[i][k] ++ * mode_lib->vba.PixelClock[k] ++ / mode_lib->vba.PixelClockBackEnd[k]; ++ } else { ++ mode_lib->vba.DSCDelayPerState[i][k] = 0.0; ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) { ++ if (mode_lib->vba.BlendingAndTiming[k] == j ++ && mode_lib->vba.RequiresDSC[i][j] == true) { ++ mode_lib->vba.DSCDelayPerState[i][k] = ++ mode_lib->vba.DSCDelayPerState[i][j]; ++ } ++ } ++ } ++ } ++ /*Urgent Latency Support Check*/ ++ ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ if (mode_lib->vba.ODMCombineEnablePerState[i][k] == true) { ++ mode_lib->vba.SwathWidthYPerState[i][k] = ++ dml_min( ++ mode_lib->vba.SwathWidthYSingleDPP[k], ++ dml_round( ++ mode_lib->vba.HActive[k] ++ / 2.0 ++ * mode_lib->vba.HRatio[k])); ++ } else { ++ mode_lib->vba.SwathWidthYPerState[i][k] = ++ mode_lib->vba.SwathWidthYSingleDPP[k] ++ / mode_lib->vba.NoOfDPP[i][k]; ++ } ++ mode_lib->vba.SwathWidthGranularityY = 256.0 ++ / dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0) ++ / mode_lib->vba.MaxSwathHeightY[k]; ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesY = (dml_ceil( ++ mode_lib->vba.SwathWidthYPerState[i][k] - 1.0, ++ mode_lib->vba.SwathWidthGranularityY) ++ + mode_lib->vba.SwathWidthGranularityY) ++ * mode_lib->vba.BytePerPixelInDETY[k] ++ * mode_lib->vba.MaxSwathHeightY[k]; ++ if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesY = dml_ceil( ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesY, ++ 256.0) + 256; ++ } ++ if (mode_lib->vba.MaxSwathHeightC[k] > 0.0) { ++ mode_lib->vba.SwathWidthGranularityC = 256.0 ++ / dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0) ++ / mode_lib->vba.MaxSwathHeightC[k]; ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesC = (dml_ceil( ++ mode_lib->vba.SwathWidthYPerState[i][k] / 2.0 - 1.0, ++ mode_lib->vba.SwathWidthGranularityC) ++ + mode_lib->vba.SwathWidthGranularityC) ++ * mode_lib->vba.BytePerPixelInDETC[k] ++ * mode_lib->vba.MaxSwathHeightC[k]; ++ if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesC = dml_ceil( ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesC, ++ 256.0) + 256; ++ } ++ } else { ++ mode_lib->vba.RoundedUpMaxSwathSizeBytesC = 0.0; ++ } ++ if (mode_lib->vba.RoundedUpMaxSwathSizeBytesY ++ + mode_lib->vba.RoundedUpMaxSwathSizeBytesC ++ <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) { ++ mode_lib->vba.SwathHeightYPerState[i][k] = ++ mode_lib->vba.MaxSwathHeightY[k]; ++ mode_lib->vba.SwathHeightCPerState[i][k] = ++ mode_lib->vba.MaxSwathHeightC[k]; ++ } else { ++ mode_lib->vba.SwathHeightYPerState[i][k] = ++ mode_lib->vba.MinSwathHeightY[k]; ++ mode_lib->vba.SwathHeightCPerState[i][k] = ++ mode_lib->vba.MinSwathHeightC[k]; ++ } ++ if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { ++ mode_lib->vba.LinesInDETLuma = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / mode_lib->vba.BytePerPixelInDETY[k] ++ / mode_lib->vba.SwathWidthYPerState[i][k]; ++ mode_lib->vba.LinesInDETChroma = 0.0; ++ } else if (mode_lib->vba.SwathHeightYPerState[i][k] ++ <= mode_lib->vba.SwathHeightCPerState[i][k]) { ++ mode_lib->vba.LinesInDETLuma = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 2.0 / mode_lib->vba.BytePerPixelInDETY[k] ++ / mode_lib->vba.SwathWidthYPerState[i][k]; ++ mode_lib->vba.LinesInDETChroma = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 2.0 / mode_lib->vba.BytePerPixelInDETC[k] ++ / (mode_lib->vba.SwathWidthYPerState[i][k] / 2.0); ++ } else { ++ mode_lib->vba.LinesInDETLuma = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 * 2.0 / 3.0 ++ / mode_lib->vba.BytePerPixelInDETY[k] ++ / mode_lib->vba.SwathWidthYPerState[i][k]; ++ mode_lib->vba.LinesInDETChroma = mode_lib->vba.DETBufferSizeInKByte ++ * 1024.0 / 3.0 / mode_lib->vba.BytePerPixelInDETY[k] ++ / (mode_lib->vba.SwathWidthYPerState[i][k] / 2.0); ++ } ++ mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma = ++ dml_min( ++ mode_lib->vba.MaxLineBufferLines, ++ dml_floor( ++ mode_lib->vba.LineBufferSize ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.SwathWidthYPerState[i][k] ++ / dml_max( ++ mode_lib->vba.HRatio[k], ++ 1.0)), ++ 1.0)) ++ - (mode_lib->vba.vtaps[k] - 1.0); ++ mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma = ++ dml_min( ++ mode_lib->vba.MaxLineBufferLines, ++ dml_floor( ++ mode_lib->vba.LineBufferSize ++ / mode_lib->vba.LBBitPerPixel[k] ++ / (mode_lib->vba.SwathWidthYPerState[i][k] ++ / 2.0 ++ / dml_max( ++ mode_lib->vba.HRatio[k] ++ / 2.0, ++ 1.0)), ++ 1.0)) ++ - (mode_lib->vba.VTAPsChroma[k] - 1.0); ++ mode_lib->vba.EffectiveDETLBLinesLuma = ++ dml_floor( ++ mode_lib->vba.LinesInDETLuma ++ + dml_min( ++ mode_lib->vba.LinesInDETLuma ++ * mode_lib->vba.RequiredDISPCLK[i] ++ * mode_lib->vba.BytePerPixelInDETY[k] ++ * mode_lib->vba.PSCL_FACTOR[k] ++ / mode_lib->vba.ReturnBWPerState[i], ++ mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma), ++ mode_lib->vba.SwathHeightYPerState[i][k]); ++ mode_lib->vba.EffectiveDETLBLinesChroma = ++ dml_floor( ++ mode_lib->vba.LinesInDETChroma ++ + dml_min( ++ mode_lib->vba.LinesInDETChroma ++ * mode_lib->vba.RequiredDISPCLK[i] ++ * mode_lib->vba.BytePerPixelInDETC[k] ++ * mode_lib->vba.PSCL_FACTOR_CHROMA[k] ++ / mode_lib->vba.ReturnBWPerState[i], ++ mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma), ++ mode_lib->vba.SwathHeightCPerState[i][k]); ++ if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { ++ mode_lib->vba.UrgentLatencySupportUsPerState[i][k] = ++ mode_lib->vba.EffectiveDETLBLinesLuma ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / mode_lib->vba.VRatio[k] ++ - mode_lib->vba.EffectiveDETLBLinesLuma ++ * mode_lib->vba.SwathWidthYPerState[i][k] ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / (mode_lib->vba.ReturnBWPerState[i] ++ / mode_lib->vba.NoOfDPP[i][k]); ++ } else { ++ mode_lib->vba.UrgentLatencySupportUsPerState[i][k] = ++ dml_min( ++ mode_lib->vba.EffectiveDETLBLinesLuma ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / mode_lib->vba.VRatio[k] ++ - mode_lib->vba.EffectiveDETLBLinesLuma ++ * mode_lib->vba.SwathWidthYPerState[i][k] ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / (mode_lib->vba.ReturnBWPerState[i] ++ / mode_lib->vba.NoOfDPP[i][k]), ++ mode_lib->vba.EffectiveDETLBLinesChroma ++ * (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]) ++ / (mode_lib->vba.VRatio[k] ++ / 2.0) ++ - mode_lib->vba.EffectiveDETLBLinesChroma ++ * mode_lib->vba.SwathWidthYPerState[i][k] ++ / 2.0 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETC[k], ++ 2.0) ++ / (mode_lib->vba.ReturnBWPerState[i] ++ / mode_lib->vba.NoOfDPP[i][k])); ++ } ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.UrgentLatencySupport[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.UrgentLatencySupportUsPerState[i][k] ++ < mode_lib->vba.UrgentLatency / 1.0) { ++ mode_lib->vba.UrgentLatencySupport[i] = false; ++ } ++ } ++ } ++ /*Prefetch Check*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.TotalNumberOfDCCActiveDPP[i] = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.DCCEnable[k] == true) { ++ mode_lib->vba.TotalNumberOfDCCActiveDPP[i] = ++ mode_lib->vba.TotalNumberOfDCCActiveDPP[i] ++ + mode_lib->vba.NoOfDPP[i][k]; ++ } ++ } ++ } ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = 8.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ mode_lib->vba.PixelClock[k] / 16.0); ++ if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { ++ if (mode_lib->vba.VRatio[k] <= 1.0) { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / 64.0 ++ * mode_lib->vba.HRatio[k] ++ * mode_lib->vba.PixelClock[k] ++ / mode_lib->vba.NoOfDPP[i][k]); ++ } else { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / 64.0 ++ * mode_lib->vba.PSCL_FACTOR[k] ++ * mode_lib->vba.RequiredDPPCLK[i][k]); ++ } ++ } else { ++ if (mode_lib->vba.VRatio[k] <= 1.0) { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / 32.0 ++ * mode_lib->vba.HRatio[k] ++ * mode_lib->vba.PixelClock[k] ++ / mode_lib->vba.NoOfDPP[i][k]); ++ } else { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0) ++ / 32.0 ++ * mode_lib->vba.PSCL_FACTOR[k] ++ * mode_lib->vba.RequiredDPPCLK[i][k]); ++ } ++ if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETC[k], ++ 2.0) ++ / 32.0 ++ * mode_lib->vba.HRatio[k] ++ / 2.0 ++ * mode_lib->vba.PixelClock[k] ++ / mode_lib->vba.NoOfDPP[i][k]); ++ } else { ++ mode_lib->vba.ProjectedDCFCLKDeepSleep = ++ dml_max( ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ 1.1 ++ * dml_ceil( ++ mode_lib->vba.BytePerPixelInDETC[k], ++ 2.0) ++ / 32.0 ++ * mode_lib->vba.PSCL_FACTOR_CHROMA[k] ++ * mode_lib->vba.RequiredDPPCLK[i][k]); ++ } ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes( ++ mode_lib, ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.Read256BlockHeightY[k], ++ mode_lib->vba.Read256BlockWidthY[k], ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.SurfaceTiling[k], ++ dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0), ++ mode_lib->vba.SourceScan[k], ++ mode_lib->vba.ViewportWidth[k], ++ mode_lib->vba.ViewportHeight[k], ++ mode_lib->vba.SwathWidthYPerState[i][k], ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.VMMPageSize, ++ mode_lib->vba.PTEBufferSizeInRequests, ++ mode_lib->vba.PDEProcessingBufIn64KBReqs, ++ mode_lib->vba.PitchY[k], ++ mode_lib->vba.DCCMetaPitchY[k], ++ &mode_lib->vba.MacroTileWidthY[k], ++ &mode_lib->vba.MetaRowBytesY, ++ &mode_lib->vba.DPTEBytesPerRowY, ++ &mode_lib->vba.PTEBufferSizeNotExceededY[i][k], ++ &mode_lib->vba.dpte_row_height[k], ++ &mode_lib->vba.meta_row_height[k]); ++ mode_lib->vba.PrefetchLinesY[k] = CalculatePrefetchSourceLines( ++ mode_lib, ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.vtaps[k], ++ mode_lib->vba.Interlace[k], ++ mode_lib->vba.ProgressiveToInterlaceUnitInOPP, ++ mode_lib->vba.SwathHeightYPerState[i][k], ++ mode_lib->vba.ViewportYStartY[k], ++ &mode_lib->vba.PrefillY[k], ++ &mode_lib->vba.MaxNumSwY[k]); ++ if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)) { ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes( ++ mode_lib, ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.Read256BlockHeightY[k], ++ mode_lib->vba.Read256BlockWidthY[k], ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.SurfaceTiling[k], ++ dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0), ++ mode_lib->vba.SourceScan[k], ++ mode_lib->vba.ViewportWidth[k] / 2.0, ++ mode_lib->vba.ViewportHeight[k] / 2.0, ++ mode_lib->vba.SwathWidthYPerState[i][k] / 2.0, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.VMMPageSize, ++ mode_lib->vba.PTEBufferSizeInRequests, ++ mode_lib->vba.PDEProcessingBufIn64KBReqs, ++ mode_lib->vba.PitchC[k], ++ 0.0, ++ &mode_lib->vba.MacroTileWidthC[k], ++ &mode_lib->vba.MetaRowBytesC, ++ &mode_lib->vba.DPTEBytesPerRowC, ++ &mode_lib->vba.PTEBufferSizeNotExceededC[i][k], ++ &mode_lib->vba.dpte_row_height_chroma[k], ++ &mode_lib->vba.meta_row_height_chroma[k]); ++ mode_lib->vba.PrefetchLinesC[k] = CalculatePrefetchSourceLines( ++ mode_lib, ++ mode_lib->vba.VRatio[k] / 2.0, ++ mode_lib->vba.VTAPsChroma[k], ++ mode_lib->vba.Interlace[k], ++ mode_lib->vba.ProgressiveToInterlaceUnitInOPP, ++ mode_lib->vba.SwathHeightCPerState[i][k], ++ mode_lib->vba.ViewportYStartC[k], ++ &mode_lib->vba.PrefillC[k], ++ &mode_lib->vba.MaxNumSwC[k]); ++ } else { ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = 0.0; ++ mode_lib->vba.MetaRowBytesC = 0.0; ++ mode_lib->vba.DPTEBytesPerRowC = 0.0; ++ mode_lib->vba.PrefetchLinesC[k] = 0.0; ++ mode_lib->vba.PTEBufferSizeNotExceededC[i][k] = true; ++ } ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k] = ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrameY ++ + mode_lib->vba.PDEAndMetaPTEBytesPerFrameC; ++ mode_lib->vba.MetaRowBytes[k] = mode_lib->vba.MetaRowBytesY ++ + mode_lib->vba.MetaRowBytesC; ++ mode_lib->vba.DPTEBytesPerRow[k] = mode_lib->vba.DPTEBytesPerRowY ++ + mode_lib->vba.DPTEBytesPerRowC; ++ } ++ mode_lib->vba.ExtraLatency = ++ mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i] ++ + (mode_lib->vba.TotalNumberOfActiveDPP[i] ++ * mode_lib->vba.PixelChunkSizeInKByte ++ + mode_lib->vba.TotalNumberOfDCCActiveDPP[i] ++ * mode_lib->vba.MetaChunkSize) ++ * 1024.0 ++ / mode_lib->vba.ReturnBWPerState[i]; ++ if (mode_lib->vba.VirtualMemoryEnable == true) { ++ mode_lib->vba.ExtraLatency = mode_lib->vba.ExtraLatency ++ + mode_lib->vba.TotalNumberOfActiveDPP[i] ++ * mode_lib->vba.PTEChunkSize * 1024.0 ++ / mode_lib->vba.ReturnBWPerState[i]; ++ } ++ mode_lib->vba.TimeCalc = 24.0 / mode_lib->vba.ProjectedDCFCLKDeepSleep; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.BlendingAndTiming[k] == k) { ++ if (mode_lib->vba.WritebackEnable[k] == true) { ++ mode_lib->vba.WritebackDelay[i][k] = ++ mode_lib->vba.WritebackLatency ++ + CalculateWriteBackDelay( ++ mode_lib->vba.WritebackPixelFormat[k], ++ mode_lib->vba.WritebackHRatio[k], ++ mode_lib->vba.WritebackVRatio[k], ++ mode_lib->vba.WritebackLumaHTaps[k], ++ mode_lib->vba.WritebackLumaVTaps[k], ++ mode_lib->vba.WritebackChromaHTaps[k], ++ mode_lib->vba.WritebackChromaVTaps[k], ++ mode_lib->vba.WritebackDestinationWidth[k]) ++ / mode_lib->vba.RequiredDISPCLK[i]; ++ } else { ++ mode_lib->vba.WritebackDelay[i][k] = 0.0; ++ } ++ for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) { ++ if (mode_lib->vba.BlendingAndTiming[j] == k ++ && mode_lib->vba.WritebackEnable[j] ++ == true) { ++ mode_lib->vba.WritebackDelay[i][k] = ++ dml_max( ++ mode_lib->vba.WritebackDelay[i][k], ++ mode_lib->vba.WritebackLatency ++ + CalculateWriteBackDelay( ++ mode_lib->vba.WritebackPixelFormat[j], ++ mode_lib->vba.WritebackHRatio[j], ++ mode_lib->vba.WritebackVRatio[j], ++ mode_lib->vba.WritebackLumaHTaps[j], ++ mode_lib->vba.WritebackLumaVTaps[j], ++ mode_lib->vba.WritebackChromaHTaps[j], ++ mode_lib->vba.WritebackChromaVTaps[j], ++ mode_lib->vba.WritebackDestinationWidth[j]) ++ / mode_lib->vba.RequiredDISPCLK[i]); ++ } ++ } ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) { ++ if (mode_lib->vba.BlendingAndTiming[k] == j) { ++ mode_lib->vba.WritebackDelay[i][k] = ++ mode_lib->vba.WritebackDelay[i][j]; ++ } ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.MaximumVStartup[k] = ++ mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k] ++ - dml_max( ++ 1.0, ++ dml_ceil( ++ mode_lib->vba.WritebackDelay[i][k] ++ / (mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]), ++ 1.0)); ++ } ++ mode_lib->vba.TWait = CalculateTWait( ++ mode_lib->vba.PrefetchMode, ++ mode_lib->vba.DRAMClockChangeLatency, ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.SREnterPlusExitTime); ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.XFCEnabled[k] == true) { ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay = ++ CalculateRemoteSurfaceFlipDelay( ++ mode_lib, ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.SwathWidthYPerState[i][k], ++ dml_ceil( ++ mode_lib->vba.BytePerPixelInDETY[k], ++ 1.0), ++ mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k], ++ mode_lib->vba.XFCTSlvVupdateOffset, ++ mode_lib->vba.XFCTSlvVupdateWidth, ++ mode_lib->vba.XFCTSlvVreadyOffset, ++ mode_lib->vba.XFCXBUFLatencyTolerance, ++ mode_lib->vba.XFCFillBWOverhead, ++ mode_lib->vba.XFCSlvChunkSize, ++ mode_lib->vba.XFCBusTransportTime, ++ mode_lib->vba.TimeCalc, ++ mode_lib->vba.TWait, ++ &mode_lib->vba.SrcActiveDrainRate, ++ &mode_lib->vba.TInitXFill, ++ &mode_lib->vba.TslvChk); ++ } else { ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0.0; ++ } ++ mode_lib->vba.IsErrorResult[i][k] = ++ CalculatePrefetchSchedule( ++ mode_lib, ++ mode_lib->vba.RequiredDPPCLK[i][k], ++ mode_lib->vba.RequiredDISPCLK[i], ++ mode_lib->vba.PixelClock[k], ++ mode_lib->vba.ProjectedDCFCLKDeepSleep, ++ mode_lib->vba.DSCDelayPerState[i][k], ++ mode_lib->vba.NoOfDPP[i][k], ++ mode_lib->vba.ScalerEnabled[k], ++ mode_lib->vba.NumberOfCursors[k], ++ mode_lib->vba.DPPCLKDelaySubtotal, ++ mode_lib->vba.DPPCLKDelaySCL, ++ mode_lib->vba.DPPCLKDelaySCLLBOnly, ++ mode_lib->vba.DPPCLKDelayCNVCFormater, ++ mode_lib->vba.DPPCLKDelayCNVCCursor, ++ mode_lib->vba.DISPCLKDelaySubtotal, ++ mode_lib->vba.SwathWidthYPerState[i][k] ++ / mode_lib->vba.HRatio[k], ++ mode_lib->vba.OutputFormat[k], ++ mode_lib->vba.VTotal[k] ++ - mode_lib->vba.VActive[k], ++ mode_lib->vba.HTotal[k], ++ mode_lib->vba.MaxInterDCNTileRepeaters, ++ mode_lib->vba.MaximumVStartup[k], ++ mode_lib->vba.MaxPageTableLevels, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.DynamicMetadataEnable[k], ++ mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k], ++ mode_lib->vba.DynamicMetadataTransmittedBytes[k], ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.ExtraLatency, ++ mode_lib->vba.TimeCalc, ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k], ++ mode_lib->vba.MetaRowBytes[k], ++ mode_lib->vba.DPTEBytesPerRow[k], ++ mode_lib->vba.PrefetchLinesY[k], ++ mode_lib->vba.SwathWidthYPerState[i][k], ++ mode_lib->vba.BytePerPixelInDETY[k], ++ mode_lib->vba.PrefillY[k], ++ mode_lib->vba.MaxNumSwY[k], ++ mode_lib->vba.PrefetchLinesC[k], ++ mode_lib->vba.BytePerPixelInDETC[k], ++ mode_lib->vba.PrefillC[k], ++ mode_lib->vba.MaxNumSwC[k], ++ mode_lib->vba.SwathHeightYPerState[i][k], ++ mode_lib->vba.SwathHeightCPerState[i][k], ++ mode_lib->vba.TWait, ++ mode_lib->vba.XFCEnabled[k], ++ mode_lib->vba.XFCRemoteSurfaceFlipDelay, ++ mode_lib->vba.Interlace[k], ++ mode_lib->vba.ProgressiveToInterlaceUnitInOPP, ++ mode_lib->vba.DSTXAfterScaler, ++ mode_lib->vba.DSTYAfterScaler, ++ &mode_lib->vba.LineTimesForPrefetch[k], ++ &mode_lib->vba.PrefetchBW[k], ++ &mode_lib->vba.LinesForMetaPTE[k], ++ &mode_lib->vba.LinesForMetaAndDPTERow[k], ++ &mode_lib->vba.VRatioPreY[i][k], ++ &mode_lib->vba.VRatioPreC[i][k], ++ &mode_lib->vba.RequiredPrefetchPixelDataBW[i][k], ++ &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, ++ &mode_lib->vba.Tno_bw[k]); ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] ++ * mode_lib->vba.CursorWidth[k][0] ++ * mode_lib->vba.CursorBPP[k][0] / 8.0 ++ / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ * mode_lib->vba.VRatio[k]; ++ } ++ mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0; ++ mode_lib->vba.prefetch_vm_bw_valid = true; ++ mode_lib->vba.prefetch_row_bw_valid = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k] == 0.0) { ++ mode_lib->vba.prefetch_vm_bw[k] = 0.0; ++ } else if (mode_lib->vba.LinesForMetaPTE[k] > 0.0) { ++ mode_lib->vba.prefetch_vm_bw[k] = ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k] ++ / (mode_lib->vba.LinesForMetaPTE[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); ++ } else { ++ mode_lib->vba.prefetch_vm_bw[k] = 0.0; ++ mode_lib->vba.prefetch_vm_bw_valid = false; ++ } ++ if (mode_lib->vba.MetaRowBytes[k] + mode_lib->vba.DPTEBytesPerRow[k] ++ == 0.0) { ++ mode_lib->vba.prefetch_row_bw[k] = 0.0; ++ } else if (mode_lib->vba.LinesForMetaAndDPTERow[k] > 0.0) { ++ mode_lib->vba.prefetch_row_bw[k] = (mode_lib->vba.MetaRowBytes[k] ++ + mode_lib->vba.DPTEBytesPerRow[k]) ++ / (mode_lib->vba.LinesForMetaAndDPTERow[k] ++ * mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k]); ++ } else { ++ mode_lib->vba.prefetch_row_bw[k] = 0.0; ++ mode_lib->vba.prefetch_row_bw_valid = false; ++ } ++ mode_lib->vba.MaximumReadBandwidthWithPrefetch = ++ mode_lib->vba.MaximumReadBandwidthWithPrefetch ++ + mode_lib->vba.cursor_bw[k] ++ + dml_max4( ++ mode_lib->vba.prefetch_vm_bw[k], ++ mode_lib->vba.prefetch_row_bw[k], ++ mode_lib->vba.ReadBandwidth[k], ++ mode_lib->vba.RequiredPrefetchPixelDataBW[i][k]); ++ } ++ mode_lib->vba.PrefetchSupported[i] = true; ++ if (mode_lib->vba.MaximumReadBandwidthWithPrefetch ++ > mode_lib->vba.ReturnBWPerState[i] ++ || mode_lib->vba.prefetch_vm_bw_valid == false ++ || mode_lib->vba.prefetch_row_bw_valid == false) { ++ mode_lib->vba.PrefetchSupported[i] = false; ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.LineTimesForPrefetch[k] < 2.0 ++ || mode_lib->vba.LinesForMetaPTE[k] >= 8.0 ++ || mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16.0 ++ || mode_lib->vba.IsErrorResult[i][k] == true) { ++ mode_lib->vba.PrefetchSupported[i] = false; ++ } ++ } ++ mode_lib->vba.VRatioInPrefetchSupported[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.VRatioPreY[i][k] > 4.0 ++ || mode_lib->vba.VRatioPreC[i][k] > 4.0 ++ || mode_lib->vba.IsErrorResult[i][k] == true) { ++ mode_lib->vba.VRatioInPrefetchSupported[i] = false; ++ } ++ } ++ if (mode_lib->vba.PrefetchSupported[i] == true ++ && mode_lib->vba.VRatioInPrefetchSupported[i] == true) { ++ mode_lib->vba.BandwidthAvailableForImmediateFlip = ++ mode_lib->vba.ReturnBWPerState[i]; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.BandwidthAvailableForImmediateFlip = ++ mode_lib->vba.BandwidthAvailableForImmediateFlip ++ - mode_lib->vba.cursor_bw[k] ++ - dml_max( ++ mode_lib->vba.ReadBandwidth[k], ++ mode_lib->vba.PrefetchBW[k]); ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.ImmediateFlipBytes[k] = 0.0; ++ if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { ++ mode_lib->vba.ImmediateFlipBytes[k] = ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k] ++ + mode_lib->vba.MetaRowBytes[k] ++ + mode_lib->vba.DPTEBytesPerRow[k]; ++ } ++ } ++ mode_lib->vba.TotImmediateFlipBytes = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { ++ mode_lib->vba.TotImmediateFlipBytes = ++ mode_lib->vba.TotImmediateFlipBytes ++ + mode_lib->vba.ImmediateFlipBytes[k]; ++ } ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ CalculateFlipSchedule( ++ mode_lib, ++ mode_lib->vba.ExtraLatency, ++ mode_lib->vba.UrgentLatency, ++ mode_lib->vba.MaxPageTableLevels, ++ mode_lib->vba.VirtualMemoryEnable, ++ mode_lib->vba.BandwidthAvailableForImmediateFlip, ++ mode_lib->vba.TotImmediateFlipBytes, ++ mode_lib->vba.SourcePixelFormat[k], ++ mode_lib->vba.ImmediateFlipBytes[k], ++ mode_lib->vba.HTotal[k] ++ / mode_lib->vba.PixelClock[k], ++ mode_lib->vba.VRatio[k], ++ mode_lib->vba.Tno_bw[k], ++ mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k], ++ mode_lib->vba.MetaRowBytes[k], ++ mode_lib->vba.DPTEBytesPerRow[k], ++ mode_lib->vba.DCCEnable[k], ++ mode_lib->vba.dpte_row_height[k], ++ mode_lib->vba.meta_row_height[k], ++ mode_lib->vba.qual_row_bw[k], ++ &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k], ++ &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k], ++ &mode_lib->vba.final_flip_bw[k], ++ &mode_lib->vba.ImmediateFlipSupportedForPipe[k]); ++ } ++ mode_lib->vba.total_dcn_read_bw_with_flip = 0.0; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.total_dcn_read_bw_with_flip = ++ mode_lib->vba.total_dcn_read_bw_with_flip ++ + mode_lib->vba.cursor_bw[k] ++ + dml_max3( ++ mode_lib->vba.prefetch_vm_bw[k], ++ mode_lib->vba.prefetch_row_bw[k], ++ mode_lib->vba.final_flip_bw[k] ++ + dml_max( ++ mode_lib->vba.ReadBandwidth[k], ++ mode_lib->vba.RequiredPrefetchPixelDataBW[i][k])); ++ } ++ mode_lib->vba.ImmediateFlipSupportedForState[i] = true; ++ if (mode_lib->vba.total_dcn_read_bw_with_flip ++ > mode_lib->vba.ReturnBWPerState[i]) { ++ mode_lib->vba.ImmediateFlipSupportedForState[i] = false; ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) { ++ mode_lib->vba.ImmediateFlipSupportedForState[i] = false; ++ } ++ } ++ } else { ++ mode_lib->vba.ImmediateFlipSupportedForState[i] = false; ++ } ++ } ++ /*PTE Buffer Size Check*/ ++ ++ for (i = 0; i <= DC__VOLTAGE_STATES; i++) { ++ mode_lib->vba.PTEBufferSizeNotExceeded[i] = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.PTEBufferSizeNotExceededY[i][k] == false ++ || mode_lib->vba.PTEBufferSizeNotExceededC[i][k] == false) { ++ mode_lib->vba.PTEBufferSizeNotExceeded[i] = false; ++ } ++ } ++ } ++ /*Cursor Support Check*/ ++ ++ mode_lib->vba.CursorSupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.CursorWidth[k][0] > 0.0) { ++ if (dml_floor( ++ dml_floor( ++ mode_lib->vba.CursorBufferSize ++ - mode_lib->vba.CursorChunkSize, ++ mode_lib->vba.CursorChunkSize) * 1024.0 ++ / (mode_lib->vba.CursorWidth[k][0] ++ * mode_lib->vba.CursorBPP[k][0] ++ / 8.0), ++ 1.0) ++ * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) ++ / mode_lib->vba.VRatio[k] < mode_lib->vba.UrgentLatency ++ || (mode_lib->vba.CursorBPP[k][0] == 64.0 ++ && mode_lib->vba.Cursor64BppSupport == false)) { ++ mode_lib->vba.CursorSupport = false; ++ } ++ } ++ } ++ /*Valid Pitch Check*/ ++ ++ mode_lib->vba.PitchSupport = true; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.AlignedYPitch[k] = dml_ceil( ++ dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.ViewportWidth[k]), ++ mode_lib->vba.MacroTileWidthY[k]); ++ if (mode_lib->vba.AlignedYPitch[k] > mode_lib->vba.PitchY[k]) { ++ mode_lib->vba.PitchSupport = false; ++ } ++ if (mode_lib->vba.DCCEnable[k] == true) { ++ mode_lib->vba.AlignedDCCMetaPitch[k] = dml_ceil( ++ dml_max( ++ mode_lib->vba.DCCMetaPitchY[k], ++ mode_lib->vba.ViewportWidth[k]), ++ 64.0 * mode_lib->vba.Read256BlockWidthY[k]); ++ } else { ++ mode_lib->vba.AlignedDCCMetaPitch[k] = mode_lib->vba.DCCMetaPitchY[k]; ++ } ++ if (mode_lib->vba.AlignedDCCMetaPitch[k] > mode_lib->vba.DCCMetaPitchY[k]) { ++ mode_lib->vba.PitchSupport = false; ++ } ++ if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 ++ && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) { ++ mode_lib->vba.AlignedCPitch[k] = dml_ceil( ++ dml_max( ++ mode_lib->vba.PitchC[k], ++ mode_lib->vba.ViewportWidth[k] / 2.0), ++ mode_lib->vba.MacroTileWidthC[k]); ++ } else { ++ mode_lib->vba.AlignedCPitch[k] = mode_lib->vba.PitchC[k]; ++ } ++ if (mode_lib->vba.AlignedCPitch[k] > mode_lib->vba.PitchC[k]) { ++ mode_lib->vba.PitchSupport = false; ++ } ++ } ++ /*Mode Support, Voltage State and SOC Configuration*/ ++ ++ for (i = DC__VOLTAGE_STATES; i >= 0; i--) { ++ if (mode_lib->vba.ScaleRatioAndTapsSupport == true ++ && mode_lib->vba.SourceFormatPixelAndScanSupport == true ++ && mode_lib->vba.ViewportSizeSupport[i] == true ++ && mode_lib->vba.BandwidthSupport[i] == true ++ && mode_lib->vba.DIOSupport[i] == true ++ && mode_lib->vba.NotEnoughDSCUnits[i] == false ++ && mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] == false ++ && mode_lib->vba.UrgentLatencySupport[i] == true ++ && mode_lib->vba.ROBSupport[i] == true ++ && mode_lib->vba.DISPCLK_DPPCLK_Support[i] == true ++ && mode_lib->vba.TotalAvailablePipesSupport[i] == true ++ && mode_lib->vba.NumberOfOTGSupport == true ++ && mode_lib->vba.WritebackModeSupport == true ++ && mode_lib->vba.WritebackLatencySupport == true ++ && mode_lib->vba.WritebackScaleRatioAndTapsSupport == true ++ && mode_lib->vba.CursorSupport == true ++ && mode_lib->vba.PitchSupport == true ++ && mode_lib->vba.PrefetchSupported[i] == true ++ && mode_lib->vba.VRatioInPrefetchSupported[i] == true ++ && mode_lib->vba.PTEBufferSizeNotExceeded[i] == true ++ && mode_lib->vba.NonsupportedDSCInputBPC == false) { ++ mode_lib->vba.ModeSupport[i] = true; ++ } else { ++ mode_lib->vba.ModeSupport[i] = false; ++ } ++ } ++ for (i = DC__VOLTAGE_STATES; i >= 0; i--) { ++ if (i == DC__VOLTAGE_STATES || mode_lib->vba.ModeSupport[i] == true) { ++ mode_lib->vba.VoltageLevel = i; ++ } ++ } ++ mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKPerState[mode_lib->vba.VoltageLevel]; ++ mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel]; ++ mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel]; ++ mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel]; ++ mode_lib->vba.FabricAndDRAMBandwidth = ++ mode_lib->vba.FabricAndDRAMBandwidthPerState[mode_lib->vba.VoltageLevel]; ++ mode_lib->vba.ImmediateFlipSupport = ++ mode_lib->vba.ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel]; ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ mode_lib->vba.DPPPerPlane[k] = mode_lib->vba.NoOfDPP[mode_lib->vba.VoltageLevel][k]; ++ } ++ for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { ++ if (mode_lib->vba.BlendingAndTiming[k] == k) { ++ mode_lib->vba.ODMCombineEnabled[k] = ++ mode_lib->vba.ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k]; ++ } else { ++ mode_lib->vba.ODMCombineEnabled[k] = 0; ++ } ++ mode_lib->vba.DSCEnabled[k] = ++ mode_lib->vba.RequiresDSC[mode_lib->vba.VoltageLevel][k]; ++ mode_lib->vba.OutputBpp[k] = ++ mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k]; ++ } ++} +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h +index a24fe9a..346ffea 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h +@@ -79,6 +79,11 @@ double get_total_prefetch_bw( + const display_e2e_pipe_params_st *pipes, + unsigned int num_pipes); + ++unsigned int dml_get_voltage_level( ++ struct display_mode_lib *mode_lib, ++ const display_e2e_pipe_params_st *pipes, ++ unsigned int num_pipes); ++ + bool Calculate256BBlockSizes( + enum source_format_class SourcePixelFormat, + enum dm_swizzle_mode SurfaceTiling, +@@ -96,42 +101,41 @@ struct vba_vars_st { + mode_evaluation_st me; + + unsigned int MaximumMaxVStartupLines; +- double cursor_bw[DC__NUM_PIPES__MAX]; +- double meta_row_bw[DC__NUM_PIPES__MAX]; +- double dpte_row_bw[DC__NUM_PIPES__MAX]; +- double qual_row_bw[DC__NUM_PIPES__MAX]; ++ double cursor_bw[DC__NUM_DPP__MAX]; ++ double meta_row_bw[DC__NUM_DPP__MAX]; ++ double dpte_row_bw[DC__NUM_DPP__MAX]; ++ double qual_row_bw[DC__NUM_DPP__MAX]; + double WritebackDISPCLK; +- double PSCL_THROUGHPUT_LUMA[DC__NUM_PIPES__MAX]; +- double PSCL_THROUGHPUT_CHROMA[DC__NUM_PIPES__MAX]; ++ double PSCL_THROUGHPUT_LUMA[DC__NUM_DPP__MAX]; ++ double PSCL_THROUGHPUT_CHROMA[DC__NUM_DPP__MAX]; + double DPPCLKUsingSingleDPPLuma; + double DPPCLKUsingSingleDPPChroma; +- double DPPCLKUsingSingleDPP[DC__NUM_PIPES__MAX]; ++ double DPPCLKUsingSingleDPP[DC__NUM_DPP__MAX]; + double DISPCLKWithRamping; + double DISPCLKWithoutRamping; + double GlobalDPPCLK; +- double MaxDispclk; + double DISPCLKWithRampingRoundedToDFSGranularity; + double DISPCLKWithoutRampingRoundedToDFSGranularity; + double MaxDispclkRoundedToDFSGranularity; + bool DCCEnabledAnyPlane; + double ReturnBandwidthToDCN; +- unsigned int SwathWidthY[DC__NUM_PIPES__MAX]; +- unsigned int SwathWidthSingleDPPY[DC__NUM_PIPES__MAX]; +- double BytePerPixelDETY[DC__NUM_PIPES__MAX]; +- double BytePerPixelDETC[DC__NUM_PIPES__MAX]; +- double ReadBandwidthPlaneLuma[DC__NUM_PIPES__MAX]; +- double ReadBandwidthPlaneChroma[DC__NUM_PIPES__MAX]; ++ unsigned int SwathWidthY[DC__NUM_DPP__MAX]; ++ unsigned int SwathWidthSingleDPPY[DC__NUM_DPP__MAX]; ++ double BytePerPixelDETY[DC__NUM_DPP__MAX]; ++ double BytePerPixelDETC[DC__NUM_DPP__MAX]; ++ double ReadBandwidthPlaneLuma[DC__NUM_DPP__MAX]; ++ double ReadBandwidthPlaneChroma[DC__NUM_DPP__MAX]; + unsigned int TotalActiveDPP; + unsigned int TotalDCCActiveDPP; + double UrgentRoundTripAndOutOfOrderLatency; +- double DisplayPipeLineDeliveryTimeLuma[DC__NUM_PIPES__MAX]; // WM +- double DisplayPipeLineDeliveryTimeChroma[DC__NUM_PIPES__MAX]; // WM +- double LinesInDETY[DC__NUM_PIPES__MAX]; // WM +- double LinesInDETC[DC__NUM_PIPES__MAX]; // WM +- unsigned int LinesInDETYRoundedDownToSwath[DC__NUM_PIPES__MAX]; // WM +- unsigned int LinesInDETCRoundedDownToSwath[DC__NUM_PIPES__MAX]; // WM +- double FullDETBufferingTimeY[DC__NUM_PIPES__MAX]; // WM +- double FullDETBufferingTimeC[DC__NUM_PIPES__MAX]; // WM ++ double DisplayPipeLineDeliveryTimeLuma[DC__NUM_DPP__MAX]; // WM ++ double DisplayPipeLineDeliveryTimeChroma[DC__NUM_DPP__MAX]; // WM ++ double LinesInDETY[DC__NUM_DPP__MAX]; // WM ++ double LinesInDETC[DC__NUM_DPP__MAX]; // WM ++ unsigned int LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX]; // WM ++ unsigned int LinesInDETCRoundedDownToSwath[DC__NUM_DPP__MAX]; // WM ++ double FullDETBufferingTimeY[DC__NUM_DPP__MAX]; // WM ++ double FullDETBufferingTimeC[DC__NUM_DPP__MAX]; // WM + double MinFullDETBufferingTime; + double FrameTimeForMinFullDETBufferingTime; + double AverageReadBandwidthGBytePerSecond; +@@ -145,55 +149,54 @@ struct vba_vars_st { + double EffectiveDETPlusLBLinesChroma; + double UrgentLatencySupportUsLuma; + double UrgentLatencySupportUsChroma; +- double UrgentLatencySupportUs[DC__NUM_PIPES__MAX]; ++ double UrgentLatencySupportUs[DC__NUM_DPP__MAX]; + unsigned int DSCFormatFactor; +- unsigned int BlockHeight256BytesY[DC__NUM_PIPES__MAX]; +- unsigned int BlockHeight256BytesC[DC__NUM_PIPES__MAX]; +- unsigned int BlockWidth256BytesY[DC__NUM_PIPES__MAX]; +- unsigned int BlockWidth256BytesC[DC__NUM_PIPES__MAX]; +- double VInitPreFillY[DC__NUM_PIPES__MAX]; +- double VInitPreFillC[DC__NUM_PIPES__MAX]; +- unsigned int MaxNumSwathY[DC__NUM_PIPES__MAX]; +- unsigned int MaxNumSwathC[DC__NUM_PIPES__MAX]; +- double PrefetchSourceLinesY[DC__NUM_PIPES__MAX]; +- double PrefetchSourceLinesC[DC__NUM_PIPES__MAX]; +- double PixelPTEBytesPerRow[DC__NUM_PIPES__MAX]; +- double MetaRowByte[DC__NUM_PIPES__MAX]; +- bool PTEBufferSizeNotExceeded; // not used +- unsigned int dpte_row_height[DC__NUM_PIPES__MAX]; +- unsigned int dpte_row_height_chroma[DC__NUM_PIPES__MAX]; +- unsigned int meta_row_height[DC__NUM_PIPES__MAX]; +- unsigned int meta_row_height_chroma[DC__NUM_PIPES__MAX]; +- +- unsigned int MacroTileWidthY; +- unsigned int MacroTileWidthC; +- unsigned int MaxVStartupLines[DC__NUM_PIPES__MAX]; +- double WritebackDelay[DC__NUM_PIPES__MAX]; ++ unsigned int BlockHeight256BytesY[DC__NUM_DPP__MAX]; ++ unsigned int BlockHeight256BytesC[DC__NUM_DPP__MAX]; ++ unsigned int BlockWidth256BytesY[DC__NUM_DPP__MAX]; ++ unsigned int BlockWidth256BytesC[DC__NUM_DPP__MAX]; ++ double VInitPreFillY[DC__NUM_DPP__MAX]; ++ double VInitPreFillC[DC__NUM_DPP__MAX]; ++ unsigned int MaxNumSwathY[DC__NUM_DPP__MAX]; ++ unsigned int MaxNumSwathC[DC__NUM_DPP__MAX]; ++ double PrefetchSourceLinesY[DC__NUM_DPP__MAX]; ++ double PrefetchSourceLinesC[DC__NUM_DPP__MAX]; ++ double PixelPTEBytesPerRow[DC__NUM_DPP__MAX]; ++ double MetaRowByte[DC__NUM_DPP__MAX]; ++ unsigned int dpte_row_height[DC__NUM_DPP__MAX]; ++ unsigned int dpte_row_height_chroma[DC__NUM_DPP__MAX]; ++ unsigned int meta_row_height[DC__NUM_DPP__MAX]; ++ unsigned int meta_row_height_chroma[DC__NUM_DPP__MAX]; ++ ++ unsigned int MacroTileWidthY[DC__NUM_DPP__MAX]; ++ unsigned int MacroTileWidthC[DC__NUM_DPP__MAX]; ++ unsigned int MaxVStartupLines[DC__NUM_DPP__MAX]; ++ double WritebackDelay[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; + bool PrefetchModeSupported; +- bool AllowDRAMClockChangeDuringVBlank[DC__NUM_PIPES__MAX]; +- bool AllowDRAMSelfRefreshDuringVBlank[DC__NUM_PIPES__MAX]; +- double RequiredPrefetchPixDataBW[DC__NUM_PIPES__MAX]; ++ bool AllowDRAMClockChangeDuringVBlank[DC__NUM_DPP__MAX]; ++ bool AllowDRAMSelfRefreshDuringVBlank[DC__NUM_DPP__MAX]; ++ double RequiredPrefetchPixDataBW[DC__NUM_DPP__MAX]; + double XFCRemoteSurfaceFlipDelay; + double TInitXFill; + double TslvChk; + double SrcActiveDrainRate; +- double Tno_bw[DC__NUM_PIPES__MAX]; ++ double Tno_bw[DC__NUM_DPP__MAX]; + bool ImmediateFlipSupported; + +- double prefetch_vm_bw[DC__NUM_PIPES__MAX]; +- double prefetch_row_bw[DC__NUM_PIPES__MAX]; +- bool ImmediateFlipSupportedForPipe[DC__NUM_PIPES__MAX]; ++ double prefetch_vm_bw[DC__NUM_DPP__MAX]; ++ double prefetch_row_bw[DC__NUM_DPP__MAX]; ++ bool ImmediateFlipSupportedForPipe[DC__NUM_DPP__MAX]; + unsigned int VStartupLines; +- double DisplayPipeLineDeliveryTimeLumaPrefetch[DC__NUM_PIPES__MAX]; +- double DisplayPipeLineDeliveryTimeChromaPrefetch[DC__NUM_PIPES__MAX]; ++ double DisplayPipeLineDeliveryTimeLumaPrefetch[DC__NUM_DPP__MAX]; ++ double DisplayPipeLineDeliveryTimeChromaPrefetch[DC__NUM_DPP__MAX]; + unsigned int ActiveDPPs; + unsigned int LBLatencyHidingSourceLinesY; + unsigned int LBLatencyHidingSourceLinesC; +- double ActiveDRAMClockChangeLatencyMargin[DC__NUM_PIPES__MAX]; ++ double ActiveDRAMClockChangeLatencyMargin[DC__NUM_DPP__MAX]; + double MinActiveDRAMClockChangeMargin; +- double XFCSlaveVUpdateOffset[DC__NUM_PIPES__MAX]; +- double XFCSlaveVupdateWidth[DC__NUM_PIPES__MAX]; +- double XFCSlaveVReadyOffset[DC__NUM_PIPES__MAX]; ++ double XFCSlaveVUpdateOffset[DC__NUM_DPP__MAX]; ++ double XFCSlaveVupdateWidth[DC__NUM_DPP__MAX]; ++ double XFCSlaveVReadyOffset[DC__NUM_DPP__MAX]; + double InitFillLevel; + double FinalFillMargin; + double FinalFillLevel; +@@ -276,71 +279,71 @@ struct vba_vars_st { + double DCFCLK; + + unsigned int NumberOfActivePlanes; +- unsigned int ViewportWidth[DC__NUM_DPP]; +- unsigned int ViewportHeight[DC__NUM_DPP]; +- unsigned int ViewportYStartY[DC__NUM_DPP]; +- unsigned int ViewportYStartC[DC__NUM_DPP]; +- unsigned int PitchY[DC__NUM_DPP]; +- unsigned int PitchC[DC__NUM_DPP]; +- double HRatio[DC__NUM_DPP]; +- double VRatio[DC__NUM_DPP]; +- unsigned int htaps[DC__NUM_DPP]; +- unsigned int vtaps[DC__NUM_DPP]; +- unsigned int HTAPsChroma[DC__NUM_DPP]; +- unsigned int VTAPsChroma[DC__NUM_DPP]; +- unsigned int HTotal[DC__NUM_DPP]; +- unsigned int VTotal[DC__NUM_DPP]; +- unsigned int DPPPerPlane[DC__NUM_DPP]; +- double PixelClock[DC__NUM_DPP]; +- double PixelClockBackEnd[DC__NUM_DPP]; +- double DPPCLK[DC__NUM_DPP]; +- bool DCCEnable[DC__NUM_DPP]; +- unsigned int DCCMetaPitchY[DC__NUM_DPP]; +- enum scan_direction_class SourceScan[DC__NUM_DPP]; +- enum source_format_class SourcePixelFormat[DC__NUM_DPP]; +- bool WritebackEnable[DC__NUM_DPP]; +- double WritebackDestinationWidth[DC__NUM_DPP]; +- double WritebackDestinationHeight[DC__NUM_DPP]; +- double WritebackSourceHeight[DC__NUM_DPP]; +- enum source_format_class WritebackPixelFormat[DC__NUM_DPP]; +- unsigned int WritebackLumaHTaps[DC__NUM_DPP]; +- unsigned int WritebackLumaVTaps[DC__NUM_DPP]; +- unsigned int WritebackChromaHTaps[DC__NUM_DPP]; +- unsigned int WritebackChromaVTaps[DC__NUM_DPP]; +- double WritebackHRatio[DC__NUM_DPP]; +- double WritebackVRatio[DC__NUM_DPP]; +- unsigned int HActive[DC__NUM_DPP]; +- unsigned int VActive[DC__NUM_DPP]; +- bool Interlace[DC__NUM_DPP]; +- enum dm_swizzle_mode SurfaceTiling[DC__NUM_DPP]; +- unsigned int ScalerRecoutWidth[DC__NUM_DPP]; +- bool DynamicMetadataEnable[DC__NUM_DPP]; +- unsigned int DynamicMetadataLinesBeforeActiveRequired[DC__NUM_DPP]; +- unsigned int DynamicMetadataTransmittedBytes[DC__NUM_DPP]; +- double DCCRate[DC__NUM_DPP]; +- bool ODMCombineEnabled[DC__NUM_DPP]; +- double OutputBpp[DC__NUM_DPP]; +- unsigned int NumberOfDSCSlices[DC__NUM_DPP]; +- bool DSCEnabled[DC__NUM_DPP]; +- unsigned int DSCDelay[DC__NUM_DPP]; +- unsigned int DSCInputBitPerComponent[DC__NUM_DPP]; +- enum output_format_class OutputFormat[DC__NUM_DPP]; +- enum output_encoder_class Output[DC__NUM_DPP]; +- unsigned int BlendingAndTiming[DC__NUM_DPP]; ++ unsigned int ViewportWidth[DC__NUM_DPP__MAX]; ++ unsigned int ViewportHeight[DC__NUM_DPP__MAX]; ++ unsigned int ViewportYStartY[DC__NUM_DPP__MAX]; ++ unsigned int ViewportYStartC[DC__NUM_DPP__MAX]; ++ unsigned int PitchY[DC__NUM_DPP__MAX]; ++ unsigned int PitchC[DC__NUM_DPP__MAX]; ++ double HRatio[DC__NUM_DPP__MAX]; ++ double VRatio[DC__NUM_DPP__MAX]; ++ unsigned int htaps[DC__NUM_DPP__MAX]; ++ unsigned int vtaps[DC__NUM_DPP__MAX]; ++ unsigned int HTAPsChroma[DC__NUM_DPP__MAX]; ++ unsigned int VTAPsChroma[DC__NUM_DPP__MAX]; ++ unsigned int HTotal[DC__NUM_DPP__MAX]; ++ unsigned int VTotal[DC__NUM_DPP__MAX]; ++ unsigned int DPPPerPlane[DC__NUM_DPP__MAX]; ++ double PixelClock[DC__NUM_DPP__MAX]; ++ double PixelClockBackEnd[DC__NUM_DPP__MAX]; ++ double DPPCLK[DC__NUM_DPP__MAX]; ++ bool DCCEnable[DC__NUM_DPP__MAX]; ++ unsigned int DCCMetaPitchY[DC__NUM_DPP__MAX]; ++ enum scan_direction_class SourceScan[DC__NUM_DPP__MAX]; ++ enum source_format_class SourcePixelFormat[DC__NUM_DPP__MAX]; ++ bool WritebackEnable[DC__NUM_DPP__MAX]; ++ double WritebackDestinationWidth[DC__NUM_DPP__MAX]; ++ double WritebackDestinationHeight[DC__NUM_DPP__MAX]; ++ double WritebackSourceHeight[DC__NUM_DPP__MAX]; ++ enum source_format_class WritebackPixelFormat[DC__NUM_DPP__MAX]; ++ unsigned int WritebackLumaHTaps[DC__NUM_DPP__MAX]; ++ unsigned int WritebackLumaVTaps[DC__NUM_DPP__MAX]; ++ unsigned int WritebackChromaHTaps[DC__NUM_DPP__MAX]; ++ unsigned int WritebackChromaVTaps[DC__NUM_DPP__MAX]; ++ double WritebackHRatio[DC__NUM_DPP__MAX]; ++ double WritebackVRatio[DC__NUM_DPP__MAX]; ++ unsigned int HActive[DC__NUM_DPP__MAX]; ++ unsigned int VActive[DC__NUM_DPP__MAX]; ++ bool Interlace[DC__NUM_DPP__MAX]; ++ enum dm_swizzle_mode SurfaceTiling[DC__NUM_DPP__MAX]; ++ unsigned int ScalerRecoutWidth[DC__NUM_DPP__MAX]; ++ bool DynamicMetadataEnable[DC__NUM_DPP__MAX]; ++ unsigned int DynamicMetadataLinesBeforeActiveRequired[DC__NUM_DPP__MAX]; ++ unsigned int DynamicMetadataTransmittedBytes[DC__NUM_DPP__MAX]; ++ double DCCRate[DC__NUM_DPP__MAX]; ++ bool ODMCombineEnabled[DC__NUM_DPP__MAX]; ++ double OutputBpp[DC__NUM_DPP__MAX]; ++ unsigned int NumberOfDSCSlices[DC__NUM_DPP__MAX]; ++ bool DSCEnabled[DC__NUM_DPP__MAX]; ++ unsigned int DSCDelay[DC__NUM_DPP__MAX]; ++ unsigned int DSCInputBitPerComponent[DC__NUM_DPP__MAX]; ++ enum output_format_class OutputFormat[DC__NUM_DPP__MAX]; ++ enum output_encoder_class Output[DC__NUM_DPP__MAX]; ++ unsigned int BlendingAndTiming[DC__NUM_DPP__MAX]; + bool SynchronizedVBlank; +- unsigned int NumberOfCursors[DC__NUM_DPP]; +- unsigned int CursorWidth[DC__NUM_DPP][DC__NUM_CURSOR]; +- unsigned int CursorBPP[DC__NUM_DPP][DC__NUM_CURSOR]; +- bool XFCEnabled[DC__NUM_DPP]; +- bool ScalerEnabled[DC__NUM_DPP]; ++ unsigned int NumberOfCursors[DC__NUM_DPP__MAX]; ++ unsigned int CursorWidth[DC__NUM_DPP__MAX][DC__NUM_CURSOR]; ++ unsigned int CursorBPP[DC__NUM_DPP__MAX][DC__NUM_CURSOR]; ++ bool XFCEnabled[DC__NUM_DPP__MAX]; ++ bool ScalerEnabled[DC__NUM_DPP__MAX]; + + // Intermediates/Informational + bool ImmediateFlipSupport; +- unsigned int SwathHeightY[DC__NUM_DPP]; +- unsigned int SwathHeightC[DC__NUM_DPP]; +- unsigned int DETBufferSizeY[DC__NUM_DPP]; +- unsigned int DETBufferSizeC[DC__NUM_DPP]; +- unsigned int LBBitPerPixel[DC__NUM_DPP]; ++ unsigned int SwathHeightY[DC__NUM_DPP__MAX]; ++ unsigned int SwathHeightC[DC__NUM_DPP__MAX]; ++ unsigned int DETBufferSizeY[DC__NUM_DPP__MAX]; ++ unsigned int DETBufferSizeC[DC__NUM_DPP__MAX]; ++ unsigned int LBBitPerPixel[DC__NUM_DPP__MAX]; + double LastPixelOfLineExtraWatermark; + double TotalDataReadBandwidth; + unsigned int TotalActiveWriteback; +@@ -349,9 +352,9 @@ struct vba_vars_st { + double BandwidthAvailableForImmediateFlip; + unsigned int PrefetchMode; + bool IgnoreViewportPositioning; +- double PrefetchBandwidth[DC__NUM_DPP]; +- bool ErrorResult[DC__NUM_DPP]; +- double PDEAndMetaPTEBytesFrame[DC__NUM_DPP]; ++ double PrefetchBandwidth[DC__NUM_DPP__MAX]; ++ bool ErrorResult[DC__NUM_DPP__MAX]; ++ double PDEAndMetaPTEBytesFrame[DC__NUM_DPP__MAX]; + + // + // Calculated dml_ml->vba.Outputs +@@ -376,35 +379,200 @@ struct vba_vars_st { + // used explicitly. They are fetched by tests and then possibly used. The + // ultimate values to use are the ones specified by the parameters to DML + double DISPCLK_calculated; +- double DSCCLK_calculated[DC__NUM_DPP]; +- double DPPCLK_calculated[DC__NUM_DPP]; ++ double DSCCLK_calculated[DC__NUM_DPP__MAX]; ++ double DPPCLK_calculated[DC__NUM_DPP__MAX]; + +- unsigned int VStartup[DC__NUM_DPP]; ++ unsigned int VStartup[DC__NUM_DPP__MAX]; + unsigned int VStartupRequiredWhenNotEnoughTimeForDynamicMetadata; + + double ImmediateFlipBW; + unsigned int TotImmediateFlipBytes; + double TCalc; +- double MinTTUVBlank[DC__NUM_DPP]; +- double VRatioPrefetchY[DC__NUM_DPP]; +- double VRatioPrefetchC[DC__NUM_DPP]; +- double DSTXAfterScaler[DC__NUM_DPP]; +- double DSTYAfterScaler[DC__NUM_DPP]; +- +- double DestinationLinesToRequestVMInVBlank[DC__NUM_DPP]; +- double DestinationLinesToRequestRowInVBlank[DC__NUM_DPP]; +- double DestinationLinesForPrefetch[DC__NUM_DPP]; +- double DestinationLinesToRequestRowInImmediateFlip[DC__NUM_DPP]; +- double DestinationLinesToRequestVMInImmediateFlip[DC__NUM_DPP]; +- +- double XFCTransferDelay[DC__NUM_DPP]; +- double XFCPrechargeDelay[DC__NUM_DPP]; +- double XFCRemoteSurfaceFlipLatency[DC__NUM_DPP]; +- double XFCPrefetchMargin[DC__NUM_DPP]; +- +- display_e2e_pipe_params_st cache_pipes[DC__NUM_DPP]; ++ double MinTTUVBlank[DC__NUM_DPP__MAX]; ++ double VRatioPrefetchY[DC__NUM_DPP__MAX]; ++ double VRatioPrefetchC[DC__NUM_DPP__MAX]; ++ double DSTXAfterScaler[DC__NUM_DPP__MAX]; ++ double DSTYAfterScaler[DC__NUM_DPP__MAX]; ++ ++ double DestinationLinesToRequestVMInVBlank[DC__NUM_DPP__MAX]; ++ double DestinationLinesToRequestRowInVBlank[DC__NUM_DPP__MAX]; ++ double DestinationLinesForPrefetch[DC__NUM_DPP__MAX]; ++ double DestinationLinesToRequestRowInImmediateFlip[DC__NUM_DPP__MAX]; ++ double DestinationLinesToRequestVMInImmediateFlip[DC__NUM_DPP__MAX]; ++ ++ double XFCTransferDelay[DC__NUM_DPP__MAX]; ++ double XFCPrechargeDelay[DC__NUM_DPP__MAX]; ++ double XFCRemoteSurfaceFlipLatency[DC__NUM_DPP__MAX]; ++ double XFCPrefetchMargin[DC__NUM_DPP__MAX]; ++ ++ display_e2e_pipe_params_st cache_pipes[DC__NUM_DPP__MAX]; + unsigned int cache_num_pipes; +- unsigned int pipe_plane[DC__NUM_PIPES__MAX]; ++ unsigned int pipe_plane[DC__NUM_DPP__MAX]; ++ ++ /* vba mode support */ ++ /*inputs*/ ++ bool SupportGFX7CompatibleTilingIn32bppAnd64bpp; ++ double MaxHSCLRatio; ++ double MaxVSCLRatio; ++ unsigned int MaxNumWriteback; ++ bool WritebackLumaAndChromaScalingSupported; ++ bool Cursor64BppSupport; ++ double DCFCLKPerState[DC__VOLTAGE_STATES + 1]; ++ double FabricClockPerState[DC__VOLTAGE_STATES + 1]; ++ double SOCCLKPerState[DC__VOLTAGE_STATES + 1]; ++ double PHYCLKPerState[DC__VOLTAGE_STATES + 1]; ++ double MaxDppclk[DC__VOLTAGE_STATES + 1]; ++ double MaxDSCCLK[DC__VOLTAGE_STATES + 1]; ++ double DRAMSpeedPerState[DC__VOLTAGE_STATES + 1]; ++ double MaxDispclk[DC__VOLTAGE_STATES + 1]; ++ ++ /*outputs*/ ++ bool ScaleRatioAndTapsSupport; ++ bool SourceFormatPixelAndScanSupport; ++ unsigned int SwathWidthYSingleDPP[DC__NUM_DPP__MAX]; ++ double BytePerPixelInDETY[DC__NUM_DPP__MAX]; ++ double BytePerPixelInDETC[DC__NUM_DPP__MAX]; ++ double TotalReadBandwidthConsumedGBytePerSecond; ++ double ReadBandwidth[DC__NUM_DPP__MAX]; ++ double TotalWriteBandwidthConsumedGBytePerSecond; ++ double WriteBandwidth[DC__NUM_DPP__MAX]; ++ double TotalBandwidthConsumedGBytePerSecond; ++ bool DCCEnabledInAnyPlane; ++ bool WritebackLatencySupport; ++ bool WritebackModeSupport; ++ bool Writeback10bpc420Supported; ++ bool BandwidthSupport[DC__VOLTAGE_STATES + 1]; ++ unsigned int TotalNumberOfActiveWriteback; ++ double CriticalPoint; ++ double ReturnBWToDCNPerState; ++ double FabricAndDRAMBandwidthPerState[DC__VOLTAGE_STATES + 1]; ++ double ReturnBWPerState[DC__VOLTAGE_STATES + 1]; ++ double UrgentRoundTripAndOutOfOrderLatencyPerState[DC__VOLTAGE_STATES + 1]; ++ bool ODMCombineEnablePerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ bool PTEBufferSizeNotExceededY[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ bool PTEBufferSizeNotExceededC[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ bool PrefetchSupported[DC__VOLTAGE_STATES + 1]; ++ bool VRatioInPrefetchSupported[DC__VOLTAGE_STATES + 1]; ++ bool DISPCLK_DPPCLK_Support[DC__VOLTAGE_STATES + 1]; ++ bool TotalAvailablePipesSupport[DC__VOLTAGE_STATES + 1]; ++ bool UrgentLatencySupport[DC__VOLTAGE_STATES + 1]; ++ bool ModeSupport[DC__VOLTAGE_STATES + 1]; ++ bool DIOSupport[DC__VOLTAGE_STATES + 1]; ++ bool NotEnoughDSCUnits[DC__VOLTAGE_STATES + 1]; ++ bool DSCCLKRequiredMoreThanSupported[DC__VOLTAGE_STATES + 1]; ++ bool ROBSupport[DC__VOLTAGE_STATES + 1]; ++ bool PTEBufferSizeNotExceeded[DC__VOLTAGE_STATES + 1]; ++ bool RequiresDSC[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ bool IsErrorResult[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ bool ViewportSizeSupport[DC__VOLTAGE_STATES + 1]; ++ bool prefetch_vm_bw_valid; ++ bool prefetch_row_bw_valid; ++ bool NumberOfOTGSupport; ++ bool NonsupportedDSCInputBPC; ++ bool WritebackScaleRatioAndTapsSupport; ++ bool CursorSupport; ++ bool PitchSupport; ++ ++ double WritebackLineBufferLumaBufferSize; ++ double WritebackLineBufferChromaBufferSize; ++ double WritebackMinHSCLRatio; ++ double WritebackMinVSCLRatio; ++ double WritebackMaxHSCLRatio; ++ double WritebackMaxVSCLRatio; ++ double WritebackMaxHSCLTaps; ++ double WritebackMaxVSCLTaps; ++ unsigned int MaxNumDPP; ++ unsigned int MaxNumOTG; ++ double CursorBufferSize; ++ double CursorChunkSize; ++ unsigned int Mode; ++ double NoOfDPP[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double OutputLinkDPLanes[DC__NUM_DPP__MAX]; ++ double SwathWidthYPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double SwathHeightYPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double SwathHeightCPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double UrgentLatencySupportUsPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double VRatioPreY[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double VRatioPreC[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double RequiredPrefetchPixelDataBW[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double RequiredDPPCLK[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double RequiredDISPCLK[DC__VOLTAGE_STATES + 1]; ++ double TotalNumberOfActiveDPP[DC__VOLTAGE_STATES + 1]; ++ double TotalNumberOfDCCActiveDPP[DC__VOLTAGE_STATES + 1]; ++ double PrefetchBW[DC__NUM_DPP__MAX]; ++ double PDEAndMetaPTEBytesPerFrame[DC__NUM_DPP__MAX]; ++ double MetaRowBytes[DC__NUM_DPP__MAX]; ++ double DPTEBytesPerRow[DC__NUM_DPP__MAX]; ++ double PrefetchLinesY[DC__NUM_DPP__MAX]; ++ double PrefetchLinesC[DC__NUM_DPP__MAX]; ++ unsigned int MaxNumSwY[DC__NUM_DPP__MAX]; ++ unsigned int MaxNumSwC[DC__NUM_DPP__MAX]; ++ double PrefillY[DC__NUM_DPP__MAX]; ++ double PrefillC[DC__NUM_DPP__MAX]; ++ double LineTimesForPrefetch[DC__NUM_DPP__MAX]; ++ double LinesForMetaPTE[DC__NUM_DPP__MAX]; ++ double LinesForMetaAndDPTERow[DC__NUM_DPP__MAX]; ++ double MinDPPCLKUsingSingleDPP[DC__NUM_DPP__MAX]; ++ double RequiresFEC[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ unsigned int OutputBppPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ double DSCDelayPerState[DC__VOLTAGE_STATES + 1][DC__NUM_DPP__MAX]; ++ unsigned int Read256BlockHeightY[DC__NUM_DPP__MAX]; ++ unsigned int Read256BlockWidthY[DC__NUM_DPP__MAX]; ++ unsigned int Read256BlockHeightC[DC__NUM_DPP__MAX]; ++ unsigned int Read256BlockWidthC[DC__NUM_DPP__MAX]; ++ unsigned int ImmediateFlipBytes[DC__NUM_DPP__MAX]; ++ double MaxSwathHeightY[DC__NUM_DPP__MAX]; ++ double MaxSwathHeightC[DC__NUM_DPP__MAX]; ++ double MinSwathHeightY[DC__NUM_DPP__MAX]; ++ double MinSwathHeightC[DC__NUM_DPP__MAX]; ++ double PSCL_FACTOR[DC__NUM_DPP__MAX]; ++ double PSCL_FACTOR_CHROMA[DC__NUM_DPP__MAX]; ++ double MaximumVStartup[DC__NUM_DPP__MAX]; ++ double AlignedDCCMetaPitch[DC__NUM_DPP__MAX]; ++ double AlignedYPitch[DC__NUM_DPP__MAX]; ++ double AlignedCPitch[DC__NUM_DPP__MAX]; ++ double MaximumSwathWidth[DC__NUM_DPP__MAX]; ++ double final_flip_bw[DC__NUM_DPP__MAX]; ++ double ImmediateFlipSupportedForState[DC__VOLTAGE_STATES + 1]; ++ ++ double WritebackLumaVExtra; ++ double WritebackChromaVExtra; ++ double WritebackRequiredDISPCLK; ++ double MaximumSwathWidthSupport; ++ double MaximumSwathWidthInDETBuffer; ++ double MaximumSwathWidthInLineBuffer; ++ double MaxDispclkRoundedDownToDFSGranularity; ++ double MaxDppclkRoundedDownToDFSGranularity; ++ double PlaneRequiredDISPCLKWithoutODMCombine; ++ double PlaneRequiredDISPCLK; ++ double TotalNumberOfActiveOTG; ++ double FECOverhead; ++ double EffectiveFECOverhead; ++ unsigned int Outbpp; ++ unsigned int OutbppDSC; ++ double TotalDSCUnitsRequired; ++ double bpp; ++ unsigned int slices; ++ double SwathWidthGranularityY; ++ double RoundedUpMaxSwathSizeBytesY; ++ double SwathWidthGranularityC; ++ double RoundedUpMaxSwathSizeBytesC; ++ double LinesInDETLuma; ++ double LinesInDETChroma; ++ double EffectiveDETLBLinesLuma; ++ double EffectiveDETLBLinesChroma; ++ double ProjectedDCFCLKDeepSleep; ++ double PDEAndMetaPTEBytesPerFrameY; ++ double PDEAndMetaPTEBytesPerFrameC; ++ unsigned int MetaRowBytesY; ++ unsigned int MetaRowBytesC; ++ unsigned int DPTEBytesPerRowC; ++ unsigned int DPTEBytesPerRowY; ++ double ExtraLatency; ++ double TimeCalc; ++ double TWait; ++ double MaximumReadBandwidthWithPrefetch; ++ double total_dcn_read_bw_with_flip; + }; + + #endif /* _DML2_DISPLAY_MODE_VBA_H_ */ +diff --git a/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.c b/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.c +index 9cbd415..2af6d15 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.c +@@ -35,6 +35,18 @@ double dml_max(double a, double b) + { + return (double) dcn_bw_max2(a, b); + } ++double dml_max3(double a, double b, double c) ++{ ++ return dml_max(dml_max(a, b), c); ++} ++double dml_max4(double a, double b, double c, double d) ++{ ++ return dml_max(dml_max(a, b), dml_max(c, d)); ++} ++double dml_max5(double a, double b, double c, double d, double e) ++{ ++ return dml_max(dml_max4(a, b, c, d), e); ++} + + double dml_ceil(double a, double granularity) + { +diff --git a/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.h b/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.h +index 19271e7..ba01bbb 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.h ++++ b/drivers/gpu/drm/amd/display/dc/dml/dml_common_defs.h +@@ -36,6 +36,9 @@ + + double dml_min(double a, double b); + double dml_max(double a, double b); ++double dml_max3(double a, double b, double c); ++double dml_max4(double a, double b, double c, double d); ++double dml_max5(double a, double b, double c, double d, double e); + bool dml_util_is_420(enum source_format_class sorce_format); + double dml_ceil_ex(double x, double granularity); + double dml_floor_ex(double x, double granularity); +-- +2.7.4 + |