/*
 * Copyright 2022 Advanced Micro Devices, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: AMD
 *
 */

#include "dc.h"
#include "dc_link.h"
#include "../display_mode_lib.h"
#include "display_mode_vba_32.h"
#include "../dml_inline_defs.h"
#include "display_mode_vba_util_32.h"

void dml32_recalculate(struct display_mode_lib *mode_lib);
static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
		struct display_mode_lib *mode_lib);
void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib);

void dml32_recalculate(struct display_mode_lib *mode_lib)
{
	ModeSupportAndSystemConfiguration(mode_lib);

	dml32_CalculateMaxDETAndMinCompressedBufferSize(mode_lib->vba.ConfigReturnBufferSizeInKByte,
			mode_lib->vba.ROBBufferSizeInKByte,
			DC__NUM_DPP,
			false, //mode_lib->vba.override_setting.nomDETInKByteOverrideEnable,
			0, //mode_lib->vba.override_setting.nomDETInKByteOverrideValue,

			/* Output */
			&mode_lib->vba.MaxTotalDETInKByte, &mode_lib->vba.nomDETInKByte,
			&mode_lib->vba.MinCompressedBufferSizeInKByte);

	PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: Calling DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation\n", __func__);
#endif
	DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
}

static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
		struct display_mode_lib *mode_lib)
{
	struct vba_vars_st *v = &mode_lib->vba;
	unsigned int j, k;
	bool ImmediateFlipRequirementFinal;
	int iteration;
	double MaxTotalRDBandwidth;
	unsigned int NextPrefetchMode;
	double MaxTotalRDBandwidthNoUrgentBurst = 0.0;
	bool DestinationLineTimesForPrefetchLessThan2 = false;
	bool VRatioPrefetchMoreThanMax = false;
	double TWait;
	double TotalWRBandwidth = 0;
	double WRBandwidth = 0;

#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: --- START ---\n", __func__);
	dml_print("DML::%s: mode_lib->vba.PrefetchMode = %d\n", __func__, mode_lib->vba.PrefetchMode);
	dml_print("DML::%s: mode_lib->vba.ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
	dml_print("DML::%s: mode_lib->vba.VoltageLevel = %d\n", __func__, mode_lib->vba.VoltageLevel);
#endif

	v->WritebackDISPCLK = 0.0;
	v->GlobalDPPCLK = 0.0;

	// DISPCLK and DPPCLK Calculation
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.WritebackEnable[k]) {
			v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
					dml32_CalculateWriteBackDISPCLK(
							mode_lib->vba.WritebackPixelFormat[k],
							mode_lib->vba.PixelClock[k], mode_lib->vba.WritebackHRatio[k],
							mode_lib->vba.WritebackVRatio[k],
							mode_lib->vba.WritebackHTaps[k],
							mode_lib->vba.WritebackVTaps[k],
							mode_lib->vba.WritebackSourceWidth[k],
							mode_lib->vba.WritebackDestinationWidth[k],
							mode_lib->vba.HTotal[k], mode_lib->vba.WritebackLineBufferSize,
							mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
		}
	}

	v->DISPCLK_calculated = v->WritebackDISPCLK;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.BlendingAndTiming[k] == k) {
			v->DISPCLK_calculated = dml_max(v->DISPCLK_calculated,
					dml32_CalculateRequiredDispclk(
							mode_lib->vba.ODMCombineEnabled[k],
							mode_lib->vba.PixelClock[k],
							mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
							mode_lib->vba.DISPCLKRampingMargin,
							mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
							mode_lib->vba.MaxDppclk[v->soc.num_states - 1]));
		}
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k],
				mode_lib->vba.HRatioChroma[k],
				mode_lib->vba.VRatio[k],
				mode_lib->vba.VRatioChroma[k],
				mode_lib->vba.MaxDCHUBToPSCLThroughput,
				mode_lib->vba.MaxPSCLToLBThroughput,
				mode_lib->vba.PixelClock[k],
				mode_lib->vba.SourcePixelFormat[k],
				mode_lib->vba.htaps[k],
				mode_lib->vba.HTAPsChroma[k],
				mode_lib->vba.vtaps[k],
				mode_lib->vba.VTAPsChroma[k],

				/* Output */
				&v->PSCL_THROUGHPUT_LUMA[k], &v->PSCL_THROUGHPUT_CHROMA[k],
				&v->DPPCLKUsingSingleDPP[k]);
	}

	dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces, mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
			mode_lib->vba.DISPCLKDPPCLKVCOSpeed, v->DPPCLKUsingSingleDPP, mode_lib->vba.DPPPerPlane,
			/* Output */
			&v->GlobalDPPCLK, v->DPPCLK);

	for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
		v->DPPCLK_calculated[k] = v->DPPCLK[k];
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		dml32_CalculateBytePerPixelAndBlockSizes(
				mode_lib->vba.SourcePixelFormat[k],
				mode_lib->vba.SurfaceTiling[k],

				/* Output */
				&v->BytePerPixelY[k],
				&v->BytePerPixelC[k],
				&v->BytePerPixelDETY[k],
				&v->BytePerPixelDETC[k],
				&v->BlockHeight256BytesY[k],
				&v->BlockHeight256BytesC[k],
				&v->BlockWidth256BytesY[k],
				&v->BlockWidth256BytesC[k],
				&v->BlockHeightY[k],
				&v->BlockHeightC[k],
				&v->BlockWidthY[k],
				&v->BlockWidthC[k]);
	}

#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: %d\n", __func__, __LINE__);
#endif
	dml32_CalculateSwathWidth(
			false,  // ForceSingleDPP
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.SourcePixelFormat,
			mode_lib->vba.SourceRotation,
			mode_lib->vba.ViewportStationary,
			mode_lib->vba.ViewportWidth,
			mode_lib->vba.ViewportHeight,
			mode_lib->vba.ViewportXStartY,
			mode_lib->vba.ViewportYStartY,
			mode_lib->vba.ViewportXStartC,
			mode_lib->vba.ViewportYStartC,
			mode_lib->vba.SurfaceWidthY,
			mode_lib->vba.SurfaceWidthC,
			mode_lib->vba.SurfaceHeightY,
			mode_lib->vba.SurfaceHeightC,
			mode_lib->vba.ODMCombineEnabled,
			v->BytePerPixelY,
			v->BytePerPixelC,
			v->BlockHeight256BytesY,
			v->BlockHeight256BytesC,
			v->BlockWidth256BytesY,
			v->BlockWidth256BytesC,
			mode_lib->vba.BlendingAndTiming,
			mode_lib->vba.HActive,
			mode_lib->vba.HRatio,
			mode_lib->vba.DPPPerPlane,

			/* Output */
			v->SwathWidthSingleDPPY, v->SwathWidthSingleDPPC, v->SwathWidthY, v->SwathWidthC,
			v->dummy_vars
				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
				.dummy_integer_array[0], // Integer             MaximumSwathHeightY[]
			v->dummy_vars
				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
				.dummy_integer_array[1], // Integer             MaximumSwathHeightC[]
			v->swath_width_luma_ub, v->swath_width_chroma_ub);

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->ReadBandwidthSurfaceLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k]
				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
		v->ReadBandwidthSurfaceChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k]
				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
				* mode_lib->vba.VRatioChroma[k];
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n",
				__func__, k, v->ReadBandwidthSurfaceLuma[k]);
		dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n",
				__func__, k, v->ReadBandwidthSurfaceChroma[k]);
#endif
	}

	{
		// VBA_DELTA
		// Calculate DET size, swath height
		dml32_CalculateSwathAndDETConfiguration(
				mode_lib->vba.DETSizeOverride,
				mode_lib->vba.UsesMALLForPStateChange,
				mode_lib->vba.ConfigReturnBufferSizeInKByte,
				mode_lib->vba.MaxTotalDETInKByte,
				mode_lib->vba.MinCompressedBufferSizeInKByte,
				false, /* ForceSingleDPP */
				mode_lib->vba.NumberOfActiveSurfaces,
				mode_lib->vba.nomDETInKByte,
				mode_lib->vba.UseUnboundedRequesting,
				mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
				mode_lib->vba.ip.pixel_chunk_size_kbytes,
				mode_lib->vba.ip.rob_buffer_size_kbytes,
				mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_output_encoder_array, /* output_encoder_class Output[] */
				v->ReadBandwidthSurfaceLuma,
				v->ReadBandwidthSurfaceChroma,
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_single_array[0], /* Single MaximumSwathWidthLuma[] */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_single_array[1], /* Single MaximumSwathWidthChroma[] */
				mode_lib->vba.SourceRotation,
				mode_lib->vba.ViewportStationary,
				mode_lib->vba.SourcePixelFormat,
				mode_lib->vba.SurfaceTiling,
				mode_lib->vba.ViewportWidth,
				mode_lib->vba.ViewportHeight,
				mode_lib->vba.ViewportXStartY,
				mode_lib->vba.ViewportYStartY,
				mode_lib->vba.ViewportXStartC,
				mode_lib->vba.ViewportYStartC,
				mode_lib->vba.SurfaceWidthY,
				mode_lib->vba.SurfaceWidthC,
				mode_lib->vba.SurfaceHeightY,
				mode_lib->vba.SurfaceHeightC,
				v->BlockHeight256BytesY,
				v->BlockHeight256BytesC,
				v->BlockWidth256BytesY,
				v->BlockWidth256BytesC,
				mode_lib->vba.ODMCombineEnabled,
				mode_lib->vba.BlendingAndTiming,
				v->BytePerPixelY,
				v->BytePerPixelC,
				v->BytePerPixelDETY,
				v->BytePerPixelDETC,
				mode_lib->vba.HActive,
				mode_lib->vba.HRatio,
				mode_lib->vba.HRatioChroma,
				mode_lib->vba.DPPPerPlane,

				/* Output */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_long_array[0], /* Long swath_width_luma_ub[] */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_long_array[1], /* Long swath_width_chroma_ub[] */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_double_array[0], /* Long SwathWidth[] */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_double_array[1], /* Long SwathWidthChroma[] */
				mode_lib->vba.SwathHeightY,
				mode_lib->vba.SwathHeightC,
				mode_lib->vba.DETBufferSizeInKByte,
				mode_lib->vba.DETBufferSizeY,
				mode_lib->vba.DETBufferSizeC,
				&v->UnboundedRequestEnabled,
				&v->CompressedBufferSizeInkByte,
				&v->CompBufReservedSpaceKBytes,
				&v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_boolean,       /* bool *CompBufReservedSpaceNeedAjustment */
				v->dummy_vars
					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					.dummy_boolean_array, /* bool ViewportSizeSupportPerSurface[] */
				&v->dummy_vars
					 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
					 .dummy_boolean); /* bool *ViewportSizeSupport */
	}

	v->CompBufReservedSpaceZs     = v->CompBufReservedSpaceKBytes * 1024.0 / 256.0;
	v->CompBufReservedSpace64B    = v->CompBufReservedSpaceKBytes * 1024.0 / 64.0;

	// DCFCLK Deep Sleep
	dml32_CalculateDCFCLKDeepSleep(
			mode_lib->vba.NumberOfActiveSurfaces,
			v->BytePerPixelY,
			v->BytePerPixelC,
			mode_lib->vba.VRatio,
			mode_lib->vba.VRatioChroma,
			v->SwathWidthY,
			v->SwathWidthC,
			mode_lib->vba.DPPPerPlane,
			mode_lib->vba.HRatio,
			mode_lib->vba.HRatioChroma,
			mode_lib->vba.PixelClock,
			v->PSCL_THROUGHPUT_LUMA,
			v->PSCL_THROUGHPUT_CHROMA,
			mode_lib->vba.DPPCLK,
			v->ReadBandwidthSurfaceLuma,
			v->ReadBandwidthSurfaceChroma,
			mode_lib->vba.ReturnBusWidth,

			/* Output */
			&v->DCFCLKDeepSleep);

	// DSCCLK
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
			v->DSCCLK_calculated[k] = 0.0;
		} else {
			if (mode_lib->vba.OutputFormat[k] == dm_420)
				mode_lib->vba.DSCFormatFactor = 2;
			else if (mode_lib->vba.OutputFormat[k] == dm_444)
				mode_lib->vba.DSCFormatFactor = 1;
			else if (mode_lib->vba.OutputFormat[k] == dm_n422)
				mode_lib->vba.DSCFormatFactor = 2;
			else
				mode_lib->vba.DSCFormatFactor = 1;
			if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 12
						/ mode_lib->vba.DSCFormatFactor
						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
			else if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 6
						/ mode_lib->vba.DSCFormatFactor
						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
			else
				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 3
						/ mode_lib->vba.DSCFormatFactor
						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
		}
	}

	// DSC Delay
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->DSCDelay[k] = dml32_DSCDelayRequirement(mode_lib->vba.DSCEnabled[k],
				mode_lib->vba.ODMCombineEnabled[k], mode_lib->vba.DSCInputBitPerComponent[k],
				mode_lib->vba.OutputBpp[k], mode_lib->vba.HActive[k], mode_lib->vba.HTotal[k],
				mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.OutputFormat[k],
				mode_lib->vba.Output[k], mode_lib->vba.PixelClock[k],
				mode_lib->vba.PixelClockBackEnd[k]);
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
		for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) // NumberOfSurfaces
			if (j != k && mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.DSCEnabled[j])
				v->DSCDelay[k] = v->DSCDelay[j];

	//Immediate Flip
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->ImmediateFlipSupportedSurface[k] = mode_lib->vba.ImmediateFlipSupport
				&& (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required);
	}

	// Prefetch
	dml32_CalculateSurfaceSizeInMall(
				mode_lib->vba.NumberOfActiveSurfaces,
				mode_lib->vba.MALLAllocatedForDCNFinal,
				mode_lib->vba.UseMALLForStaticScreen,
				mode_lib->vba.DCCEnable,
				mode_lib->vba.ViewportStationary,
				mode_lib->vba.ViewportXStartY,
				mode_lib->vba.ViewportYStartY,
				mode_lib->vba.ViewportXStartC,
				mode_lib->vba.ViewportYStartC,
				mode_lib->vba.ViewportWidth,
				mode_lib->vba.ViewportHeight,
				v->BytePerPixelY,
				mode_lib->vba.ViewportWidthChroma,
				mode_lib->vba.ViewportHeightChroma,
				v->BytePerPixelC,
				mode_lib->vba.SurfaceWidthY,
				mode_lib->vba.SurfaceWidthC,
				mode_lib->vba.SurfaceHeightY,
				mode_lib->vba.SurfaceHeightC,
				v->BlockWidth256BytesY,
				v->BlockWidth256BytesC,
				v->BlockHeight256BytesY,
				v->BlockHeight256BytesC,
				v->BlockWidthY,
				v->BlockWidthC,
				v->BlockHeightY,
				v->BlockHeightC,

				/* Output */
				v->SurfaceSizeInMALL,
				&v->dummy_vars.
				DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
				.dummy_boolean2); /* Boolean *ExceededMALLSize */

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesY = v->BlockWidth256BytesY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesY = v->BlockHeight256BytesY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesC = v->BlockWidth256BytesC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesC = v->BlockHeight256BytesC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthY = v->BlockWidthY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightY = v->BlockHeightY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthC = v->BlockWidthC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightC = v->BlockHeightC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].HTotal = mode_lib->vba.HTotal[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelY = v->BytePerPixelY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelC = v->BytePerPixelC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatio = mode_lib->vba.VRatio[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTaps = mode_lib->vba.vtaps[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchY = mode_lib->vba.PitchY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchC = mode_lib->vba.PitchC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightY = mode_lib->vba.SwathHeightY[k];
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightC = mode_lib->vba.SwathHeightC[k];
	}

	{

		dml32_CalculateVMRowAndSwath(
				mode_lib->vba.NumberOfActiveSurfaces,
				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters,
				v->SurfaceSizeInMALL,
				mode_lib->vba.PTEBufferSizeInRequestsLuma,
				mode_lib->vba.PTEBufferSizeInRequestsChroma,
				mode_lib->vba.DCCMetaBufferSizeBytes,
				mode_lib->vba.UseMALLForStaticScreen,
				mode_lib->vba.UsesMALLForPStateChange,
				mode_lib->vba.MALLAllocatedForDCNFinal,
				v->SwathWidthY,
				v->SwathWidthC,
				mode_lib->vba.GPUVMEnable,
				mode_lib->vba.HostVMEnable,
				mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
				mode_lib->vba.GPUVMMaxPageTableLevels,
				mode_lib->vba.GPUVMMinPageSizeKBytes,
				mode_lib->vba.HostVMMinPageSize,

				/* Output */
				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[0],  // Boolean PTEBufferSizeNotExceeded[]
				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[1],  // Boolean DCCMetaBufferSizeNotExceeded[]
				v->dpte_row_width_luma_ub,
				v->dpte_row_width_chroma_ub,
				v->dpte_row_height,
				v->dpte_row_height_chroma,
				v->dpte_row_height_linear,
				v->dpte_row_height_linear_chroma,
				v->meta_req_width,
				v->meta_req_width_chroma,
				v->meta_req_height,
				v->meta_req_height_chroma,
				v->meta_row_width,
				v->meta_row_width_chroma,
				v->meta_row_height,
				v->meta_row_height_chroma,
				v->vm_group_bytes,
				v->dpte_group_bytes,
				v->PixelPTEReqWidthY,
				v->PixelPTEReqHeightY,
				v->PTERequestSizeY,
				v->PixelPTEReqWidthC,
				v->PixelPTEReqHeightC,
				v->PTERequestSizeC,
				v->dpde0_bytes_per_frame_ub_l,
				v->meta_pte_bytes_per_frame_ub_l,
				v->dpde0_bytes_per_frame_ub_c,
				v->meta_pte_bytes_per_frame_ub_c,
				v->PrefetchSourceLinesY,
				v->PrefetchSourceLinesC,
				v->VInitPreFillY, v->VInitPreFillC,
				v->MaxNumSwathY,
				v->MaxNumSwathC,
				v->meta_row_bw,
				v->dpte_row_bw,
				v->PixelPTEBytesPerRow,
				v->PDEAndMetaPTEBytesFrame,
				v->MetaRowByte,
				v->Use_One_Row_For_Frame,
				v->Use_One_Row_For_Frame_Flip,
				v->UsesMALLForStaticScreen,
				v->PTE_BUFFER_MODE,
				v->BIGK_FRAGMENT_SIZE);
	}


	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes = mode_lib->vba.NumberOfChannels
			* dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
					mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
					mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);

	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.VMDataOnlyReturnBW = dml32_get_return_bw_mbps_vm_only(
			&mode_lib->vba.soc,
			mode_lib->vba.VoltageLevel,
			mode_lib->vba.DCFCLK,
			mode_lib->vba.FabricClock,
			mode_lib->vba.DRAMSpeed);

#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: mode_lib->vba.ReturnBusWidth = %f\n", __func__, mode_lib->vba.ReturnBusWidth);
	dml_print("DML::%s: mode_lib->vba.DCFCLK = %f\n", __func__, mode_lib->vba.DCFCLK);
	dml_print("DML::%s: mode_lib->vba.FabricClock = %f\n", __func__, mode_lib->vba.FabricClock);
	dml_print("DML::%s: mode_lib->vba.FabricDatapathToDCNDataReturn = %f\n", __func__,
			mode_lib->vba.FabricDatapathToDCNDataReturn);
	dml_print("DML::%s: mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency = %f\n",
			__func__, mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency);
	dml_print("DML::%s: mode_lib->vba.DRAMSpeed = %f\n", __func__, mode_lib->vba.DRAMSpeed);
	dml_print("DML::%s: mode_lib->vba.NumberOfChannels = %f\n", __func__, mode_lib->vba.NumberOfChannels);
	dml_print("DML::%s: mode_lib->vba.DRAMChannelWidth = %f\n", __func__, mode_lib->vba.DRAMChannelWidth);
	dml_print("DML::%s: mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly = %f\n",
			__func__, mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly);
	dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
	dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->vba.ReturnBW);
#endif

	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor = 1.0;

	if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
		v->dummy_vars
			.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
			.HostVMInefficiencyFactor =
			mode_lib->vba.ReturnBW / v->dummy_vars
				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
				.VMDataOnlyReturnBW;

	mode_lib->vba.TotalDCCActiveDPP = 0;
	mode_lib->vba.TotalActiveDPP = 0;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++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];
	}

	v->UrgentExtraLatency = dml32_CalculateExtraLatency(
			mode_lib->vba.RoundTripPingLatencyCycles,
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes,
			mode_lib->vba.DCFCLK,
			mode_lib->vba.TotalActiveDPP,
			mode_lib->vba.PixelChunkSizeInKByte,
			mode_lib->vba.TotalDCCActiveDPP,
			mode_lib->vba.MetaChunkSize,
			mode_lib->vba.ReturnBW,
			mode_lib->vba.GPUVMEnable,
			mode_lib->vba.HostVMEnable,
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.DPPPerPlane,
			v->dpte_group_bytes,
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
			mode_lib->vba.HostVMMinPageSize,
			mode_lib->vba.HostVMMaxNonCachedPageTableLevels);

	mode_lib->vba.TCalc = 24.0 / v->DCFCLKDeepSleep;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.BlendingAndTiming[k] == k) {
			if (mode_lib->vba.WritebackEnable[k] == true) {
				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = mode_lib->vba.WritebackLatency
						+ dml32_CalculateWriteBackDelay(
								mode_lib->vba.WritebackPixelFormat[k],
								mode_lib->vba.WritebackHRatio[k],
								mode_lib->vba.WritebackVRatio[k],
								mode_lib->vba.WritebackVTaps[k],
								mode_lib->vba.WritebackDestinationWidth[k],
								mode_lib->vba.WritebackDestinationHeight[k],
								mode_lib->vba.WritebackSourceHeight[k],
								mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK;
			} else
				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
			for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
				if (mode_lib->vba.BlendingAndTiming[j] == k &&
					mode_lib->vba.WritebackEnable[j] == true) {
					v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
						dml_max(v->WritebackDelay[mode_lib->vba.VoltageLevel][k],
						mode_lib->vba.WritebackLatency +
						dml32_CalculateWriteBackDelay(
								mode_lib->vba.WritebackPixelFormat[j],
								mode_lib->vba.WritebackHRatio[j],
								mode_lib->vba.WritebackVRatio[j],
								mode_lib->vba.WritebackVTaps[j],
								mode_lib->vba.WritebackDestinationWidth[j],
								mode_lib->vba.WritebackDestinationHeight[j],
								mode_lib->vba.WritebackSourceHeight[j],
								mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK);
				}
			}
		}
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
		for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j)
			if (mode_lib->vba.BlendingAndTiming[k] == j)
				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
						v->WritebackDelay[mode_lib->vba.VoltageLevel][j];

	v->UrgentLatency = dml32_CalculateUrgentLatency(mode_lib->vba.UrgentLatencyPixelDataOnly,
			mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
			mode_lib->vba.UrgentLatencyVMDataOnly,
			mode_lib->vba.DoUrgentLatencyAdjustment,
			mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
			mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
			mode_lib->vba.FabricClock);

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
				v->swath_width_luma_ub[k],
				v->swath_width_chroma_ub[k],
				mode_lib->vba.SwathHeightY[k],
				mode_lib->vba.SwathHeightC[k],
				mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
				v->UrgentLatency,
				mode_lib->vba.CursorBufferSize,
				mode_lib->vba.CursorWidth[k][0],
				mode_lib->vba.CursorBPP[k][0],
				mode_lib->vba.VRatio[k],
				mode_lib->vba.VRatioChroma[k],
				v->BytePerPixelDETY[k],
				v->BytePerPixelDETC[k],
				mode_lib->vba.DETBufferSizeY[k],
				mode_lib->vba.DETBufferSizeC[k],

				/* output */
				&v->UrgBurstFactorCursor[k],
				&v->UrgBurstFactorLuma[k],
				&v->UrgBurstFactorChroma[k],
				&v->NoUrgentLatencyHiding[k]);

		v->cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] / 8 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->MaxVStartupLines[k] = ((mode_lib->vba.Interlace[k] &&
				!mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
				dml_floor((mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) / 2.0, 1.0) :
				mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) - dml_max(1.0,
				dml_ceil((double) v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1));

	// Clamp to max OTG vstartup register limit
	if (v->MaxVStartupLines[k] > 1023)
		v->MaxVStartupLines[k] = 1023;

#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: k=%d MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
		dml_print("DML::%s: k=%d VoltageLevel = %d\n", __func__, k, mode_lib->vba.VoltageLevel);
		dml_print("DML::%s: k=%d WritebackDelay = %f\n", __func__,
				k, v->WritebackDelay[mode_lib->vba.VoltageLevel][k]);
#endif
	}

	v->MaximumMaxVStartupLines = 0;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
		v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);

	ImmediateFlipRequirementFinal = false;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		ImmediateFlipRequirementFinal = ImmediateFlipRequirementFinal
				|| (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
	}
#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: ImmediateFlipRequirementFinal = %d\n", __func__, ImmediateFlipRequirementFinal);
#endif
	// ModeProgramming will not repeat the schedule calculation using different prefetch mode,
	//it is just calcualated once with given prefetch mode
	dml32_CalculateMinAndMaxPrefetchMode(
			mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
			&mode_lib->vba.MinPrefetchMode,
			&mode_lib->vba.MaxPrefetchMode);

	v->VStartupLines = __DML_VBA_MIN_VSTARTUP__;

	iteration = 0;
	MaxTotalRDBandwidth = 0;
	NextPrefetchMode = mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb];

	do {
		MaxTotalRDBandwidth = 0;
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);
#endif
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			/* NOTE PerfetchMode variable is invalid in DAL as per the input received.
			 * Hence the direction is to use PrefetchModePerState.
			 */
			TWait = dml32_CalculateTWait(
				mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
				mode_lib->vba.UsesMALLForPStateChange[k],
				mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
				mode_lib->vba.DRRDisplay[k],
				mode_lib->vba.DRAMClockChangeLatency,
				mode_lib->vba.FCLKChangeLatency, v->UrgentLatency,
				mode_lib->vba.SREnterPlusExitTime);

			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dppclk = mode_lib->vba.DPPCLK[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dispclk = mode_lib->vba.DISPCLK;
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCFClkDeepSleep = v->DCFCLKDeepSleep;
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HTotal = mode_lib->vba.HTotal[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HActive = mode_lib->vba.HActive[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ODMMode = mode_lib->vba.ODMCombineEnabled[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelY = v->BytePerPixelY[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelC = v->BytePerPixelC[k];
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
			v->ErrorResult[k] = dml32_CalculatePrefetchSchedule(
					v,
					k,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe,
					v->DSCDelay[k],
					(unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
					dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
					v->MaxVStartupLines[k],
					v->UrgentLatency,
					v->UrgentExtraLatency,
					v->TCalc,
					v->PDEAndMetaPTEBytesFrame[k],
					v->MetaRowByte[k],
					v->PixelPTEBytesPerRow[k],
					v->PrefetchSourceLinesY[k],
					v->SwathWidthY[k],
					v->VInitPreFillY[k],
					v->MaxNumSwathY[k],
					v->PrefetchSourceLinesC[k],
					v->SwathWidthC[k],
					v->VInitPreFillC[k],
					v->MaxNumSwathC[k],
					v->swath_width_luma_ub[k],
					v->swath_width_chroma_ub[k],
					v->SwathHeightY[k],
					v->SwathHeightC[k],
					TWait,
					/* Output */
					&v->DSTXAfterScaler[k],
					&v->DSTYAfterScaler[k],
					&v->DestinationLinesForPrefetch[k],
					&v->PrefetchBandwidth[k],
					&v->DestinationLinesToRequestVMInVBlank[k],
					&v->DestinationLinesToRequestRowInVBlank[k],
					&v->VRatioPrefetchY[k],
					&v->VRatioPrefetchC[k],
					&v->RequiredPrefetchPixDataBWLuma[k],
					&v->RequiredPrefetchPixDataBWChroma[k],
					&v->NotEnoughTimeForDynamicMetadata[k],
					&v->Tno_bw[k], &v->prefetch_vmrow_bw[k],
					&v->Tdmdl_vm[k],
					&v->Tdmdl[k],
					&v->TSetup[k],
					&v->VUpdateOffsetPix[k],
					&v->VUpdateWidthPix[k],
					&v->VReadyOffsetPix[k]);

#ifdef __DML_VBA_DEBUG__
			dml_print("DML::%s: k=%0d Prefetch calculation errResult=%0d\n",
					__func__, k, mode_lib->vba.ErrorResult[k]);
#endif
			v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
		}

		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
					v->swath_width_luma_ub[k],
					v->swath_width_chroma_ub[k],
					mode_lib->vba.SwathHeightY[k],
					mode_lib->vba.SwathHeightC[k],
					mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
					v->UrgentLatency,
					mode_lib->vba.CursorBufferSize,
					mode_lib->vba.CursorWidth[k][0],
					mode_lib->vba.CursorBPP[k][0],
					v->VRatioPrefetchY[k],
					v->VRatioPrefetchC[k],
					v->BytePerPixelDETY[k],
					v->BytePerPixelDETC[k],
					mode_lib->vba.DETBufferSizeY[k],
					mode_lib->vba.DETBufferSizeC[k],
					/* Output */
					&v->UrgBurstFactorCursorPre[k],
					&v->UrgBurstFactorLumaPre[k],
					&v->UrgBurstFactorChromaPre[k],
					&v->NoUrgentLatencyHidingPre[k]);

			v->cursor_bw_pre[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]) * v->VRatioPrefetchY[k];

#ifdef __DML_VBA_DEBUG__
			dml_print("DML::%s: k=%0d DPPPerSurface=%d\n", __func__, k, mode_lib->vba.DPPPerPlane[k]);
			dml_print("DML::%s: k=%0d UrgBurstFactorLuma=%f\n", __func__, k, v->UrgBurstFactorLuma[k]);
			dml_print("DML::%s: k=%0d UrgBurstFactorChroma=%f\n", __func__, k, v->UrgBurstFactorChroma[k]);
			dml_print("DML::%s: k=%0d UrgBurstFactorLumaPre=%f\n", __func__, k,
					v->UrgBurstFactorLumaPre[k]);
			dml_print("DML::%s: k=%0d UrgBurstFactorChromaPre=%f\n", __func__, k,
					v->UrgBurstFactorChromaPre[k]);

			dml_print("DML::%s: k=%0d VRatioPrefetchY=%f\n", __func__, k, v->VRatioPrefetchY[k]);
			dml_print("DML::%s: k=%0d VRatioY=%f\n", __func__, k, mode_lib->vba.VRatio[k]);

			dml_print("DML::%s: k=%0d prefetch_vmrow_bw=%f\n", __func__, k, v->prefetch_vmrow_bw[k]);
			dml_print("DML::%s: k=%0d ReadBandwidthSurfaceLuma=%f\n", __func__, k,
					v->ReadBandwidthSurfaceLuma[k]);
			dml_print("DML::%s: k=%0d ReadBandwidthSurfaceChroma=%f\n", __func__, k,
					v->ReadBandwidthSurfaceChroma[k]);
			dml_print("DML::%s: k=%0d cursor_bw=%f\n", __func__, k, v->cursor_bw[k]);
			dml_print("DML::%s: k=%0d meta_row_bw=%f\n", __func__, k, v->meta_row_bw[k]);
			dml_print("DML::%s: k=%0d dpte_row_bw=%f\n", __func__, k, v->dpte_row_bw[k]);
			dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWLuma=%f\n", __func__, k,
					v->RequiredPrefetchPixDataBWLuma[k]);
			dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWChroma=%f\n", __func__, k,
					v->RequiredPrefetchPixDataBWChroma[k]);
			dml_print("DML::%s: k=%0d cursor_bw_pre=%f\n", __func__, k, v->cursor_bw_pre[k]);
			dml_print("DML::%s: k=%0d MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k,
					MaxTotalRDBandwidthNoUrgentBurst);
#endif
			if (v->DestinationLinesForPrefetch[k] < 2)
				DestinationLineTimesForPrefetchLessThan2 = true;

			if (v->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE__
					|| v->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE__)
				VRatioPrefetchMoreThanMax = true;

			//bool DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
			//bool DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
			//if (v->DestinationLinesToRequestVMInVBlank[k] >= 32) {
			//    DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
			//}

			//if (v->DestinationLinesToRequestRowInVBlank[k] >= 16) {
			//    DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
			//}
		}

		v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / mode_lib->vba.ReturnBW;

#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f\n",
				__func__, MaxTotalRDBandwidthNoUrgentBurst);
		dml_print("DML::%s: ReturnBW=%f\n", __func__, mode_lib->vba.ReturnBW);
		dml_print("DML::%s: FractionOfUrgentBandwidth=%f\n",
				__func__, mode_lib->vba.FractionOfUrgentBandwidth);
#endif

		{
			dml32_CalculatePrefetchBandwithSupport(
					mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.ReturnBW,
					v->NoUrgentLatencyHidingPre,
					v->ReadBandwidthSurfaceLuma,
					v->ReadBandwidthSurfaceChroma,
					v->RequiredPrefetchPixDataBWLuma,
					v->RequiredPrefetchPixDataBWChroma,
					v->cursor_bw,
					v->meta_row_bw,
					v->dpte_row_bw,
					v->cursor_bw_pre,
					v->prefetch_vmrow_bw,
					mode_lib->vba.DPPPerPlane,
					v->UrgBurstFactorLuma,
					v->UrgBurstFactorChroma,
					v->UrgBurstFactorCursor,
					v->UrgBurstFactorLumaPre,
					v->UrgBurstFactorChromaPre,
					v->UrgBurstFactorCursorPre,

					/* output */
					&MaxTotalRDBandwidth,
					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
					&v->PrefetchModeSupported);
		}

		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector[k] = 1.0;

		{
			dml32_CalculatePrefetchBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.ReturnBW,
					v->NoUrgentLatencyHidingPre,
					v->ReadBandwidthSurfaceLuma,
					v->ReadBandwidthSurfaceChroma,
					v->RequiredPrefetchPixDataBWLuma,
					v->RequiredPrefetchPixDataBWChroma,
					v->cursor_bw,
					v->meta_row_bw,
					v->dpte_row_bw,
					v->cursor_bw_pre,
					v->prefetch_vmrow_bw,
					mode_lib->vba.DPPPerPlane,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,

					/* output */
					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
					&v->FractionOfUrgentBandwidth,
					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
		}

		if (VRatioPrefetchMoreThanMax != false || DestinationLineTimesForPrefetchLessThan2 != false) {
			v->PrefetchModeSupported = false;
		}

		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (v->ErrorResult[k] == true || v->NotEnoughTimeForDynamicMetadata[k]) {
				v->PrefetchModeSupported = false;
			}
		}

		if (v->PrefetchModeSupported == true && mode_lib->vba.ImmediateFlipSupport == true) {
			mode_lib->vba.BandwidthAvailableForImmediateFlip = dml32_CalculateBandwidthAvailableForImmediateFlip(
					mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.ReturnBW,
					v->ReadBandwidthSurfaceLuma,
					v->ReadBandwidthSurfaceChroma,
					v->RequiredPrefetchPixDataBWLuma,
					v->RequiredPrefetchPixDataBWChroma,
					v->cursor_bw,
					v->cursor_bw_pre,
					mode_lib->vba.DPPPerPlane,
					v->UrgBurstFactorLuma,
					v->UrgBurstFactorChroma,
					v->UrgBurstFactorCursor,
					v->UrgBurstFactorLumaPre,
					v->UrgBurstFactorChromaPre,
					v->UrgBurstFactorCursorPre);

			mode_lib->vba.TotImmediateFlipBytes = 0;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) {
					mode_lib->vba.TotImmediateFlipBytes = mode_lib->vba.TotImmediateFlipBytes
							+ mode_lib->vba.DPPPerPlane[k]
									* (v->PDEAndMetaPTEBytesFrame[k]
											+ v->MetaRowByte[k]);
					if (v->use_one_row_for_frame_flip[k][0][0]) {
						mode_lib->vba.TotImmediateFlipBytes =
								mode_lib->vba.TotImmediateFlipBytes
										+ 2 * v->PixelPTEBytesPerRow[k];
					} else {
						mode_lib->vba.TotImmediateFlipBytes =
								mode_lib->vba.TotImmediateFlipBytes
										+ v->PixelPTEBytesPerRow[k];
					}
				}
			}
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				dml32_CalculateFlipSchedule(v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
						v->UrgentExtraLatency,
						v->UrgentLatency,
						mode_lib->vba.GPUVMMaxPageTableLevels,
						mode_lib->vba.HostVMEnable,
						mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
						mode_lib->vba.GPUVMEnable,
						mode_lib->vba.HostVMMinPageSize,
						v->PDEAndMetaPTEBytesFrame[k],
						v->MetaRowByte[k],
						v->PixelPTEBytesPerRow[k],
						mode_lib->vba.BandwidthAvailableForImmediateFlip,
						mode_lib->vba.TotImmediateFlipBytes,
						mode_lib->vba.SourcePixelFormat[k],
						mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
						mode_lib->vba.VRatio[k],
						mode_lib->vba.VRatioChroma[k],
						v->Tno_bw[k],
						mode_lib->vba.DCCEnable[k],
						v->dpte_row_height[k],
						v->meta_row_height[k],
						v->dpte_row_height_chroma[k],
						v->meta_row_height_chroma[k],
						v->Use_One_Row_For_Frame_Flip[k],

						/* Output */
						&v->DestinationLinesToRequestVMInImmediateFlip[k],
						&v->DestinationLinesToRequestRowInImmediateFlip[k],
						&v->final_flip_bw[k],
						&v->ImmediateFlipSupportedForPipe[k]);
			}

			{
				dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
						mode_lib->vba.ReturnBW,
						mode_lib->vba.ImmediateFlipRequirement,
						v->final_flip_bw,
						v->ReadBandwidthSurfaceLuma,
						v->ReadBandwidthSurfaceChroma,
						v->RequiredPrefetchPixDataBWLuma,
						v->RequiredPrefetchPixDataBWChroma,
						v->cursor_bw,
						v->meta_row_bw,
						v->dpte_row_bw,
						v->cursor_bw_pre,
						v->prefetch_vmrow_bw,
						mode_lib->vba.DPPPerPlane,
						v->UrgBurstFactorLuma,
						v->UrgBurstFactorChroma,
						v->UrgBurstFactorCursor,
						v->UrgBurstFactorLumaPre,
						v->UrgBurstFactorChromaPre,
						v->UrgBurstFactorCursorPre,

						/* output */
						&v->total_dcn_read_bw_with_flip,    // Single  *TotalBandwidth
						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],                        // Single  *FractionOfUrgentBandwidth
						&v->ImmediateFlipSupported);        // Boolean *ImmediateFlipBandwidthSupport

				dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
						mode_lib->vba.ReturnBW,
						mode_lib->vba.ImmediateFlipRequirement,
						v->final_flip_bw,
						v->ReadBandwidthSurfaceLuma,
						v->ReadBandwidthSurfaceChroma,
						v->RequiredPrefetchPixDataBWLuma,
						v->RequiredPrefetchPixDataBWChroma,
						v->cursor_bw,
						v->meta_row_bw,
						v->dpte_row_bw,
						v->cursor_bw_pre,
						v->prefetch_vmrow_bw,
						mode_lib->vba.DPPPerPlane,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,

						/* output */
						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],                                // Single  *TotalBandwidth
						&v->FractionOfUrgentBandwidthImmediateFlip, // Single  *FractionOfUrgentBandwidth
						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);                              // Boolean *ImmediateFlipBandwidthSupport
			}

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required && v->ImmediateFlipSupportedForPipe[k] == false) {
					v->ImmediateFlipSupported = false;
#ifdef __DML_VBA_DEBUG__
					dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
#endif
				}
			}
		} else {
			v->ImmediateFlipSupported = false;
		}

		/* consider flip support is okay if the flip bw is ok or (when user does't require a iflip and there is no host vm) */
		v->PrefetchAndImmediateFlipSupported = (v->PrefetchModeSupported == true &&
				((!mode_lib->vba.ImmediateFlipSupport && !mode_lib->vba.HostVMEnable && !ImmediateFlipRequirementFinal) ||
						v->ImmediateFlipSupported)) ? true : false;

#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: PrefetchModeSupported = %d\n", __func__, locals->PrefetchModeSupported);
		for (uint k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
			dml_print("DML::%s: ImmediateFlipRequirement[%d] = %d\n", __func__, k,  mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
		dml_print("DML::%s: ImmediateFlipSupported = %d\n", __func__, locals->ImmediateFlipSupported);
		dml_print("DML::%s: ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
		dml_print("DML::%s: HostVMEnable = %d\n", __func__, mode_lib->vba.HostVMEnable);
		dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %d\n", __func__, locals->PrefetchAndImmediateFlipSupported);
		dml_print("DML::%s: Done loop: Vstartup=%d, Max Vstartup=%d\n", __func__, locals->VStartupLines, locals->MaximumMaxVStartupLines);
#endif

		v->VStartupLines = v->VStartupLines + 1;

		if (v->VStartupLines > v->MaximumMaxVStartupLines) {
#ifdef __DML_VBA_DEBUG__
			dml_print("DML::%s: Vstartup exceeds max vstartup, exiting loop\n", __func__);
#endif
			break; // VBA_DELTA: Implementation divergence! Gabe is *still* iterating across prefetch modes which we don't care to do
		}
		iteration++;
		if (iteration > 2500) {
#ifdef __DML_VBA_DEBUG__
			dml_print("DML::%s: too many errors, exit now\n", __func__);
			assert(0);
#endif
		}
	} while (!(v->PrefetchAndImmediateFlipSupported || NextPrefetchMode > mode_lib->vba.MaxPrefetchMode));


	if (v->VStartupLines <= v->MaximumMaxVStartupLines) {
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: Good, Prefetch and flip scheduling found solution at VStartupLines=%d\n", __func__, locals->VStartupLines-1);
#endif
	}


	//Watermarks and NB P-State/DRAM Clock Change Support
	{
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.UrgentLatency = v->UrgentLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.ExtraLatency = v->UrgentExtraLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;

		dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
			v,
			v->PrefetchModePerState[v->VoltageLevel][v->maxMpcComb],
			v->DCFCLK,
			v->ReturnBW,
			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters,
			v->SOCCLK,
			v->DCFCLKDeepSleep,
			v->DETBufferSizeY,
			v->DETBufferSizeC,
			v->SwathHeightY,
			v->SwathHeightC,
			v->SwathWidthY,
			v->SwathWidthC,
			v->DPPPerPlane,
			v->BytePerPixelDETY,
			v->BytePerPixelDETC,
			v->DSTXAfterScaler,
			v->DSTYAfterScaler,
			v->UnboundedRequestEnabled,
			v->CompressedBufferSizeInkByte,

			/* Output */
			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_dramchange_support,
			v->MaxActiveDRAMClockChangeLatencySupported,
			v->SubViewportLinesNeededInMALL,
			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_fclkchange_support,
			&v->MinActiveFCLKChangeLatencySupported,
			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_USRRetrainingSupport,
			mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);

		/* DCN32 has a new struct Watermarks (typedef) which is used to store
		 * calculated WM values. Copy over values from struct to vba varaibles
		 * to ensure that the DCN32 getters return the correct value.
		 */
		v->UrgentWatermark = v->Watermark.UrgentWatermark;
		v->WritebackUrgentWatermark = v->Watermark.WritebackUrgentWatermark;
		v->DRAMClockChangeWatermark = v->Watermark.DRAMClockChangeWatermark;
		v->WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark;
		v->StutterExitWatermark = v->Watermark.StutterExitWatermark;
		v->StutterEnterPlusExitWatermark = v->Watermark.StutterEnterPlusExitWatermark;
		v->Z8StutterExitWatermark = v->Watermark.Z8StutterExitWatermark;
		v->Z8StutterEnterPlusExitWatermark = v->Watermark.Z8StutterEnterPlusExitWatermark;

		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.WritebackEnable[k] == true) {
				v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
						v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
								- v->Watermark.WritebackDRAMClockChangeWatermark);
				v->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0,
						v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
								- v->Watermark.WritebackFCLKChangeWatermark);
			} else {
				v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
				v->WritebackAllowFCLKChangeEndPosition[k] = 0;
			}
		}
	}

	//Display Pipeline Delivery Time in Prefetch, Groups
	dml32_CalculatePixelDeliveryTimes(
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.VRatio,
			mode_lib->vba.VRatioChroma,
			v->VRatioPrefetchY,
			v->VRatioPrefetchC,
			v->swath_width_luma_ub,
			v->swath_width_chroma_ub,
			mode_lib->vba.DPPPerPlane,
			mode_lib->vba.HRatio,
			mode_lib->vba.HRatioChroma,
			mode_lib->vba.PixelClock,
			v->PSCL_THROUGHPUT_LUMA,
			v->PSCL_THROUGHPUT_CHROMA,
			mode_lib->vba.DPPCLK,
			v->BytePerPixelC,
			mode_lib->vba.SourceRotation,
			mode_lib->vba.NumberOfCursors,
			mode_lib->vba.CursorWidth,
			mode_lib->vba.CursorBPP,
			v->BlockWidth256BytesY,
			v->BlockHeight256BytesY,
			v->BlockWidth256BytesC,
			v->BlockHeight256BytesC,

			/* Output */
			v->DisplayPipeLineDeliveryTimeLuma,
			v->DisplayPipeLineDeliveryTimeChroma,
			v->DisplayPipeLineDeliveryTimeLumaPrefetch,
			v->DisplayPipeLineDeliveryTimeChromaPrefetch,
			v->DisplayPipeRequestDeliveryTimeLuma,
			v->DisplayPipeRequestDeliveryTimeChroma,
			v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
			v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
			v->CursorRequestDeliveryTime,
			v->CursorRequestDeliveryTimePrefetch);

	dml32_CalculateMetaAndPTETimes(v->Use_One_Row_For_Frame,
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.GPUVMEnable,
			mode_lib->vba.MetaChunkSize,
			mode_lib->vba.MinMetaChunkSizeBytes,
			mode_lib->vba.HTotal,
			mode_lib->vba.VRatio,
			mode_lib->vba.VRatioChroma,
			v->DestinationLinesToRequestRowInVBlank,
			v->DestinationLinesToRequestRowInImmediateFlip,
			mode_lib->vba.DCCEnable,
			mode_lib->vba.PixelClock,
			v->BytePerPixelY,
			v->BytePerPixelC,
			mode_lib->vba.SourceRotation,
			v->dpte_row_height,
			v->dpte_row_height_chroma,
			v->meta_row_width,
			v->meta_row_width_chroma,
			v->meta_row_height,
			v->meta_row_height_chroma,
			v->meta_req_width,
			v->meta_req_width_chroma,
			v->meta_req_height,
			v->meta_req_height_chroma,
			v->dpte_group_bytes,
			v->PTERequestSizeY,
			v->PTERequestSizeC,
			v->PixelPTEReqWidthY,
			v->PixelPTEReqHeightY,
			v->PixelPTEReqWidthC,
			v->PixelPTEReqHeightC,
			v->dpte_row_width_luma_ub,
			v->dpte_row_width_chroma_ub,

			/* Output */
			v->DST_Y_PER_PTE_ROW_NOM_L,
			v->DST_Y_PER_PTE_ROW_NOM_C,
			v->DST_Y_PER_META_ROW_NOM_L,
			v->DST_Y_PER_META_ROW_NOM_C,
			v->TimePerMetaChunkNominal,
			v->TimePerChromaMetaChunkNominal,
			v->TimePerMetaChunkVBlank,
			v->TimePerChromaMetaChunkVBlank,
			v->TimePerMetaChunkFlip,
			v->TimePerChromaMetaChunkFlip,
			v->time_per_pte_group_nom_luma,
			v->time_per_pte_group_vblank_luma,
			v->time_per_pte_group_flip_luma,
			v->time_per_pte_group_nom_chroma,
			v->time_per_pte_group_vblank_chroma,
			v->time_per_pte_group_flip_chroma);

	dml32_CalculateVMGroupAndRequestTimes(
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.GPUVMEnable,
			mode_lib->vba.GPUVMMaxPageTableLevels,
			mode_lib->vba.HTotal,
			v->BytePerPixelC,
			v->DestinationLinesToRequestVMInVBlank,
			v->DestinationLinesToRequestVMInImmediateFlip,
			mode_lib->vba.DCCEnable,
			mode_lib->vba.PixelClock,
			v->dpte_row_width_luma_ub,
			v->dpte_row_width_chroma_ub,
			v->vm_group_bytes,
			v->dpde0_bytes_per_frame_ub_l,
			v->dpde0_bytes_per_frame_ub_c,
			v->meta_pte_bytes_per_frame_ub_l,
			v->meta_pte_bytes_per_frame_ub_c,

			/* Output */
			v->TimePerVMGroupVBlank,
			v->TimePerVMGroupFlip,
			v->TimePerVMRequestVBlank,
			v->TimePerVMRequestFlip);

	// Min TTUVBlank
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
			v->MinTTUVBlank[k] = dml_max4(v->Watermark.DRAMClockChangeWatermark,
					v->Watermark.FCLKChangeWatermark, v->Watermark.StutterEnterPlusExitWatermark,
					v->Watermark.UrgentWatermark);
		} else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
				== 1) {
			v->MinTTUVBlank[k] = dml_max3(v->Watermark.FCLKChangeWatermark,
					v->Watermark.StutterEnterPlusExitWatermark, v->Watermark.UrgentWatermark);
		} else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
				== 2) {
			v->MinTTUVBlank[k] = dml_max(v->Watermark.StutterEnterPlusExitWatermark,
					v->Watermark.UrgentWatermark);
		} else {
			v->MinTTUVBlank[k] = v->Watermark.UrgentWatermark;
		}
		if (!mode_lib->vba.DynamicMetadataEnable[k])
			v->MinTTUVBlank[k] = mode_lib->vba.TCalc + v->MinTTUVBlank[k];
	}

	// DCC Configuration
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: Calculate DCC configuration for surface k=%d\n", __func__, k);
#endif
		dml32_CalculateDCCConfiguration(
				mode_lib->vba.DCCEnable[k],
				mode_lib->vba.DCCProgrammingAssumesScanDirectionUnknownFinal,
				mode_lib->vba.SourcePixelFormat[k], mode_lib->vba.SurfaceWidthY[k],
				mode_lib->vba.SurfaceWidthC[k],
				mode_lib->vba.SurfaceHeightY[k],
				mode_lib->vba.SurfaceHeightC[k],
				mode_lib->vba.nomDETInKByte,
				v->BlockHeight256BytesY[k],
				v->BlockHeight256BytesC[k],
				mode_lib->vba.SurfaceTiling[k],
				v->BytePerPixelY[k],
				v->BytePerPixelC[k],
				v->BytePerPixelDETY[k],
				v->BytePerPixelDETC[k],
				(enum dm_rotation_angle) mode_lib->vba.SourceScan[k],
				/* Output */
				&v->DCCYMaxUncompressedBlock[k],
				&v->DCCCMaxUncompressedBlock[k],
				&v->DCCYMaxCompressedBlock[k],
				&v->DCCCMaxCompressedBlock[k],
				&v->DCCYIndependentBlock[k],
				&v->DCCCIndependentBlock[k]);
	}

	// VStartup Adjustment
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		bool isInterlaceTiming;
		double Tvstartup_margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * mode_lib->vba.HTotal[k]
				/ mode_lib->vba.PixelClock[k];
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: k=%d, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k,
				v->MinTTUVBlank[k]);
#endif

		v->MinTTUVBlank[k] = v->MinTTUVBlank[k] + Tvstartup_margin;

#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: k=%d, Tvstartup_margin = %f\n", __func__, k, Tvstartup_margin);
		dml_print("DML::%s: k=%d, MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
		dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
		dml_print("DML::%s: k=%d, MinTTUVBlank = %f\n", __func__, k, v->MinTTUVBlank[k]);
#endif

		v->Tdmdl[k] = v->Tdmdl[k] + Tvstartup_margin;
		if (mode_lib->vba.DynamicMetadataEnable[k] && mode_lib->vba.DynamicMetadataVMEnabled)
			v->Tdmdl_vm[k] = v->Tdmdl_vm[k] + Tvstartup_margin;

		isInterlaceTiming = (mode_lib->vba.Interlace[k] &&
				!mode_lib->vba.ProgressiveToInterlaceUnitInOPP);

		v->MIN_DST_Y_NEXT_START[k] = ((isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k] -
						mode_lib->vba.VFrontPorch[k]) / 2.0, 1.0) :
						mode_lib->vba.VTotal[k]) - mode_lib->vba.VFrontPorch[k])
						+ dml_max(1.0,
						dml_ceil(v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
						/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0))
						+ dml_floor(4.0 * v->TSetup[k] / (mode_lib->vba.HTotal[k]
						/ mode_lib->vba.PixelClock[k]), 1.0) / 4.0;

		v->VStartup[k] = (isInterlaceTiming ? (2 * v->MaxVStartupLines[k]) : v->MaxVStartupLines[k]);

		if (((v->VUpdateOffsetPix[k] + v->VUpdateWidthPix[k] + v->VReadyOffsetPix[k])
			/ mode_lib->vba.HTotal[k]) <= (isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k]
			- mode_lib->vba.VActive[k] - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]) / 2.0, 1.0) :
			(int) (mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
		       - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]))) {
			v->VREADY_AT_OR_AFTER_VSYNC[k] = true;
		} else {
			v->VREADY_AT_OR_AFTER_VSYNC[k] = false;
		}
#ifdef __DML_VBA_DEBUG__
		dml_print("DML::%s: k=%d, VStartup = %d (max)\n", __func__, k, v->VStartup[k]);
		dml_print("DML::%s: k=%d, VUpdateOffsetPix = %d\n", __func__, k, v->VUpdateOffsetPix[k]);
		dml_print("DML::%s: k=%d, VUpdateWidthPix = %d\n", __func__, k, v->VUpdateWidthPix[k]);
		dml_print("DML::%s: k=%d, VReadyOffsetPix = %d\n", __func__, k, v->VReadyOffsetPix[k]);
		dml_print("DML::%s: k=%d, HTotal = %d\n", __func__, k, mode_lib->vba.HTotal[k]);
		dml_print("DML::%s: k=%d, VTotal = %d\n", __func__, k, mode_lib->vba.VTotal[k]);
		dml_print("DML::%s: k=%d, VActive = %d\n", __func__, k, mode_lib->vba.VActive[k]);
		dml_print("DML::%s: k=%d, VFrontPorch = %d\n", __func__, k, mode_lib->vba.VFrontPorch[k]);
		dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
		dml_print("DML::%s: k=%d, TSetup = %f\n", __func__, k, v->TSetup[k]);
		dml_print("DML::%s: k=%d, MIN_DST_Y_NEXT_START = %f\n", __func__, k, v->MIN_DST_Y_NEXT_START[k]);
		dml_print("DML::%s: k=%d, VREADY_AT_OR_AFTER_VSYNC = %d\n", __func__, k,
				v->VREADY_AT_OR_AFTER_VSYNC[k]);
#endif
	}

	{
		//Maximum Bandwidth Used
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.WritebackEnable[k] == true
					&& mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
				WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
						* mode_lib->vba.WritebackDestinationHeight[k]
						/ (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
								/ mode_lib->vba.PixelClock[k]) * 4;
			} else if (mode_lib->vba.WritebackEnable[k] == true) {
				WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
						* mode_lib->vba.WritebackDestinationHeight[k]
						/ (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
								/ mode_lib->vba.PixelClock[k]) * 8;
			}
			TotalWRBandwidth = TotalWRBandwidth + WRBandwidth;
		}

		v->TotalDataReadBandwidth = 0;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			v->TotalDataReadBandwidth = v->TotalDataReadBandwidth + v->ReadBandwidthSurfaceLuma[k]
					+ v->ReadBandwidthSurfaceChroma[k];
#ifdef __DML_VBA_DEBUG__
			dml_print("DML::%s: k=%d, TotalDataReadBandwidth = %f\n",
					__func__, k, v->TotalDataReadBandwidth);
			dml_print("DML::%s: k=%d, ReadBandwidthSurfaceLuma = %f\n",
					__func__, k, v->ReadBandwidthSurfaceLuma[k]);
			dml_print("DML::%s: k=%d, ReadBandwidthSurfaceChroma = %f\n",
					__func__, k, v->ReadBandwidthSurfaceChroma[k]);
#endif
		}
	}

	// Stutter Efficiency
	dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
			mode_lib->vba.UsesMALLForPStateChange,
			v->UnboundedRequestEnabled,
			mode_lib->vba.MetaFIFOSizeInKEntries,
			mode_lib->vba.ZeroSizeBufferEntries,
			mode_lib->vba.PixelChunkSizeInKByte,
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.ROBBufferSizeInKByte,
			v->TotalDataReadBandwidth,
			mode_lib->vba.DCFCLK,
			mode_lib->vba.ReturnBW,
			v->CompbufReservedSpace64B,
			v->CompbufReservedSpaceZs,
			mode_lib->vba.SRExitTime,
			mode_lib->vba.SRExitZ8Time,
			mode_lib->vba.SynchronizeTimingsFinal,
			mode_lib->vba.BlendingAndTiming,
			v->Watermark.StutterEnterPlusExitWatermark,
			v->Watermark.Z8StutterEnterPlusExitWatermark,
			mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
			mode_lib->vba.Interlace,
			v->MinTTUVBlank, mode_lib->vba.DPPPerPlane,
			mode_lib->vba.DETBufferSizeY,
			v->BytePerPixelY,
			v->BytePerPixelDETY,
			v->SwathWidthY,
			mode_lib->vba.SwathHeightY,
			mode_lib->vba.SwathHeightC,
			mode_lib->vba.DCCRateLuma,
			mode_lib->vba.DCCRateChroma,
			mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
			mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
			mode_lib->vba.HTotal, mode_lib->vba.VTotal,
			mode_lib->vba.PixelClock,
			mode_lib->vba.VRatio,
			mode_lib->vba.SourceRotation,
			v->BlockHeight256BytesY,
			v->BlockWidth256BytesY,
			v->BlockHeight256BytesC,
			v->BlockWidth256BytesC,
			v->DCCYMaxUncompressedBlock,
			v->DCCCMaxUncompressedBlock,
			mode_lib->vba.VActive,
			mode_lib->vba.DCCEnable,
			mode_lib->vba.WritebackEnable,
			v->ReadBandwidthSurfaceLuma,
			v->ReadBandwidthSurfaceChroma,
			v->meta_row_bw,
			v->dpte_row_bw,
			/* Output */
			&v->StutterEfficiencyNotIncludingVBlank,
			&v->StutterEfficiency,
			&v->NumberOfStutterBurstsPerFrame,
			&v->Z8StutterEfficiencyNotIncludingVBlank,
			&v->Z8StutterEfficiency,
			&v->Z8NumberOfStutterBurstsPerFrame,
			&v->StutterPeriod,
			&v->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);

#ifdef __DML_VBA_ALLOW_DELTA__
	{
		unsigned int dummy_integer[1];

		// Calculate z8 stutter eff assuming 0 reserved space
		dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
				mode_lib->vba.UsesMALLForPStateChange,
				v->UnboundedRequestEnabled,
				mode_lib->vba.MetaFIFOSizeInKEntries,
				mode_lib->vba.ZeroSizeBufferEntries,
				mode_lib->vba.PixelChunkSizeInKByte,
				mode_lib->vba.NumberOfActiveSurfaces,
				mode_lib->vba.ROBBufferSizeInKByte,
				v->TotalDataReadBandwidth,
				mode_lib->vba.DCFCLK,
				mode_lib->vba.ReturnBW,
				0, //CompbufReservedSpace64B,
				0, //CompbufReservedSpaceZs,
				mode_lib->vba.SRExitTime,
				mode_lib->vba.SRExitZ8Time,
				mode_lib->vba.SynchronizeTimingsFinal,
				mode_lib->vba.BlendingAndTiming,
				v->Watermark.StutterEnterPlusExitWatermark,
				v->Watermark.Z8StutterEnterPlusExitWatermark,
				mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
				mode_lib->vba.Interlace,
				v->MinTTUVBlank,
				mode_lib->vba.DPPPerPlane,
				mode_lib->vba.DETBufferSizeY,
				v->BytePerPixelY, v->BytePerPixelDETY,
				v->SwathWidthY, mode_lib->vba.SwathHeightY,
				mode_lib->vba.SwathHeightC,
				mode_lib->vba.DCCRateLuma,
				mode_lib->vba.DCCRateChroma,
				mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
				mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
				mode_lib->vba.HTotal,
				mode_lib->vba.VTotal,
				mode_lib->vba.PixelClock,
				mode_lib->vba.VRatio,
				mode_lib->vba.SourceRotation,
				v->BlockHeight256BytesY,
				v->BlockWidth256BytesY,
				v->BlockHeight256BytesC,
				v->BlockWidth256BytesC,
				v->DCCYMaxUncompressedBlock,
				v->DCCCMaxUncompressedBlock,
				mode_lib->vba.VActive,
				mode_lib->vba.DCCEnable,
				mode_lib->vba.WritebackEnable,
				v->ReadBandwidthSurfaceLuma,
				v->ReadBandwidthSurfaceChroma,
				v->meta_row_bw, v->dpte_row_bw,

				/* Output */
				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],
				&dummy_integer[0],
				&v->Z8StutterEfficiencyNotIncludingVBlankBestCase,
				&v->Z8StutterEfficiencyBestCase,
				&v->Z8NumberOfStutterBurstsPerFrameBestCase,
				&v->StutterPeriodBestCase,
				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
	}
#else
	v->Z8StutterEfficiencyNotIncludingVBlankBestCase = v->Z8StutterEfficiencyNotIncludingVBlank;
	v->Z8StutterEfficiencyBestCase = v->Z8StutterEfficiency;
	v->Z8NumberOfStutterBurstsPerFrameBestCase = v->Z8NumberOfStutterBurstsPerFrame;
	v->StutterPeriodBestCase = v->StutterPeriod;
#endif

#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: --- END ---\n", __func__);
#endif
}

static void mode_support_configuration(struct vba_vars_st *v,
				  struct display_mode_lib *mode_lib)
{
	int i, j;

	for (i = v->soc.num_states - 1; i >= 0; i--) {
		for (j = 0; j < 2; j++) {
			if (mode_lib->vba.ScaleRatioAndTapsSupport == true
				&& mode_lib->vba.SourceFormatPixelAndScanSupport == true
				&& mode_lib->vba.ViewportSizeSupport[i][j] == true
				&& !mode_lib->vba.LinkRateDoesNotMatchDPVersion
				&& !mode_lib->vba.LinkRateForMultistreamNotIndicated
				&& !mode_lib->vba.BPPForMultistreamNotIndicated
				&& !mode_lib->vba.MultistreamWithHDMIOreDP
				&& !mode_lib->vba.ExceededMultistreamSlots[i]
				&& !mode_lib->vba.MSOOrODMSplitWithNonDPLink
				&& !mode_lib->vba.NotEnoughLanesForMSO
				&& mode_lib->vba.LinkCapacitySupport[i] == true && !mode_lib->vba.P2IWith420
				&& !mode_lib->vba.DSCOnlyIfNecessaryWithBPP
				&& !mode_lib->vba.DSC422NativeNotSupported
				&& !mode_lib->vba.MPCCombineMethodIncompatible
				&& mode_lib->vba.ODMCombine2To1SupportCheckOK[i] == true
				&& mode_lib->vba.ODMCombine4To1SupportCheckOK[i] == true
				&& mode_lib->vba.NotEnoughDSCUnits[i] == false
				&& !mode_lib->vba.NotEnoughDSCSlices[i]
				&& !mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
				&& !mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
				&& mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] == false
				&& mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i]
				&& mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] == false
				&& !mode_lib->vba.InvalidCombinationOfMALLUseForPState
				&& !mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
				&& mode_lib->vba.ROBSupport[i][j] == true
				&& mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] == true
				&& mode_lib->vba.TotalAvailablePipesSupport[i][j] == true
				&& mode_lib->vba.NumberOfOTGSupport == true
				&& mode_lib->vba.NumberOfHDMIFRLSupport == true
				&& mode_lib->vba.EnoughWritebackUnits == true
				&& mode_lib->vba.WritebackLatencySupport == true
				&& mode_lib->vba.WritebackScaleRatioAndTapsSupport == true
				&& mode_lib->vba.CursorSupport == true && mode_lib->vba.PitchSupport == true
				&& mode_lib->vba.ViewportExceedsSurface == false
				&& mode_lib->vba.PrefetchSupported[i][j] == true
				&& mode_lib->vba.VActiveBandwithSupport[i][j] == true
				&& mode_lib->vba.DynamicMetadataSupported[i][j] == true
				&& mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] == true
				&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true
				&& mode_lib->vba.PTEBufferSizeNotExceeded[i][j] == true
				&& mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] == true
				&& mode_lib->vba.NonsupportedDSCInputBPC == false
				&& !mode_lib->vba.ExceededMALLSize
				&& ((mode_lib->vba.HostVMEnable == false
				&& !mode_lib->vba.ImmediateFlipRequiredFinal)
				|| mode_lib->vba.ImmediateFlipSupportedForState[i][j])
				&& (!mode_lib->vba.DRAMClockChangeRequirementFinal
				|| i == v->soc.num_states - 1
				|| mode_lib->vba.DRAMClockChangeSupport[i][j] != dm_dram_clock_change_unsupported)
				&& (!mode_lib->vba.FCLKChangeRequirementFinal || i == v->soc.num_states - 1
				|| mode_lib->vba.FCLKChangeSupport[i][j] != dm_fclock_change_unsupported)
				&& (!mode_lib->vba.USRRetrainingRequiredFinal
				|| mode_lib->vba.USRRetrainingSupport[i][j])) {
				mode_lib->vba.ModeSupport[i][j] = true;
			} else {
				mode_lib->vba.ModeSupport[i][j] = false;
			}
		}
	}
}

void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
{
	struct vba_vars_st *v = &mode_lib->vba;
	int i, j;
	unsigned int k, m;
	unsigned int MaximumMPCCombine;
	unsigned int NumberOfNonCombinedSurfaceOfMaximumBandwidth;
	unsigned int TotalSlots;
	bool CompBufReservedSpaceNeedAdjustment;
	bool CompBufReservedSpaceNeedAdjustmentSingleDPP;

#ifdef __DML_VBA_DEBUG__
	dml_print("DML::%s: called\n", __func__);
#endif

	/*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/

	/*Scale Ratio, taps Support Check*/

	mode_lib->vba.ScaleRatioAndTapsSupport = true;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 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.SourcePixelFormat[k] != dm_rgbe
						&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha)
						|| 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.SourcePixelFormat[k] != dm_rgbe
						&& (mode_lib->vba.VTAPsChroma[k] < 1
								|| mode_lib->vba.VTAPsChroma[k] > 8
								|| mode_lib->vba.HTAPsChroma[k] < 1
								|| mode_lib->vba.HTAPsChroma[k] > 8
								|| (mode_lib->vba.HTAPsChroma[k] > 1
										&& mode_lib->vba.HTAPsChroma[k] % 2
												== 1)
								|| mode_lib->vba.HRatioChroma[k]
										> mode_lib->vba.MaxHSCLRatio
								|| mode_lib->vba.VRatioChroma[k]
										> mode_lib->vba.MaxVSCLRatio
								|| mode_lib->vba.HRatioChroma[k]
										> mode_lib->vba.HTAPsChroma[k]
								|| mode_lib->vba.VRatioChroma[k]
										> 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.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
			&& (!(!IsVertical((enum dm_rotation_angle) mode_lib->vba.SourceScan[k]))
				|| mode_lib->vba.DCCEnable[k] == true)) {
			mode_lib->vba.SourceFormatPixelAndScanSupport = false;
		}
	}

	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		dml32_CalculateBytePerPixelAndBlockSizes(
				mode_lib->vba.SourcePixelFormat[k],
				mode_lib->vba.SurfaceTiling[k],

				/* Output */
				&mode_lib->vba.BytePerPixelY[k],
				&mode_lib->vba.BytePerPixelC[k],
				&mode_lib->vba.BytePerPixelInDETY[k],
				&mode_lib->vba.BytePerPixelInDETC[k],
				&mode_lib->vba.Read256BlockHeightY[k],
				&mode_lib->vba.Read256BlockHeightC[k],
				&mode_lib->vba.Read256BlockWidthY[k],
				&mode_lib->vba.Read256BlockWidthC[k],
				&mode_lib->vba.MacroTileHeightY[k],
				&mode_lib->vba.MacroTileHeightC[k],
				&mode_lib->vba.MacroTileWidthY[k],
				&mode_lib->vba.MacroTileWidthC[k]);
	}

	/*Bandwidth Support Check*/
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (!IsVertical(mode_lib->vba.SourceRotation[k])) {
			v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
			v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportWidthChroma[k];
		} else {
			v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
			v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportHeightChroma[k];
		}
	}
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0)
				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
		v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0)
				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]
				/ 2.0;
	}
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.WritebackEnable[k] == true && mode_lib->vba.WritebackPixelFormat[k] == dm_444_64) {
			v->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]) * 8.0;
		} else if (mode_lib->vba.WritebackEnable[k] == true) {
			v->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 {
			v->WriteBandwidth[k] = 0.0;
		}
	}

	/*Writeback Latency support check*/

	mode_lib->vba.WritebackLatencySupport = true;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.WritebackEnable[k] == true
				&& (v->WriteBandwidth[k]
						> mode_lib->vba.WritebackInterfaceBufferSize * 1024
								/ mode_lib->vba.WritebackLatency)) {
			mode_lib->vba.WritebackLatencySupport = false;
		}
	}

	/*Writeback Mode Support Check*/
	mode_lib->vba.EnoughWritebackUnits = true;
	mode_lib->vba.TotalNumberOfActiveWriteback = 0;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.WritebackEnable[k] == true)
			mode_lib->vba.TotalNumberOfActiveWriteback = mode_lib->vba.TotalNumberOfActiveWriteback + 1;
	}

	if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback)
		mode_lib->vba.EnoughWritebackUnits = false;

	/*Writeback Scale Ratio and Taps Support Check*/
	mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.WritebackEnable[k] == true) {
			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.WritebackHTaps[k] > mode_lib->vba.WritebackMaxHSCLTaps
					|| mode_lib->vba.WritebackVTaps[k] > mode_lib->vba.WritebackMaxVSCLTaps
					|| mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackHTaps[k]
					|| mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackVTaps[k]
					|| (mode_lib->vba.WritebackHTaps[k] > 2.0
							&& ((mode_lib->vba.WritebackHTaps[k] % 2) == 1))) {
				mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
			}
			if (2.0 * mode_lib->vba.WritebackDestinationWidth[k] * (mode_lib->vba.WritebackVTaps[k] - 1)
					* 57 > mode_lib->vba.WritebackLineBufferSize) {
				mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
			}
		}
	}

	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k], mode_lib->vba.HRatioChroma[k],
				mode_lib->vba.VRatio[k], mode_lib->vba.VRatioChroma[k],
				mode_lib->vba.MaxDCHUBToPSCLThroughput, mode_lib->vba.MaxPSCLToLBThroughput,
				mode_lib->vba.PixelClock[k], mode_lib->vba.SourcePixelFormat[k],
				mode_lib->vba.htaps[k], mode_lib->vba.HTAPsChroma[k], mode_lib->vba.vtaps[k],
				mode_lib->vba.VTAPsChroma[k],
				/* Output */
				&mode_lib->vba.PSCL_FACTOR[k], &mode_lib->vba.PSCL_FACTOR_CHROMA[k],
				&mode_lib->vba.MinDPPCLKUsingSingleDPP[k]);
	}

	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {

		if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 8192;
		} else if (!IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
				&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 7680;
		} else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
				&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 4320;
		} else if (mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3840;
		} else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelY[k] == 8 &&
				mode_lib->vba.DCCEnable[k] == true) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3072;
		} else {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 6144;
		}

		if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
				|| mode_lib->vba.SourcePixelFormat[k] == dm_420_12) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma / 2.0;
		} else {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma;
		}
		v->MaximumSwathWidthInLineBufferLuma = mode_lib->vba.LineBufferSizeFinal
				* 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));
		if (v->BytePerPixelC[k] == 0.0) {
			v->MaximumSwathWidthInLineBufferChroma = 0;
		} else {
			v->MaximumSwathWidthInLineBufferChroma = mode_lib->vba.LineBufferSizeFinal
					* dml_max(mode_lib->vba.HRatioChroma[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
					/ (mode_lib->vba.VTAPsChroma[k]
							+ dml_max(dml_ceil(mode_lib->vba.VRatioChroma[k], 1.0) - 2,
									0.0));
		}
		v->MaximumSwathWidthLuma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma,
				v->MaximumSwathWidthInLineBufferLuma);
		v->MaximumSwathWidthChroma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma,
				v->MaximumSwathWidthInLineBufferChroma);
	}

	dml32_CalculateSwathAndDETConfiguration(
			mode_lib->vba.DETSizeOverride,
			mode_lib->vba.UsesMALLForPStateChange,
			mode_lib->vba.ConfigReturnBufferSizeInKByte,
			mode_lib->vba.MaxTotalDETInKByte,
			mode_lib->vba.MinCompressedBufferSizeInKByte,
			1, /* ForceSingleDPP */
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.nomDETInKByte,
			mode_lib->vba.UseUnboundedRequesting,
			mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
			mode_lib->vba.ip.pixel_chunk_size_kbytes,
			mode_lib->vba.ip.rob_buffer_size_kbytes,
			mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
			mode_lib->vba.Output,
			mode_lib->vba.ReadBandwidthLuma,
			mode_lib->vba.ReadBandwidthChroma,
			mode_lib->vba.MaximumSwathWidthLuma,
			mode_lib->vba.MaximumSwathWidthChroma,
			mode_lib->vba.SourceRotation,
			mode_lib->vba.ViewportStationary,
			mode_lib->vba.SourcePixelFormat,
			mode_lib->vba.SurfaceTiling,
			mode_lib->vba.ViewportWidth,
			mode_lib->vba.ViewportHeight,
			mode_lib->vba.ViewportXStartY,
			mode_lib->vba.ViewportYStartY,
			mode_lib->vba.ViewportXStartC,
			mode_lib->vba.ViewportYStartC,
			mode_lib->vba.SurfaceWidthY,
			mode_lib->vba.SurfaceWidthC,
			mode_lib->vba.SurfaceHeightY,
			mode_lib->vba.SurfaceHeightC,
			mode_lib->vba.Read256BlockHeightY,
			mode_lib->vba.Read256BlockHeightC,
			mode_lib->vba.Read256BlockWidthY,
			mode_lib->vba.Read256BlockWidthC,
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_odm_mode,
			mode_lib->vba.BlendingAndTiming,
			mode_lib->vba.BytePerPixelY,
			mode_lib->vba.BytePerPixelC,
			mode_lib->vba.BytePerPixelInDETY,
			mode_lib->vba.BytePerPixelInDETC,
			mode_lib->vba.HActive,
			mode_lib->vba.HRatio,
			mode_lib->vba.HRatioChroma,
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0], /*  Integer DPPPerSurface[] */

			/* Output */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1], /* Long            swath_width_luma_ub[] */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2], /* Long            swath_width_chroma_ub[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[0], /* Long            SwathWidth[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[1], /* Long            SwathWidthChroma[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3], /* Integer         SwathHeightY[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4], /* Integer         SwathHeightC[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5], /* Long            DETBufferSizeInKByte[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6], /* Long            DETBufferSizeY[]  */
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7], /* Long            DETBufferSizeC[]  */
			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0][0], /* bool           *UnboundedRequestEnabled  */
			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0][0], /* Long           *CompressedBufferSizeInkByte  */
			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1][0], /* Long           *CompBufReservedSpaceKBytes */
			&CompBufReservedSpaceNeedAdjustmentSingleDPP,
			mode_lib->vba.SingleDPPViewportSizeSupportPerSurface,/* bool ViewportSizeSupportPerSurface[] */
			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1][0]); /* bool           *ViewportSizeSupport */

	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = false;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_reduce_voltage_and_clocks)
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
		if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_always_when_possible)
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = true;
	}
	mode_lib->vba.MPCCombineMethodIncompatible = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage
			&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible;

	for (i = 0; i < v->soc.num_states; i++) {
		for (j = 0; j < 2; j++) {
			mode_lib->vba.TotalNumberOfActiveDPP[i][j] = 0;
			mode_lib->vba.TotalAvailablePipesSupport[i][j] = true;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC = dm_odm_combine_mode_disabled;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC = dm_odm_combine_mode_disabled;

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				dml32_CalculateODMMode(
						mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
						mode_lib->vba.HActive[k],
						mode_lib->vba.Output[k],
						mode_lib->vba.ODMUse[k],
						mode_lib->vba.MaxDispclk[i],
						mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
						false,
						mode_lib->vba.TotalNumberOfActiveDPP[i][j],
						mode_lib->vba.MaxNumDPP,
						mode_lib->vba.PixelClock[k],
						mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
						mode_lib->vba.DISPCLKRampingMargin,
						mode_lib->vba.DISPCLKDPPCLKVCOSpeed,

						/* Output */
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC);

				dml32_CalculateODMMode(
						mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
						mode_lib->vba.HActive[k],
						mode_lib->vba.Output[k],
						mode_lib->vba.ODMUse[k],
						mode_lib->vba.MaxDispclk[i],
						mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
						true,
						mode_lib->vba.TotalNumberOfActiveDPP[i][j],
						mode_lib->vba.MaxNumDPP,
						mode_lib->vba.PixelClock[k],
						mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
						mode_lib->vba.DISPCLKRampingMargin,
						mode_lib->vba.DISPCLKDPPCLKVCOSpeed,

						/* Output */
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC);

				dml32_CalculateOutputLink(
						mode_lib->vba.PHYCLKPerState[i],
						mode_lib->vba.PHYCLKD18PerState[i],
						mode_lib->vba.PHYCLKD32PerState[i],
						mode_lib->vba.Downspreading,
						(mode_lib->vba.BlendingAndTiming[k] == k),
						mode_lib->vba.Output[k],
						mode_lib->vba.OutputFormat[k],
						mode_lib->vba.HTotal[k],
						mode_lib->vba.HActive[k],
						mode_lib->vba.PixelClockBackEnd[k],
						mode_lib->vba.ForcedOutputLinkBPP[k],
						mode_lib->vba.DSCInputBitPerComponent[k],
						mode_lib->vba.NumberOfDSCSlices[k],
						mode_lib->vba.AudioSampleRate[k],
						mode_lib->vba.AudioSampleLayout[k],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
						mode_lib->vba.DSCEnable[k],
						mode_lib->vba.OutputLinkDPLanes[k],
						mode_lib->vba.OutputLinkDPRate[k],

						/* Output */
						&mode_lib->vba.RequiresDSC[i][k],
						&mode_lib->vba.RequiresFEC[i][k],
						&mode_lib->vba.OutputBppPerState[i][k],
						&mode_lib->vba.OutputTypePerState[i][k],
						&mode_lib->vba.OutputRatePerState[i][k],
						&mode_lib->vba.RequiredSlots[i][k]);

				if (mode_lib->vba.RequiresDSC[i][k] == false) {
					mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC;
					mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC;
					if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC)
						mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC;
				} else {
					mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC;
					mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC;
					if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC)
						mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC;
				}
			}

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
					mode_lib->vba.MPCCombine[i][j][k] = false;
					mode_lib->vba.NoOfDPP[i][j][k] = 4;
				} else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
					mode_lib->vba.MPCCombine[i][j][k] = false;
					mode_lib->vba.NoOfDPP[i][j][k] = 2;
				} else if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_never) {
					mode_lib->vba.MPCCombine[i][j][k] = false;
					mode_lib->vba.NoOfDPP[i][j][k] = 1;
				} else if (dml32_RoundToDFSGranularity(
						mode_lib->vba.MinDPPCLKUsingSingleDPP[k]
								* (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
												/ 100), 1,
						mode_lib->vba.DISPCLKDPPCLKVCOSpeed) <= mode_lib->vba.MaxDppclk[i] &&
				mode_lib->vba.SingleDPPViewportSizeSupportPerSurface[k] == true) {
					mode_lib->vba.MPCCombine[i][j][k] = false;
					mode_lib->vba.NoOfDPP[i][j][k] = 1;
				} else if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP) {
					mode_lib->vba.MPCCombine[i][j][k] = true;
					mode_lib->vba.NoOfDPP[i][j][k] = 2;
					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
				} else {
					mode_lib->vba.MPCCombine[i][j][k] = false;
					mode_lib->vba.NoOfDPP[i][j][k] = 1;
					mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
				}
			}

			mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] = 0;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = true;

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.NoOfDPP[i][j][k] == 1)
					mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
							mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] + 1;
				if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
						|| mode_lib->vba.SourcePixelFormat[k] == dm_420_10
						|| mode_lib->vba.SourcePixelFormat[k] == dm_420_12
						|| mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = false;
				}
			}

			// if TotalNumberOfActiveDPP is > 1, then there should be no unbounded req mode (hw limitation), the comp buf reserved adjustment is not needed regardless
			// if TotalNumberOfActiveDPP is == 1, then will use the SingleDPP version of unbounded_req for the decision
			CompBufReservedSpaceNeedAdjustment = (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > 1) ? 0 : CompBufReservedSpaceNeedAdjustmentSingleDPP;


			if (j == 1 && !dml32_UnboundedRequest(mode_lib->vba.UseUnboundedRequesting,
					mode_lib->vba.TotalNumberOfActiveDPP[i][j], v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma,
					mode_lib->vba.Output[0],
					mode_lib->vba.SurfaceTiling[0],
					CompBufReservedSpaceNeedAdjustment,
					mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)) {
				while (!(mode_lib->vba.TotalNumberOfActiveDPP[i][j] >= mode_lib->vba.MaxNumDPP
						|| mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] == 0)) {
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
					NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;

					for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
						if (mode_lib->vba.MPCCombineUse[k]
							!= dm_mpc_never &&
							mode_lib->vba.MPCCombineUse[k] != dm_mpc_reduce_voltage &&
							mode_lib->vba.ReadBandwidthLuma[k] +
							mode_lib->vba.ReadBandwidthChroma[k] >
							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth &&
							(mode_lib->vba.ODMCombineEnablePerState[i][k] !=
							dm_odm_combine_mode_2to1 &&
							mode_lib->vba.ODMCombineEnablePerState[i][k] !=
							dm_odm_combine_mode_4to1) &&
								mode_lib->vba.MPCCombine[i][j][k] == false) {
							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth =
								mode_lib->vba.ReadBandwidthLuma[k]
								+ mode_lib->vba.ReadBandwidthChroma[k];
							NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
						}
					}
					mode_lib->vba.MPCCombine[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] =
							true;
					mode_lib->vba.NoOfDPP[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
					mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
							mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] - 1;
				}
			}

			//DISPCLK/DPPCLK
			mode_lib->vba.WritebackRequiredDISPCLK = 0;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.WritebackEnable[k]) {
					mode_lib->vba.WritebackRequiredDISPCLK = dml_max(
							mode_lib->vba.WritebackRequiredDISPCLK,
							dml32_CalculateWriteBackDISPCLK(
									mode_lib->vba.WritebackPixelFormat[k],
									mode_lib->vba.PixelClock[k],
									mode_lib->vba.WritebackHRatio[k],
									mode_lib->vba.WritebackVRatio[k],
									mode_lib->vba.WritebackHTaps[k],
									mode_lib->vba.WritebackVTaps[k],
									mode_lib->vba.WritebackSourceWidth[k],
									mode_lib->vba.WritebackDestinationWidth[k],
									mode_lib->vba.HTotal[k],
									mode_lib->vba.WritebackLineBufferSize,
									mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
				}
			}

			mode_lib->vba.RequiredDISPCLK[i][j] = mode_lib->vba.WritebackRequiredDISPCLK;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.RequiredDISPCLK[i][j] = dml_max(mode_lib->vba.RequiredDISPCLK[i][j],
						mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k]);
			}

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];

			dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
					mode_lib->vba.DISPCLKDPPCLKVCOSpeed, mode_lib->vba.MinDPPCLKUsingSingleDPP,
					mode_lib->vba.NoOfDPPThisState,
					/* Output */
					&mode_lib->vba.GlobalDPPCLK, mode_lib->vba.RequiredDPPCLKThisState);

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
				mode_lib->vba.RequiredDPPCLK[i][j][k] = mode_lib->vba.RequiredDPPCLKThisState[k];

			mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] = !((mode_lib->vba.RequiredDISPCLK[i][j]
					> mode_lib->vba.MaxDispclk[i])
					|| (mode_lib->vba.GlobalDPPCLK > mode_lib->vba.MaxDppclk[i]));

			if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP)
				mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
		} // j
	} // i (VOLTAGE_STATE)

	/* Total Available OTG, HDMIFRL, DP Support Check */
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = 0;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL = 0;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = 0;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = 0;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.BlendingAndTiming[k] == k) {
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG + 1;
			if (mode_lib->vba.Output[k] == dm_dp2p0) {
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 + 1;
				if (mode_lib->vba.OutputMultistreamId[k]
						== k || mode_lib->vba.OutputMultistreamEn[k] == false) {
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs + 1;
				}
			}
		}
	}

	mode_lib->vba.NumberOfOTGSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG);
	mode_lib->vba.NumberOfHDMIFRLSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL <= mode_lib->vba.MaxNumHDMIFRLOutputs);
	mode_lib->vba.NumberOfDP2p0Support = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 <= mode_lib->vba.MaxNumDP2p0Streams
			&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs <= mode_lib->vba.MaxNumDP2p0Outputs);

	/* Display IO and DSC Support Check */
	mode_lib->vba.NonsupportedDSCInputBPC = false;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 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.DSCInputBitPerComponent[k] >
				mode_lib->vba.MaximumDSCBitsPerComponent)) {
			mode_lib->vba.NonsupportedDSCInputBPC = true;
		}
	}

	for (i = 0; i < v->soc.num_states; ++i) {
		mode_lib->vba.ExceededMultistreamSlots[i] = false;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == k) {
				TotalSlots = mode_lib->vba.RequiredSlots[i][k];
				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
					if (mode_lib->vba.OutputMultistreamId[j] == k)
						TotalSlots = TotalSlots + mode_lib->vba.RequiredSlots[i][j];
				}
				if (mode_lib->vba.Output[k] == dm_dp && TotalSlots > 63)
					mode_lib->vba.ExceededMultistreamSlots[i] = true;
				if (mode_lib->vba.Output[k] == dm_dp2p0 && TotalSlots > 64)
					mode_lib->vba.ExceededMultistreamSlots[i] = true;
			}
		}
		mode_lib->vba.LinkCapacitySupport[i] = true;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.BlendingAndTiming[k] == k
					&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
							|| mode_lib->vba.Output[k] == dm_edp
							|| mode_lib->vba.Output[k] == dm_hdmi)
					&& mode_lib->vba.OutputBppPerState[i][k] == 0) {
				mode_lib->vba.LinkCapacitySupport[i] = false;
			}
		}
	}

	mode_lib->vba.P2IWith420 = false;
	mode_lib->vba.DSCOnlyIfNecessaryWithBPP = false;
	mode_lib->vba.DSC422NativeNotSupported = false;
	mode_lib->vba.LinkRateDoesNotMatchDPVersion = false;
	mode_lib->vba.LinkRateForMultistreamNotIndicated = false;
	mode_lib->vba.BPPForMultistreamNotIndicated = false;
	mode_lib->vba.MultistreamWithHDMIOreDP = false;
	mode_lib->vba.MSOOrODMSplitWithNonDPLink = false;
	mode_lib->vba.NotEnoughLanesForMSO = false;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.BlendingAndTiming[k] == k
				&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
						|| mode_lib->vba.Output[k] == dm_edp
						|| mode_lib->vba.Output[k] == dm_hdmi)) {
			if (mode_lib->vba.OutputFormat[k]
					== dm_420 && mode_lib->vba.Interlace[k] == 1 &&
					mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)
				mode_lib->vba.P2IWith420 = true;

			if (mode_lib->vba.DSCEnable[k] && mode_lib->vba.ForcedOutputLinkBPP[k] != 0)
				mode_lib->vba.DSCOnlyIfNecessaryWithBPP = true;
			if ((mode_lib->vba.DSCEnable[k] || mode_lib->vba.DSCEnable[k])
					&& mode_lib->vba.OutputFormat[k] == dm_n422
					&& !mode_lib->vba.DSC422NativeSupport)
				mode_lib->vba.DSC422NativeNotSupported = true;

			if (((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr
					|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr2
					|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr3)
					&& mode_lib->vba.Output[k] != dm_dp && mode_lib->vba.Output[k] != dm_edp)
					|| ((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr10
							|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5
							|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr20)
							&& mode_lib->vba.Output[k] != dm_dp2p0))
				mode_lib->vba.LinkRateDoesNotMatchDPVersion = true;

			if (mode_lib->vba.OutputMultistreamEn[k] == true) {
				if (mode_lib->vba.OutputMultistreamId[k] == k
					&& mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_na)
					mode_lib->vba.LinkRateForMultistreamNotIndicated = true;
				if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
					mode_lib->vba.BPPForMultistreamNotIndicated = true;
				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
					if (mode_lib->vba.OutputMultistreamId[k] == j && mode_lib->vba.OutputMultistreamEn[k]
						&& mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
						mode_lib->vba.BPPForMultistreamNotIndicated = true;
				}
			}

			if ((mode_lib->vba.Output[k] == dm_edp || mode_lib->vba.Output[k] == dm_hdmi)) {
				if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.OutputMultistreamEn[k])
					mode_lib->vba.MultistreamWithHDMIOreDP = true;

				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
					if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == j)
						mode_lib->vba.MultistreamWithHDMIOreDP = true;
				}
			}

			if (mode_lib->vba.Output[k] != dm_dp
					&& (mode_lib->vba.ODMUse[k] == dm_odm_split_policy_1to2
							|| mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
							|| mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4))
				mode_lib->vba.MSOOrODMSplitWithNonDPLink = true;

			if ((mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
					&& mode_lib->vba.OutputLinkDPLanes[k] < 2)
					|| (mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4
							&& mode_lib->vba.OutputLinkDPLanes[k] < 4))
				mode_lib->vba.NotEnoughLanesForMSO = true;
		}
	}

	for (i = 0; i < v->soc.num_states; ++i) {
		mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = false;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.BlendingAndTiming[k] == k
					&& dml32_RequiredDTBCLK(mode_lib->vba.RequiresDSC[i][k],
							mode_lib->vba.PixelClockBackEnd[k],
							mode_lib->vba.OutputFormat[k],
							mode_lib->vba.OutputBppPerState[i][k],
							mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.HTotal[k],
							mode_lib->vba.HActive[k], mode_lib->vba.AudioSampleRate[k],
							mode_lib->vba.AudioSampleLayout[k])
							> mode_lib->vba.DTBCLKPerState[i]) {
				mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = true;
			}
		}
	}

	for (i = 0; i < v->soc.num_states; ++i) {
		mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = true;
		mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = true;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.BlendingAndTiming[k] == k
					&& mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1
					&& mode_lib->vba.Output[k] == dm_hdmi) {
				mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = false;
			}
			if (mode_lib->vba.BlendingAndTiming[k] == k
					&& mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
					&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_edp
							|| mode_lib->vba.Output[k] == dm_hdmi)) {
				mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = false;
			}
		}
	}

	for (i = 0; i < v->soc.num_states; i++) {
		mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = false;
		for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
			if (mode_lib->vba.BlendingAndTiming[k] == k) {
				if (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
						|| mode_lib->vba.Output[k] == dm_edp) {
					if (mode_lib->vba.OutputFormat[k] == dm_420) {
						mode_lib->vba.DSCFormatFactor = 2;
					} else if (mode_lib->vba.OutputFormat[k] == dm_444) {
						mode_lib->vba.DSCFormatFactor = 1;
					} else if (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]
								== dm_odm_combine_mode_4to1) {
							if (mode_lib->vba.PixelClockBackEnd[k] / 12.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.ODMCombineEnablePerState[i][k]
								== dm_odm_combine_mode_2to1) {
							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;
						}
					}
				}
			}
		}
	}

	/* Check DSC Unit and Slices Support */
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;

	for (i = 0; i < v->soc.num_states; ++i) {
		mode_lib->vba.NotEnoughDSCUnits[i] = false;
		mode_lib->vba.NotEnoughDSCSlices[i] = false;
		v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
		mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = true;
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			if (mode_lib->vba.RequiresDSC[i][k] == true) {
				if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
					if (mode_lib->vba.HActive[k]
							> 4 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 4;
					if (mode_lib->vba.NumberOfDSCSlices[k] > 16)
						mode_lib->vba.NotEnoughDSCSlices[i] = true;
				} else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
					if (mode_lib->vba.HActive[k]
							> 2 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 2;
					if (mode_lib->vba.NumberOfDSCSlices[k] > 8)
						mode_lib->vba.NotEnoughDSCSlices[i] = true;
				} else {
					if (mode_lib->vba.HActive[k] > mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 1;
					if (mode_lib->vba.NumberOfDSCSlices[k] > 4)
						mode_lib->vba.NotEnoughDSCSlices[i] = true;
				}
			}
		}
		if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC)
			mode_lib->vba.NotEnoughDSCUnits[i] = true;
	}

	/*DSC Delay per state*/
	for (i = 0; i < v->soc.num_states; ++i) {
		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
			mode_lib->vba.DSCDelayPerState[i][k] = dml32_DSCDelayRequirement(
					mode_lib->vba.RequiresDSC[i][k], mode_lib->vba.ODMCombineEnablePerState[i][k],
					mode_lib->vba.DSCInputBitPerComponent[k],
					mode_lib->vba.OutputBppPerState[i][k], mode_lib->vba.HActive[k],
					mode_lib->vba.HTotal[k], mode_lib->vba.NumberOfDSCSlices[k],
					mode_lib->vba.OutputFormat[k], mode_lib->vba.Output[k],
					mode_lib->vba.PixelClock[k], mode_lib->vba.PixelClockBackEnd[k]);
		}

		m = 0;

		for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
			for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
				for (j = 0; j <= mode_lib->vba.NumberOfActiveSurfaces - 1; j++) {
					if (mode_lib->vba.BlendingAndTiming[k] == m &&
							mode_lib->vba.RequiresDSC[i][m] == true) {
						mode_lib->vba.DSCDelayPerState[i][k] =
							mode_lib->vba.DSCDelayPerState[i][m];
					}
				}
			}
		}
	}

	//Calculate Swath, DET Configuration, DCFCLKDeepSleep
	//
	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
				mode_lib->vba.ODMCombineEnableThisState[k] =
						mode_lib->vba.ODMCombineEnablePerState[i][k];
			}

			dml32_CalculateSwathAndDETConfiguration(
					mode_lib->vba.DETSizeOverride,
					mode_lib->vba.UsesMALLForPStateChange,
					mode_lib->vba.ConfigReturnBufferSizeInKByte,
					mode_lib->vba.MaxTotalDETInKByte,
					mode_lib->vba.MinCompressedBufferSizeInKByte,
					false, /* ForceSingleDPP */
					mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.nomDETInKByte,
					mode_lib->vba.UseUnboundedRequesting,
					mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
					mode_lib->vba.ip.pixel_chunk_size_kbytes,
					mode_lib->vba.ip.rob_buffer_size_kbytes,
					mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
					mode_lib->vba.Output,
					mode_lib->vba.ReadBandwidthLuma,
					mode_lib->vba.ReadBandwidthChroma,
					mode_lib->vba.MaximumSwathWidthLuma,
					mode_lib->vba.MaximumSwathWidthChroma,
					mode_lib->vba.SourceRotation,
					mode_lib->vba.ViewportStationary,
					mode_lib->vba.SourcePixelFormat,
					mode_lib->vba.SurfaceTiling,
					mode_lib->vba.ViewportWidth,
					mode_lib->vba.ViewportHeight,
					mode_lib->vba.ViewportXStartY,
					mode_lib->vba.ViewportYStartY,
					mode_lib->vba.ViewportXStartC,
					mode_lib->vba.ViewportYStartC,
					mode_lib->vba.SurfaceWidthY,
					mode_lib->vba.SurfaceWidthC,
					mode_lib->vba.SurfaceHeightY,
					mode_lib->vba.SurfaceHeightC,
					mode_lib->vba.Read256BlockHeightY,
					mode_lib->vba.Read256BlockHeightC,
					mode_lib->vba.Read256BlockWidthY,
					mode_lib->vba.Read256BlockWidthC,
					mode_lib->vba.ODMCombineEnableThisState,
					mode_lib->vba.BlendingAndTiming,
					mode_lib->vba.BytePerPixelY,
					mode_lib->vba.BytePerPixelC,
					mode_lib->vba.BytePerPixelInDETY,
					mode_lib->vba.BytePerPixelInDETC,
					mode_lib->vba.HActive,
					mode_lib->vba.HRatio,
					mode_lib->vba.HRatioChroma,
					mode_lib->vba.NoOfDPPThisState,
					/* Output */
					mode_lib->vba.swath_width_luma_ub_this_state,
					mode_lib->vba.swath_width_chroma_ub_this_state,
					mode_lib->vba.SwathWidthYThisState,
					mode_lib->vba.SwathWidthCThisState,
					mode_lib->vba.SwathHeightYThisState,
					mode_lib->vba.SwathHeightCThisState,
					mode_lib->vba.DETBufferSizeInKByteThisState,
					mode_lib->vba.DETBufferSizeYThisState,
					mode_lib->vba.DETBufferSizeCThisState,
					&mode_lib->vba.UnboundedRequestEnabledThisState,
					&mode_lib->vba.CompressedBufferSizeInkByteThisState,
					&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], /* Long CompBufReservedSpaceKBytes */
					&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean[0], /* bool CompBufReservedSpaceNeedAdjustment */
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0],
					&mode_lib->vba.ViewportSizeSupport[i][j]);

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.swath_width_luma_ub_all_states[i][j][k] =
						mode_lib->vba.swath_width_luma_ub_this_state[k];
				mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k] =
						mode_lib->vba.swath_width_chroma_ub_this_state[k];
				mode_lib->vba.SwathWidthYAllStates[i][j][k] = mode_lib->vba.SwathWidthYThisState[k];
				mode_lib->vba.SwathWidthCAllStates[i][j][k] = mode_lib->vba.SwathWidthCThisState[k];
				mode_lib->vba.SwathHeightYAllStates[i][j][k] = mode_lib->vba.SwathHeightYThisState[k];
				mode_lib->vba.SwathHeightCAllStates[i][j][k] = mode_lib->vba.SwathHeightCThisState[k];
				mode_lib->vba.UnboundedRequestEnabledAllStates[i][j] =
						mode_lib->vba.UnboundedRequestEnabledThisState;
				mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j] =
						mode_lib->vba.CompressedBufferSizeInkByteThisState;
				mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k] =
						mode_lib->vba.DETBufferSizeInKByteThisState[k];
				mode_lib->vba.DETBufferSizeYAllStates[i][j][k] =
						mode_lib->vba.DETBufferSizeYThisState[k];
				mode_lib->vba.DETBufferSizeCAllStates[i][j][k] =
						mode_lib->vba.DETBufferSizeCThisState[k];
			}
		}
	}

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++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];
	}

	dml32_CalculateSurfaceSizeInMall(
			mode_lib->vba.NumberOfActiveSurfaces,
			mode_lib->vba.MALLAllocatedForDCNFinal,
			mode_lib->vba.UseMALLForStaticScreen,
			mode_lib->vba.DCCEnable,
			mode_lib->vba.ViewportStationary,
			mode_lib->vba.ViewportXStartY,
			mode_lib->vba.ViewportYStartY,
			mode_lib->vba.ViewportXStartC,
			mode_lib->vba.ViewportYStartC,
			mode_lib->vba.ViewportWidth,
			mode_lib->vba.ViewportHeight,
			mode_lib->vba.BytePerPixelY,
			mode_lib->vba.ViewportWidthChroma,
			mode_lib->vba.ViewportHeightChroma,
			mode_lib->vba.BytePerPixelC,
			mode_lib->vba.SurfaceWidthY,
			mode_lib->vba.SurfaceWidthC,
			mode_lib->vba.SurfaceHeightY,
			mode_lib->vba.SurfaceHeightC,
			mode_lib->vba.Read256BlockWidthY,
			mode_lib->vba.Read256BlockWidthC,
			mode_lib->vba.Read256BlockHeightY,
			mode_lib->vba.Read256BlockHeightC,
			mode_lib->vba.MacroTileWidthY,
			mode_lib->vba.MacroTileWidthC,
			mode_lib->vba.MacroTileHeightY,
			mode_lib->vba.MacroTileHeightC,

			/* Output */
			mode_lib->vba.SurfaceSizeInMALL,
			&mode_lib->vba.ExceededMALLSize);

	for (i = 0; i < v->soc.num_states; i++) {
		for (j = 0; j < 2; j++) {
			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
				mode_lib->vba.swath_width_luma_ub_this_state[k] =
						mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
				mode_lib->vba.swath_width_chroma_ub_this_state[k] =
						mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
				mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
				mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
				mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
				mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
				mode_lib->vba.DETBufferSizeInKByteThisState[k] =
						mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
				mode_lib->vba.DETBufferSizeYThisState[k] =
						mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
				mode_lib->vba.DETBufferSizeCThisState[k] =
						mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
				mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
			}

			mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] = 0;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.DCCEnable[k] == true) {
					mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] =
							mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
									+ mode_lib->vba.NoOfDPP[i][j][k];
				}
			}


			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthY = mode_lib->vba.MacroTileWidthY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightY = mode_lib->vba.MacroTileHeightY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthC = mode_lib->vba.MacroTileWidthC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightC = mode_lib->vba.MacroTileHeightC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].HTotal = mode_lib->vba.HTotal[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ProgressiveToInterlaceUnitInOPP =
				mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatio = mode_lib->vba.VRatio[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTaps = mode_lib->vba.vtaps[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchY = mode_lib->vba.PitchY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchC = mode_lib->vba.PitchC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightY = mode_lib->vba.SwathHeightYThisState[k];
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightC = mode_lib->vba.SwathHeightCThisState[k];
			}

			{
				dml32_CalculateVMRowAndSwath(
						mode_lib->vba.NumberOfActiveSurfaces,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters,
						mode_lib->vba.SurfaceSizeInMALL,
						mode_lib->vba.PTEBufferSizeInRequestsLuma,
						mode_lib->vba.PTEBufferSizeInRequestsChroma,
						mode_lib->vba.DCCMetaBufferSizeBytes,
						mode_lib->vba.UseMALLForStaticScreen,
						mode_lib->vba.UsesMALLForPStateChange,
						mode_lib->vba.MALLAllocatedForDCNFinal,
						mode_lib->vba.SwathWidthYThisState,
						mode_lib->vba.SwathWidthCThisState,
						mode_lib->vba.GPUVMEnable,
						mode_lib->vba.HostVMEnable,
						mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
						mode_lib->vba.GPUVMMaxPageTableLevels,
						mode_lib->vba.GPUVMMinPageSizeKBytes,
						mode_lib->vba.HostVMMinPageSize,

						/* Output */
						mode_lib->vba.PTEBufferSizeNotExceededPerState,
						mode_lib->vba.DCCMetaBufferSizeNotExceededPerState,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1],
						mode_lib->vba.dpte_row_height,
						mode_lib->vba.dpte_row_height_chroma,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[8],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[9],
						mode_lib->vba.meta_row_height,
						mode_lib->vba.meta_row_height_chroma,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[10],
						mode_lib->vba.dpte_group_bytes,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[11],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[12],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[13],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[14],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[15],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[16],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[17],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[18],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[19],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[20],
						mode_lib->vba.PrefetchLinesYThisState,
						mode_lib->vba.PrefetchLinesCThisState,
						mode_lib->vba.PrefillY,
						mode_lib->vba.PrefillC,
						mode_lib->vba.MaxNumSwY,
						mode_lib->vba.MaxNumSwC,
						mode_lib->vba.meta_row_bandwidth_this_state,
						mode_lib->vba.dpte_row_bandwidth_this_state,
						mode_lib->vba.DPTEBytesPerRowThisState,
						mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState,
						mode_lib->vba.MetaRowBytesThisState,
						mode_lib->vba.use_one_row_for_frame_this_state,
						mode_lib->vba.use_one_row_for_frame_flip_this_state,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0], // Boolean UsesMALLForStaticScreen[]
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1], // Boolean PTE_BUFFER_MODE[]
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[21]); // Long BIGK_FRAGMENT_SIZE[]
			}

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.PrefetchLinesY[i][j][k] = mode_lib->vba.PrefetchLinesYThisState[k];
				mode_lib->vba.PrefetchLinesC[i][j][k] = mode_lib->vba.PrefetchLinesCThisState[k];
				mode_lib->vba.meta_row_bandwidth[i][j][k] =
						mode_lib->vba.meta_row_bandwidth_this_state[k];
				mode_lib->vba.dpte_row_bandwidth[i][j][k] =
						mode_lib->vba.dpte_row_bandwidth_this_state[k];
				mode_lib->vba.DPTEBytesPerRow[i][j][k] = mode_lib->vba.DPTEBytesPerRowThisState[k];
				mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k] =
						mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState[k];
				mode_lib->vba.MetaRowBytes[i][j][k] = mode_lib->vba.MetaRowBytesThisState[k];
				mode_lib->vba.use_one_row_for_frame[i][j][k] =
						mode_lib->vba.use_one_row_for_frame_this_state[k];
				mode_lib->vba.use_one_row_for_frame_flip[i][j][k] =
						mode_lib->vba.use_one_row_for_frame_flip_this_state[k];
			}

			mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = true;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.PTEBufferSizeNotExceededPerState[k] == false)
					mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = false;
			}

			mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = true;
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				if (mode_lib->vba.DCCMetaBufferSizeNotExceededPerState[k] == false)
					mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = false;
			}

			mode_lib->vba.UrgLatency[i] = dml32_CalculateUrgentLatency(
					mode_lib->vba.UrgentLatencyPixelDataOnly,
					mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
					mode_lib->vba.UrgentLatencyVMDataOnly, mode_lib->vba.DoUrgentLatencyAdjustment,
					mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
					mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
					mode_lib->vba.FabricClockPerState[i]);

			//bool   NotUrgentLatencyHiding[DC__NUM_DPP__MAX];
			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				dml32_CalculateUrgentBurstFactor(
						mode_lib->vba.UsesMALLForPStateChange[k],
						mode_lib->vba.swath_width_luma_ub_this_state[k],
						mode_lib->vba.swath_width_chroma_ub_this_state[k],
						mode_lib->vba.SwathHeightYThisState[k],
						mode_lib->vba.SwathHeightCThisState[k],
						(double) mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
						mode_lib->vba.UrgLatency[i],
						mode_lib->vba.CursorBufferSize,
						mode_lib->vba.CursorWidth[k][0],
						mode_lib->vba.CursorBPP[k][0],
						mode_lib->vba.VRatio[k],
						mode_lib->vba.VRatioChroma[k],
						mode_lib->vba.BytePerPixelInDETY[k],
						mode_lib->vba.BytePerPixelInDETC[k],
						mode_lib->vba.DETBufferSizeYThisState[k],
						mode_lib->vba.DETBufferSizeCThisState[k],
						/* Output */
						&mode_lib->vba.UrgentBurstFactorCursor[k],
						&mode_lib->vba.UrgentBurstFactorLuma[k],
						&mode_lib->vba.UrgentBurstFactorChroma[k],
						&mode_lib->vba.NoUrgentLatencyHiding[k]);
			}

			dml32_CalculateDCFCLKDeepSleep(
					mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.BytePerPixelY,
					mode_lib->vba.BytePerPixelC,
					mode_lib->vba.VRatio,
					mode_lib->vba.VRatioChroma,
					mode_lib->vba.SwathWidthYThisState,
					mode_lib->vba.SwathWidthCThisState,
					mode_lib->vba.NoOfDPPThisState,
					mode_lib->vba.HRatio,
					mode_lib->vba.HRatioChroma,
					mode_lib->vba.PixelClock,
					mode_lib->vba.PSCL_FACTOR,
					mode_lib->vba.PSCL_FACTOR_CHROMA,
					mode_lib->vba.RequiredDPPCLKThisState,
					mode_lib->vba.ReadBandwidthLuma,
					mode_lib->vba.ReadBandwidthChroma,
					mode_lib->vba.ReturnBusWidth,

					/* Output */
					&mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j]);
		}
	}

	m = 0;

	//Calculate Return BW
	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {
			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
				if (mode_lib->vba.BlendingAndTiming[k] == k) {
					if (mode_lib->vba.WritebackEnable[k] == true) {
						mode_lib->vba.WritebackDelayTime[k] =
							mode_lib->vba.WritebackLatency
						+ dml32_CalculateWriteBackDelay(
							mode_lib->vba.WritebackPixelFormat[k],
							mode_lib->vba.WritebackHRatio[k],
							mode_lib->vba.WritebackVRatio[k],
							mode_lib->vba.WritebackVTaps[k],
							mode_lib->vba.WritebackDestinationWidth[k],
							mode_lib->vba.WritebackDestinationHeight[k],
							mode_lib->vba.WritebackSourceHeight[k],
							mode_lib->vba.HTotal[k])
							/ mode_lib->vba.RequiredDISPCLK[i][j];
					} else {
						mode_lib->vba.WritebackDelayTime[k] = 0.0;
					}
					for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
						if (mode_lib->vba.BlendingAndTiming[m]
								== k && mode_lib->vba.WritebackEnable[m] == true) {
							mode_lib->vba.WritebackDelayTime[k] =
								dml_max(mode_lib->vba.WritebackDelayTime[k],
									mode_lib->vba.WritebackLatency
								+ dml32_CalculateWriteBackDelay(
									mode_lib->vba.WritebackPixelFormat[m],
									mode_lib->vba.WritebackHRatio[m],
									mode_lib->vba.WritebackVRatio[m],
									mode_lib->vba.WritebackVTaps[m],
									mode_lib->vba.WritebackDestinationWidth[m],
									mode_lib->vba.WritebackDestinationHeight[m],
									mode_lib->vba.WritebackSourceHeight[m],
									mode_lib->vba.HTotal[m]) /
									mode_lib->vba.RequiredDISPCLK[i][j]);
						}
					}
				}
			}
			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
				for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
					if (mode_lib->vba.BlendingAndTiming[k] == m) {
						mode_lib->vba.WritebackDelayTime[k] =
								mode_lib->vba.WritebackDelayTime[m];
					}
				}
			}
			mode_lib->vba.MaxMaxVStartup[i][j] = 0;
			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
				mode_lib->vba.MaximumVStartup[i][j][k] = ((mode_lib->vba.Interlace[k] &&
								!mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
								dml_floor((mode_lib->vba.VTotal[k] -
									mode_lib->vba.VActive[k]) / 2.0, 1.0) :
								mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k])
								- dml_max(1.0, dml_ceil(1.0 *
									mode_lib->vba.WritebackDelayTime[k] /
									(mode_lib->vba.HTotal[k] /
									mode_lib->vba.PixelClock[k]), 1.0));

				// Clamp to max OTG vstartup register limit
				if (mode_lib->vba.MaximumVStartup[i][j][k] > 1023)
					mode_lib->vba.MaximumVStartup[i][j][k] = 1023;

				mode_lib->vba.MaxMaxVStartup[i][j] = dml_max(mode_lib->vba.MaxMaxVStartup[i][j],
						mode_lib->vba.MaximumVStartup[i][j][k]);
			}
		}
	}

	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes = mode_lib->vba.NumberOfChannels
			* dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
					mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
					mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);

	dml32_CalculateMinAndMaxPrefetchMode(mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
			&mode_lib->vba.MinPrefetchMode,
			&mode_lib->vba.MaxPrefetchMode);

	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j)
			mode_lib->vba.DCFCLKState[i][j] = mode_lib->vba.DCFCLKPerState[i];
	}

	/* Immediate Flip and MALL parameters */
	mode_lib->vba.ImmediateFlipRequiredFinal = false;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		mode_lib->vba.ImmediateFlipRequiredFinal = mode_lib->vba.ImmediateFlipRequiredFinal
				|| (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
	}

	mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
				mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
						|| ((mode_lib->vba.ImmediateFlipRequirement[k]
								!= dm_immediate_flip_required)
								&& (mode_lib->vba.ImmediateFlipRequirement[k]
										!= dm_immediate_flip_not_required));
	}
	mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
			mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
					&& mode_lib->vba.ImmediateFlipRequiredFinal;

	mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
			mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe ||
			((mode_lib->vba.HostVMEnable == true || mode_lib->vba.ImmediateFlipRequirement[k] !=
					dm_immediate_flip_not_required) &&
			(mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame ||
			mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe));
	}

	mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen =
			mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
			|| ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable
			|| mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
			&& (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe))
			|| ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_disable
			|| mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
			&& (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame));
	}

	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = false;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = false;
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = false;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame)
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = true;
		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport)
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = true;
		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe)
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = true;
	}
	mode_lib->vba.InvalidCombinationOfMALLUseForPState = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod
			!= v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod) || (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod);

	if (mode_lib->vba.UseMinimumRequiredDCFCLK == true) {
		dml32_UseMinimumDCFCLK(
				mode_lib->vba.UsesMALLForPStateChange,
				mode_lib->vba.DRRDisplay,
				mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
				mode_lib->vba.MaxInterDCNTileRepeaters,
				mode_lib->vba.MaxPrefetchMode,
				mode_lib->vba.DRAMClockChangeLatency,
				mode_lib->vba.FCLKChangeLatency,
				mode_lib->vba.SREnterPlusExitTime,
				mode_lib->vba.ReturnBusWidth,
				mode_lib->vba.RoundTripPingLatencyCycles,
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
				mode_lib->vba.PixelChunkSizeInKByte,
				mode_lib->vba.MetaChunkSize,
				mode_lib->vba.GPUVMEnable,
				mode_lib->vba.GPUVMMaxPageTableLevels,
				mode_lib->vba.HostVMEnable,
				mode_lib->vba.NumberOfActiveSurfaces,
				mode_lib->vba.HostVMMinPageSize,
				mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
				mode_lib->vba.DynamicMetadataVMEnabled,
				mode_lib->vba.ImmediateFlipRequiredFinal,
				mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
				mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
				mode_lib->vba.PercentOfIdealFabricAndSDPPortBWReceivedAfterUrgLatency,
				mode_lib->vba.VTotal,
				mode_lib->vba.VActive,
				mode_lib->vba.DynamicMetadataTransmittedBytes,
				mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired,
				mode_lib->vba.Interlace,
				mode_lib->vba.RequiredDPPCLK,
				mode_lib->vba.RequiredDISPCLK,
				mode_lib->vba.UrgLatency,
				mode_lib->vba.NoOfDPP,
				mode_lib->vba.ProjectedDCFCLKDeepSleep,
				mode_lib->vba.MaximumVStartup,
				mode_lib->vba.TotalNumberOfActiveDPP,
				mode_lib->vba.TotalNumberOfDCCActiveDPP,
				mode_lib->vba.dpte_group_bytes,
				mode_lib->vba.PrefetchLinesY,
				mode_lib->vba.PrefetchLinesC,
				mode_lib->vba.swath_width_luma_ub_all_states,
				mode_lib->vba.swath_width_chroma_ub_all_states,
				mode_lib->vba.BytePerPixelY,
				mode_lib->vba.BytePerPixelC,
				mode_lib->vba.HTotal,
				mode_lib->vba.PixelClock,
				mode_lib->vba.PDEAndMetaPTEBytesPerFrame,
				mode_lib->vba.DPTEBytesPerRow,
				mode_lib->vba.MetaRowBytes,
				mode_lib->vba.DynamicMetadataEnable,
				mode_lib->vba.ReadBandwidthLuma,
				mode_lib->vba.ReadBandwidthChroma,
				mode_lib->vba.DCFCLKPerState,

				/* Output */
				mode_lib->vba.DCFCLKState);
	} // UseMinimumRequiredDCFCLK == true

	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {
			mode_lib->vba.ReturnBWPerState[i][j] = dml32_get_return_bw_mbps(&mode_lib->vba.soc, i,
					mode_lib->vba.HostVMEnable, mode_lib->vba.DCFCLKState[i][j],
					mode_lib->vba.FabricClockPerState[i], mode_lib->vba.DRAMSpeedPerState[i]);
		}
	}

	//Re-ordering Buffer Support Check
	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {
			if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024
					/ mode_lib->vba.ReturnBWPerState[i][j]
					> (mode_lib->vba.RoundTripPingLatencyCycles + 32)
							/ mode_lib->vba.DCFCLKState[i][j]
							+ v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes / mode_lib->vba.ReturnBWPerState[i][j]) {
				mode_lib->vba.ROBSupport[i][j] = true;
			} else {
				mode_lib->vba.ROBSupport[i][j] = false;
			}
		}
	}

	//Vertical Active BW support check
	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth = 0;

	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
		v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth += mode_lib->vba.ReadBandwidthLuma[k]
				+ mode_lib->vba.ReadBandwidthChroma[k];
	}

	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {
			mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j] =
				dml_min3(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKState[i][j]
					* mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
					mode_lib->vba.FabricClockPerState[i]
					* mode_lib->vba.FabricDatapathToDCNDataReturn
					* mode_lib->vba.MaxAveragePercentOfIdealFabricBWDisplayCanUseInNormalSystemOperation / 100,
					mode_lib->vba.DRAMSpeedPerState[i]
					* mode_lib->vba.NumberOfChannels
					* mode_lib->vba.DRAMChannelWidth
					* (i < 2 ? mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperationSTROBE : mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation) / 100);

			if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth
					<= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
				mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = true;
			} else {
				mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = false;
			}
		}
	}

	/* Prefetch Check */

	for (i = 0; i < (int) v->soc.num_states; ++i) {
		for (j = 0; j <= 1; ++j) {

			mode_lib->vba.TimeCalc = 24 / mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
				mode_lib->vba.swath_width_luma_ub_this_state[k] =
						mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
				mode_lib->vba.swath_width_chroma_ub_this_state[k] =
						mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
				mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
				mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
				mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
				mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
				mode_lib->vba.UnboundedRequestEnabledThisState =
						mode_lib->vba.UnboundedRequestEnabledAllStates[i][j];
				mode_lib->vba.CompressedBufferSizeInkByteThisState =
						mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j];
				mode_lib->vba.DETBufferSizeInKByteThisState[k] =
						mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
				mode_lib->vba.DETBufferSizeYThisState[k] =
						mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
				mode_lib->vba.DETBufferSizeCThisState[k] =
						mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
			}

			mode_lib->vba.VActiveBandwithSupport[i][j] = dml32_CalculateVActiveBandwithSupport(
					mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.ReturnBWPerState[i][j],
					mode_lib->vba.NoUrgentLatencyHiding,
					mode_lib->vba.ReadBandwidthLuma,
					mode_lib->vba.ReadBandwidthChroma,
					mode_lib->vba.cursor_bw,
					mode_lib->vba.meta_row_bandwidth_this_state,
					mode_lib->vba.dpte_row_bandwidth_this_state,
					mode_lib->vba.NoOfDPPThisState,
					mode_lib->vba.UrgentBurstFactorLuma,
					mode_lib->vba.UrgentBurstFactorChroma,
					mode_lib->vba.UrgentBurstFactorCursor);

			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState = dml32_get_return_bw_mbps_vm_only(&mode_lib->vba.soc, i,
					mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.FabricClockPerState[i],
					mode_lib->vba.DRAMSpeedPerState[i]);
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = 1;

			if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = mode_lib->vba.ReturnBWPerState[i][j]
						/ v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState;

			mode_lib->vba.ExtraLatency = dml32_CalculateExtraLatency(
					mode_lib->vba.RoundTripPingLatencyCycles, v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
					mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.TotalNumberOfActiveDPP[i][j],
					mode_lib->vba.PixelChunkSizeInKByte,
					mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j], mode_lib->vba.MetaChunkSize,
					mode_lib->vba.ReturnBWPerState[i][j], mode_lib->vba.GPUVMEnable,
					mode_lib->vba.HostVMEnable, mode_lib->vba.NumberOfActiveSurfaces,
					mode_lib->vba.NoOfDPPThisState, mode_lib->vba.dpte_group_bytes,
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor, mode_lib->vba.HostVMMinPageSize,
					mode_lib->vba.HostVMMaxNonCachedPageTableLevels);

			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = mode_lib->vba.MinPrefetchMode;

			mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];

			do {
				mode_lib->vba.PrefetchModePerState[i][j] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState;
				mode_lib->vba.MaxVStartup = mode_lib->vba.NextMaxVStartup;

				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
					mode_lib->vba.TWait = dml32_CalculateTWait(
							mode_lib->vba.PrefetchModePerState[i][j],
							mode_lib->vba.UsesMALLForPStateChange[k],
							mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
							mode_lib->vba.DRRDisplay[k],
							mode_lib->vba.DRAMClockChangeLatency,
							mode_lib->vba.FCLKChangeLatency, mode_lib->vba.UrgLatency[i],
							mode_lib->vba.SREnterPlusExitTime);

					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dppclk = mode_lib->vba.RequiredDPPCLK[i][j][k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dispclk = mode_lib->vba.RequiredDISPCLK[i][j];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCFClkDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HTotal = mode_lib->vba.HTotal[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HActive = mode_lib->vba.HActive[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ODMMode = mode_lib->vba.ODMCombineEnablePerState[i][k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ProgressiveToInterlaceUnitInOPP =
							mode_lib->vba.ProgressiveToInterlaceUnitInOPP;

					mode_lib->vba.NoTimeForPrefetch[i][j][k] =
						dml32_CalculatePrefetchSchedule(
							v,
							k,
							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe,
							v->DSCDelayPerState[i][k],
							v->SwathWidthYThisState[k] / v->HRatio[k],
							dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
							v->MaximumVStartup[i][j][k],
							v->UrgLatency[i],
							v->ExtraLatency,
							v->TimeCalc,
							v->PDEAndMetaPTEBytesPerFrame[i][j][k],
							v->MetaRowBytes[i][j][k],
							v->DPTEBytesPerRow[i][j][k],
							v->PrefetchLinesY[i][j][k],
							v->SwathWidthYThisState[k],
							v->PrefillY[k],
							v->MaxNumSwY[k],
							v->PrefetchLinesC[i][j][k],
							v->SwathWidthCThisState[k],
							v->PrefillC[k],
							v->MaxNumSwC[k],
							v->swath_width_luma_ub_this_state[k],
							v->swath_width_chroma_ub_this_state[k],
							v->SwathHeightYThisState[k],
							v->SwathHeightCThisState[k], v->TWait,

							/* Output */
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler[k],
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler[k],
							&v->LineTimesForPrefetch[k],
							&v->PrefetchBW[k],
							&v->LinesForMetaPTE[k],
							&v->LinesForMetaAndDPTERow[k],
							&v->VRatioPreY[i][j][k],
							&v->VRatioPreC[i][j][k],
							&v->RequiredPrefetchPixelDataBWLuma[0][0][k],
							&v->RequiredPrefetchPixelDataBWChroma[0][0][k],
							&v->NoTimeForDynamicMetadata[i][j][k],
							&v->Tno_bw[k],
							&v->prefetch_vmrow_bw[k],
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],         // double *Tdmdl_vm
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],         // double *Tdmdl
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[2],         // double *TSetup
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0],         							    // unsigned int   *VUpdateOffsetPix
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[3],         // unsigned int   *VUpdateWidthPix
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[4]);        // unsigned int   *VReadyOffsetPix
				}

				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
					dml32_CalculateUrgentBurstFactor(
							mode_lib->vba.UsesMALLForPStateChange[k],
							mode_lib->vba.swath_width_luma_ub_this_state[k],
							mode_lib->vba.swath_width_chroma_ub_this_state[k],
							mode_lib->vba.SwathHeightYThisState[k],
							mode_lib->vba.SwathHeightCThisState[k],
							mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
							mode_lib->vba.UrgLatency[i], mode_lib->vba.CursorBufferSize,
							mode_lib->vba.CursorWidth[k][0], mode_lib->vba.CursorBPP[k][0],
							mode_lib->vba.VRatioPreY[i][j][k],
							mode_lib->vba.VRatioPreC[i][j][k],
							mode_lib->vba.BytePerPixelInDETY[k],
							mode_lib->vba.BytePerPixelInDETC[k],
							mode_lib->vba.DETBufferSizeYThisState[k],
							mode_lib->vba.DETBufferSizeCThisState[k],
							/* Output */
							&mode_lib->vba.UrgentBurstFactorCursorPre[k],
							&mode_lib->vba.UrgentBurstFactorLumaPre[k],
							&mode_lib->vba.UrgentBurstFactorChroma[k],
							&mode_lib->vba.NotUrgentLatencyHidingPre[k]);
				}

				{
					dml32_CalculatePrefetchBandwithSupport(
							mode_lib->vba.NumberOfActiveSurfaces,
							mode_lib->vba.ReturnBWPerState[i][j],
							mode_lib->vba.NotUrgentLatencyHidingPre,
							mode_lib->vba.ReadBandwidthLuma,
							mode_lib->vba.ReadBandwidthChroma,
							mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
							mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
							mode_lib->vba.cursor_bw,
							mode_lib->vba.meta_row_bandwidth_this_state,
							mode_lib->vba.dpte_row_bandwidth_this_state,
							mode_lib->vba.cursor_bw_pre,
							mode_lib->vba.prefetch_vmrow_bw,
							mode_lib->vba.NoOfDPPThisState,
							mode_lib->vba.UrgentBurstFactorLuma,
							mode_lib->vba.UrgentBurstFactorChroma,
							mode_lib->vba.UrgentBurstFactorCursor,
							mode_lib->vba.UrgentBurstFactorLumaPre,
							mode_lib->vba.UrgentBurstFactorChromaPre,
							mode_lib->vba.UrgentBurstFactorCursorPre,

							/* output */
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],   // Single  *PrefetchBandwidth
							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],   // Single  *FractionOfUrgentBandwidth
							&mode_lib->vba.PrefetchSupported[i][j]);
				}

				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
					if (mode_lib->vba.LineTimesForPrefetch[k]
							< 2.0 || mode_lib->vba.LinesForMetaPTE[k] >= 32.0
							|| mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16.0
							|| mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
						mode_lib->vba.PrefetchSupported[i][j] = false;
					}
				}

				mode_lib->vba.DynamicMetadataSupported[i][j] = true;
				for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
					if (mode_lib->vba.NoTimeForDynamicMetadata[i][j][k] == true)
						mode_lib->vba.DynamicMetadataSupported[i][j] = false;
				}

				mode_lib->vba.VRatioInPrefetchSupported[i][j] = true;
				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
					if (mode_lib->vba.VRatioPreY[i][j][k] > __DML_MAX_VRATIO_PRE__
							|| mode_lib->vba.VRatioPreC[i][j][k] > __DML_MAX_VRATIO_PRE__
							|| mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
						mode_lib->vba.VRatioInPrefetchSupported[i][j] = false;
					}
				}
				mode_lib->vba.AnyLinesForVMOrRowTooLarge = false;
				for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
					if (mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16
							|| mode_lib->vba.LinesForMetaPTE[k] >= 32) {
						mode_lib->vba.AnyLinesForVMOrRowTooLarge = true;
					}
				}

				if (mode_lib->vba.PrefetchSupported[i][j] == true
						&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
					mode_lib->vba.BandwidthAvailableForImmediateFlip =
							dml32_CalculateBandwidthAvailableForImmediateFlip(
							mode_lib->vba.NumberOfActiveSurfaces,
							mode_lib->vba.ReturnBWPerState[i][j],
							mode_lib->vba.ReadBandwidthLuma,
							mode_lib->vba.ReadBandwidthChroma,
							mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
							mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
							mode_lib->vba.cursor_bw,
							mode_lib->vba.cursor_bw_pre,
							mode_lib->vba.NoOfDPPThisState,
							mode_lib->vba.UrgentBurstFactorLuma,
							mode_lib->vba.UrgentBurstFactorChroma,
							mode_lib->vba.UrgentBurstFactorCursor,
							mode_lib->vba.UrgentBurstFactorLumaPre,
							mode_lib->vba.UrgentBurstFactorChromaPre,
							mode_lib->vba.UrgentBurstFactorCursorPre);

					mode_lib->vba.TotImmediateFlipBytes = 0.0;
					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
						if (!(mode_lib->vba.ImmediateFlipRequirement[k] ==
								dm_immediate_flip_not_required)) {
							mode_lib->vba.TotImmediateFlipBytes =
									mode_lib->vba.TotImmediateFlipBytes
								+ mode_lib->vba.NoOfDPP[i][j][k]
								* mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k]
								+ mode_lib->vba.MetaRowBytes[i][j][k];
							if (mode_lib->vba.use_one_row_for_frame_flip[i][j][k]) {
								mode_lib->vba.TotImmediateFlipBytes =
									mode_lib->vba.TotImmediateFlipBytes + 2
								* mode_lib->vba.DPTEBytesPerRow[i][j][k];
							} else {
								mode_lib->vba.TotImmediateFlipBytes =
									mode_lib->vba.TotImmediateFlipBytes
								+ mode_lib->vba.DPTEBytesPerRow[i][j][k];
							}
						}
					}

					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
						dml32_CalculateFlipSchedule(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
							mode_lib->vba.ExtraLatency,
							mode_lib->vba.UrgLatency[i],
							mode_lib->vba.GPUVMMaxPageTableLevels,
							mode_lib->vba.HostVMEnable,
							mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
							mode_lib->vba.GPUVMEnable,
							mode_lib->vba.HostVMMinPageSize,
							mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k],
							mode_lib->vba.MetaRowBytes[i][j][k],
							mode_lib->vba.DPTEBytesPerRow[i][j][k],
							mode_lib->vba.BandwidthAvailableForImmediateFlip,
							mode_lib->vba.TotImmediateFlipBytes,
							mode_lib->vba.SourcePixelFormat[k],
							(mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]),
							mode_lib->vba.VRatio[k],
							mode_lib->vba.VRatioChroma[k],
							mode_lib->vba.Tno_bw[k],
								mode_lib->vba.DCCEnable[k],
							mode_lib->vba.dpte_row_height[k],
							mode_lib->vba.meta_row_height[k],
							mode_lib->vba.dpte_row_height_chroma[k],
							mode_lib->vba.meta_row_height_chroma[k],
							mode_lib->vba.use_one_row_for_frame_flip[i][j][k], // 24

							/* Output */
							&mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
							&mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
							&mode_lib->vba.final_flip_bw[k],
							&mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
					}

					{
						dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
								mode_lib->vba.ReturnBWPerState[i][j],
								mode_lib->vba.ImmediateFlipRequirement,
								mode_lib->vba.final_flip_bw,
								mode_lib->vba.ReadBandwidthLuma,
								mode_lib->vba.ReadBandwidthChroma,
								mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
								mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
								mode_lib->vba.cursor_bw,
								mode_lib->vba.meta_row_bandwidth_this_state,
								mode_lib->vba.dpte_row_bandwidth_this_state,
								mode_lib->vba.cursor_bw_pre,
								mode_lib->vba.prefetch_vmrow_bw,
								mode_lib->vba.DPPPerPlane,
								mode_lib->vba.UrgentBurstFactorLuma,
								mode_lib->vba.UrgentBurstFactorChroma,
								mode_lib->vba.UrgentBurstFactorCursor,
								mode_lib->vba.UrgentBurstFactorLumaPre,
								mode_lib->vba.UrgentBurstFactorChromaPre,
								mode_lib->vba.UrgentBurstFactorCursorPre,

								/* output */
								&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0], //  Single  *TotalBandwidth
								&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1], //  Single  *FractionOfUrgentBandwidth
								&mode_lib->vba.ImmediateFlipSupportedForState[i][j]); // Boolean *ImmediateFlipBandwidthSupport
					}

					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
						if (!(mode_lib->vba.ImmediateFlipRequirement[k]
								== dm_immediate_flip_not_required)
								&& (mode_lib->vba.ImmediateFlipSupportedForPipe[k]
										== false))
							mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
					}
				} else { // if prefetch not support, assume iflip not supported
					mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
				}

				if (mode_lib->vba.MaxVStartup <= __DML_VBA_MIN_VSTARTUP__
						|| mode_lib->vba.AnyLinesForVMOrRowTooLarge == false) {
					mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState + 1;
				} else {
					mode_lib->vba.NextMaxVStartup = mode_lib->vba.NextMaxVStartup - 1;
				}
			} while (!((mode_lib->vba.PrefetchSupported[i][j] == true
					&& mode_lib->vba.DynamicMetadataSupported[i][j] == true
					&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true &&
					// consider flip support is okay if when there is no hostvm and the
					// user does't require a iflip OR the flip bw is ok
					// If there is hostvm, DCN needs to support iflip for invalidation
					((mode_lib->vba.HostVMEnable == false
							&& !mode_lib->vba.ImmediateFlipRequiredFinal)
							|| mode_lib->vba.ImmediateFlipSupportedForState[i][j] == true))
					|| (mode_lib->vba.NextMaxVStartup == mode_lib->vba.MaxMaxVStartup[i][j]
							&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState > mode_lib->vba.MaxPrefetchMode)));

			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
				mode_lib->vba.use_one_row_for_frame_this_state[k] =
						mode_lib->vba.use_one_row_for_frame[i][j][k];
			}


			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.UrgentLatency = mode_lib->vba.UrgLatency[i];
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.ExtraLatency = mode_lib->vba.ExtraLatency;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;

			{
				dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
						v,
						v->PrefetchModePerState[i][j],
						v->DCFCLKState[i][j],
						v->ReturnBWPerState[i][j],
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters,
						v->SOCCLKPerState[i],
						v->ProjectedDCFCLKDeepSleep[i][j],
						v->DETBufferSizeYThisState,
						v->DETBufferSizeCThisState,
						v->SwathHeightYThisState,
						v->SwathHeightCThisState,
						v->SwathWidthYThisState, // 24
						v->SwathWidthCThisState,
						v->NoOfDPPThisState,
						v->BytePerPixelInDETY,
						v->BytePerPixelInDETC,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler,
						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler,
						v->UnboundedRequestEnabledThisState,
						v->CompressedBufferSizeInkByteThisState,

						/* Output */
						&v->DRAMClockChangeSupport[i][j],
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[0], // double *MaxActiveDRAMClockChangeLatencySupported
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], // Long SubViewportLinesNeededInMALL[]
						&v->FCLKChangeSupport[i][j],
						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[1], // double *MinActiveFCLKChangeLatencySupported
						&mode_lib->vba.USRRetrainingSupport[i][j],
						mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);
			}
		}
	} // End of Prefetch Check

	/*Cursor Support Check*/
	mode_lib->vba.CursorSupport = true;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.CursorWidth[k][0] > 0.0) {
			if (mode_lib->vba.CursorBPP[k][0] == 64 && 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.NumberOfActiveSurfaces - 1; k++) {
		mode_lib->vba.AlignedYPitch[k] = dml_ceil(
				dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.SurfaceWidthY[k]),
				mode_lib->vba.MacroTileWidthY[k]);
		if (mode_lib->vba.DCCEnable[k] == true) {
			mode_lib->vba.AlignedDCCMetaPitchY[k] = dml_ceil(
					dml_max(mode_lib->vba.DCCMetaPitchY[k], mode_lib->vba.SurfaceWidthY[k]),
					64.0 * mode_lib->vba.Read256BlockWidthY[k]);
		} else {
			mode_lib->vba.AlignedDCCMetaPitchY[k] = mode_lib->vba.DCCMetaPitchY[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_rgbe
				&& 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.SurfaceWidthC[k]),
					mode_lib->vba.MacroTileWidthC[k]);
			if (mode_lib->vba.DCCEnable[k] == true) {
				mode_lib->vba.AlignedDCCMetaPitchC[k] = dml_ceil(
						dml_max(mode_lib->vba.DCCMetaPitchC[k],
								mode_lib->vba.SurfaceWidthC[k]),
						64.0 * mode_lib->vba.Read256BlockWidthC[k]);
			} else {
				mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
			}
		} else {
			mode_lib->vba.AlignedCPitch[k] = mode_lib->vba.PitchC[k];
			mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
		}
		if (mode_lib->vba.AlignedYPitch[k] > mode_lib->vba.PitchY[k]
				|| mode_lib->vba.AlignedCPitch[k] > mode_lib->vba.PitchC[k]
				|| mode_lib->vba.AlignedDCCMetaPitchY[k] > mode_lib->vba.DCCMetaPitchY[k]
				|| mode_lib->vba.AlignedDCCMetaPitchC[k] > mode_lib->vba.DCCMetaPitchC[k]) {
			mode_lib->vba.PitchSupport = false;
		}
	}

	mode_lib->vba.ViewportExceedsSurface = false;
	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		if (mode_lib->vba.ViewportWidth[k] > mode_lib->vba.SurfaceWidthY[k]
				|| mode_lib->vba.ViewportHeight[k] > mode_lib->vba.SurfaceHeightY[k]) {
			mode_lib->vba.ViewportExceedsSurface = true;
			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_16
					&& mode_lib->vba.SourcePixelFormat[k] != dm_444_8
					&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe) {
				if (mode_lib->vba.ViewportWidthChroma[k] > mode_lib->vba.SurfaceWidthC[k]
						|| mode_lib->vba.ViewportHeightChroma[k]
								> mode_lib->vba.SurfaceHeightC[k]) {
					mode_lib->vba.ViewportExceedsSurface = true;
				}
			}
		}
	}

	/*Mode Support, Voltage State and SOC Configuration*/
	mode_support_configuration(v, mode_lib);

	MaximumMPCCombine = 0;

	for (i = v->soc.num_states; i >= 0; i--) {
		if (i == v->soc.num_states || mode_lib->vba.ModeSupport[i][0] == true ||
				mode_lib->vba.ModeSupport[i][1] == true) {
			mode_lib->vba.VoltageLevel = i;
			mode_lib->vba.ModeIsSupported = mode_lib->vba.ModeSupport[i][0] == true
					|| mode_lib->vba.ModeSupport[i][1] == true;

			if (mode_lib->vba.ModeSupport[i][0] == true) {
				MaximumMPCCombine = 0;
			} else {
				MaximumMPCCombine = 1;
			}
		}
	}

	mode_lib->vba.ImmediateFlipSupport =
			mode_lib->vba.ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
	mode_lib->vba.UnboundedRequestEnabled =
			mode_lib->vba.UnboundedRequestEnabledAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
	mode_lib->vba.CompressedBufferSizeInkByte =
			mode_lib->vba.CompressedBufferSizeInkByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; // Not used, informational

	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
		mode_lib->vba.MPCCombineEnable[k] =
				mode_lib->vba.MPCCombine[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.DPPPerPlane[k] = mode_lib->vba.NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.SwathHeightY[k] =
				mode_lib->vba.SwathHeightYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.SwathHeightC[k] =
				mode_lib->vba.SwathHeightCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.DETBufferSizeInKByte[k] =
			mode_lib->vba.DETBufferSizeInKByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.DETBufferSizeY[k] =
				mode_lib->vba.DETBufferSizeYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.DETBufferSizeC[k] =
				mode_lib->vba.DETBufferSizeCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
		mode_lib->vba.OutputType[k] = mode_lib->vba.OutputTypePerState[mode_lib->vba.VoltageLevel][k];
		mode_lib->vba.OutputRate[k] = mode_lib->vba.OutputRatePerState[mode_lib->vba.VoltageLevel][k];
	}

	mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
	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.ReturnBW = mode_lib->vba.ReturnBWPerState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
	mode_lib->vba.DISPCLK = mode_lib->vba.RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
	mode_lib->vba.maxMpcComb = MaximumMPCCombine;

	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 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] = dm_odm_combine_mode_disabled;
		}

		mode_lib->vba.DSCEnabled[k] = mode_lib->vba.RequiresDSC[mode_lib->vba.VoltageLevel][k];
		mode_lib->vba.FECEnable[k] = mode_lib->vba.RequiresFEC[mode_lib->vba.VoltageLevel][k];
		mode_lib->vba.OutputBpp[k] = mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k];
	}

	mode_lib->vba.UrgentWatermark = mode_lib->vba.Watermark.UrgentWatermark;
	mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.Watermark.StutterEnterPlusExitWatermark;
	mode_lib->vba.StutterExitWatermark = mode_lib->vba.Watermark.StutterExitWatermark;
	mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.Watermark.WritebackDRAMClockChangeWatermark;
	mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.Watermark.DRAMClockChangeWatermark;
	mode_lib->vba.UrgentLatency = mode_lib->vba.UrgLatency[mode_lib->vba.VoltageLevel];
	mode_lib->vba.DCFCLKDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[mode_lib->vba.VoltageLevel][MaximumMPCCombine];

	/* VBA has Error type to Error Msg output here, but not necessary for DML-C */
} // ModeSupportAndSystemConfigurationFull