1 /*
2  * Copyright 2022 Advanced Micro Devices, Inc. All rights reserved.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors: AMD
23  *
24  */
25 
26 #include "dc.h"
27 #include "../display_mode_lib.h"
28 #include "display_mode_vba_32.h"
29 #include "../dml_inline_defs.h"
30 #include "display_mode_vba_util_32.h"
31 
32 void dml32_recalculate(struct display_mode_lib *mode_lib);
33 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
34 		struct display_mode_lib *mode_lib);
35 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib);
36 
dml32_recalculate(struct display_mode_lib * mode_lib)37 void dml32_recalculate(struct display_mode_lib *mode_lib)
38 {
39 	ModeSupportAndSystemConfiguration(mode_lib);
40 
41 	dml32_CalculateMaxDETAndMinCompressedBufferSize(mode_lib->vba.ConfigReturnBufferSizeInKByte,
42 			mode_lib->vba.ROBBufferSizeInKByte,
43 			DC__NUM_DPP,
44 			false, //mode_lib->vba.override_setting.nomDETInKByteOverrideEnable,
45 			0, //mode_lib->vba.override_setting.nomDETInKByteOverrideValue,
46 
47 			/* Output */
48 			&mode_lib->vba.MaxTotalDETInKByte, &mode_lib->vba.nomDETInKByte,
49 			&mode_lib->vba.MinCompressedBufferSizeInKByte);
50 
51 	PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
52 #ifdef __DML_VBA_DEBUG__
53 	dml_print("DML::%s: Calling DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation\n", __func__);
54 #endif
55 	DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
56 }
57 
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(struct display_mode_lib * mode_lib)58 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
59 		struct display_mode_lib *mode_lib)
60 {
61 	struct vba_vars_st *v = &mode_lib->vba;
62 	unsigned int j, k;
63 	bool ImmediateFlipRequirementFinal;
64 	int iteration;
65 	double MaxTotalRDBandwidth;
66 	unsigned int NextPrefetchMode;
67 	double MaxTotalRDBandwidthNoUrgentBurst = 0.0;
68 	bool DestinationLineTimesForPrefetchLessThan2 = false;
69 	bool VRatioPrefetchMoreThanMax = false;
70 	double TWait;
71 	double TotalWRBandwidth = 0;
72 	double WRBandwidth = 0;
73 
74 #ifdef __DML_VBA_DEBUG__
75 	dml_print("DML::%s: --- START ---\n", __func__);
76 	dml_print("DML::%s: mode_lib->vba.PrefetchMode = %d\n", __func__, mode_lib->vba.PrefetchMode);
77 	dml_print("DML::%s: mode_lib->vba.ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
78 	dml_print("DML::%s: mode_lib->vba.VoltageLevel = %d\n", __func__, mode_lib->vba.VoltageLevel);
79 #endif
80 
81 	v->WritebackDISPCLK = 0.0;
82 	v->GlobalDPPCLK = 0.0;
83 
84 	// DISPCLK and DPPCLK Calculation
85 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
86 		if (mode_lib->vba.WritebackEnable[k]) {
87 			v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
88 					dml32_CalculateWriteBackDISPCLK(
89 							mode_lib->vba.WritebackPixelFormat[k],
90 							mode_lib->vba.PixelClock[k], mode_lib->vba.WritebackHRatio[k],
91 							mode_lib->vba.WritebackVRatio[k],
92 							mode_lib->vba.WritebackHTaps[k],
93 							mode_lib->vba.WritebackVTaps[k],
94 							mode_lib->vba.WritebackSourceWidth[k],
95 							mode_lib->vba.WritebackDestinationWidth[k],
96 							mode_lib->vba.HTotal[k], mode_lib->vba.WritebackLineBufferSize,
97 							mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
98 		}
99 	}
100 
101 	v->DISPCLK_calculated = v->WritebackDISPCLK;
102 
103 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
104 		if (mode_lib->vba.BlendingAndTiming[k] == k) {
105 			v->DISPCLK_calculated = dml_max(v->DISPCLK_calculated,
106 					dml32_CalculateRequiredDispclk(
107 							mode_lib->vba.ODMCombineEnabled[k],
108 							mode_lib->vba.PixelClock[k],
109 							mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
110 							mode_lib->vba.DISPCLKRampingMargin,
111 							mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
112 							mode_lib->vba.MaxDppclk[v->soc.num_states - 1]));
113 		}
114 	}
115 
116 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
117 		dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k],
118 				mode_lib->vba.HRatioChroma[k],
119 				mode_lib->vba.VRatio[k],
120 				mode_lib->vba.VRatioChroma[k],
121 				mode_lib->vba.MaxDCHUBToPSCLThroughput,
122 				mode_lib->vba.MaxPSCLToLBThroughput,
123 				mode_lib->vba.PixelClock[k],
124 				mode_lib->vba.SourcePixelFormat[k],
125 				mode_lib->vba.htaps[k],
126 				mode_lib->vba.HTAPsChroma[k],
127 				mode_lib->vba.vtaps[k],
128 				mode_lib->vba.VTAPsChroma[k],
129 
130 				/* Output */
131 				&v->PSCL_THROUGHPUT_LUMA[k], &v->PSCL_THROUGHPUT_CHROMA[k],
132 				&v->DPPCLKUsingSingleDPP[k]);
133 	}
134 
135 	dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces, mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
136 			mode_lib->vba.DISPCLKDPPCLKVCOSpeed, v->DPPCLKUsingSingleDPP, mode_lib->vba.DPPPerPlane,
137 			/* Output */
138 			&v->GlobalDPPCLK, v->DPPCLK);
139 
140 	for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
141 		v->DPPCLK_calculated[k] = v->DPPCLK[k];
142 	}
143 
144 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
145 		dml32_CalculateBytePerPixelAndBlockSizes(
146 				mode_lib->vba.SourcePixelFormat[k],
147 				mode_lib->vba.SurfaceTiling[k],
148 
149 				/* Output */
150 				&v->BytePerPixelY[k],
151 				&v->BytePerPixelC[k],
152 				&v->BytePerPixelDETY[k],
153 				&v->BytePerPixelDETC[k],
154 				&v->BlockHeight256BytesY[k],
155 				&v->BlockHeight256BytesC[k],
156 				&v->BlockWidth256BytesY[k],
157 				&v->BlockWidth256BytesC[k],
158 				&v->BlockHeightY[k],
159 				&v->BlockHeightC[k],
160 				&v->BlockWidthY[k],
161 				&v->BlockWidthC[k]);
162 	}
163 
164 #ifdef __DML_VBA_DEBUG__
165 	dml_print("DML::%s: %d\n", __func__, __LINE__);
166 #endif
167 	dml32_CalculateSwathWidth(
168 			false,  // ForceSingleDPP
169 			mode_lib->vba.NumberOfActiveSurfaces,
170 			mode_lib->vba.SourcePixelFormat,
171 			mode_lib->vba.SourceRotation,
172 			mode_lib->vba.ViewportStationary,
173 			mode_lib->vba.ViewportWidth,
174 			mode_lib->vba.ViewportHeight,
175 			mode_lib->vba.ViewportXStartY,
176 			mode_lib->vba.ViewportYStartY,
177 			mode_lib->vba.ViewportXStartC,
178 			mode_lib->vba.ViewportYStartC,
179 			mode_lib->vba.SurfaceWidthY,
180 			mode_lib->vba.SurfaceWidthC,
181 			mode_lib->vba.SurfaceHeightY,
182 			mode_lib->vba.SurfaceHeightC,
183 			mode_lib->vba.ODMCombineEnabled,
184 			v->BytePerPixelY,
185 			v->BytePerPixelC,
186 			v->BlockHeight256BytesY,
187 			v->BlockHeight256BytesC,
188 			v->BlockWidth256BytesY,
189 			v->BlockWidth256BytesC,
190 			mode_lib->vba.BlendingAndTiming,
191 			mode_lib->vba.HActive,
192 			mode_lib->vba.HRatio,
193 			mode_lib->vba.DPPPerPlane,
194 
195 			/* Output */
196 			v->SwathWidthSingleDPPY, v->SwathWidthSingleDPPC, v->SwathWidthY, v->SwathWidthC,
197 			v->dummy_vars
198 				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
199 				.dummy_integer_array[0], // Integer             MaximumSwathHeightY[]
200 			v->dummy_vars
201 				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
202 				.dummy_integer_array[1], // Integer             MaximumSwathHeightC[]
203 			v->swath_width_luma_ub, v->swath_width_chroma_ub);
204 
205 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
206 		v->ReadBandwidthSurfaceLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k]
207 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
208 		v->ReadBandwidthSurfaceChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k]
209 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
210 				* mode_lib->vba.VRatioChroma[k];
211 #ifdef __DML_VBA_DEBUG__
212 		dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n",
213 				__func__, k, v->ReadBandwidthSurfaceLuma[k]);
214 		dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n",
215 				__func__, k, v->ReadBandwidthSurfaceChroma[k]);
216 #endif
217 	}
218 
219 	{
220 		// VBA_DELTA
221 		// Calculate DET size, swath height
222 		dml32_CalculateSwathAndDETConfiguration(
223 				mode_lib->vba.DETSizeOverride,
224 				mode_lib->vba.UsesMALLForPStateChange,
225 				mode_lib->vba.ConfigReturnBufferSizeInKByte,
226 				mode_lib->vba.MaxTotalDETInKByte,
227 				mode_lib->vba.MinCompressedBufferSizeInKByte,
228 				false, /* ForceSingleDPP */
229 				mode_lib->vba.NumberOfActiveSurfaces,
230 				mode_lib->vba.nomDETInKByte,
231 				mode_lib->vba.UseUnboundedRequesting,
232 				mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
233 				mode_lib->vba.ip.pixel_chunk_size_kbytes,
234 				mode_lib->vba.ip.rob_buffer_size_kbytes,
235 				mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
236 				v->dummy_vars
237 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
238 					.dummy_output_encoder_array, /* output_encoder_class Output[] */
239 				v->ReadBandwidthSurfaceLuma,
240 				v->ReadBandwidthSurfaceChroma,
241 				v->dummy_vars
242 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
243 					.dummy_single_array[0], /* Single MaximumSwathWidthLuma[] */
244 				v->dummy_vars
245 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
246 					.dummy_single_array[1], /* Single MaximumSwathWidthChroma[] */
247 				mode_lib->vba.SourceRotation,
248 				mode_lib->vba.ViewportStationary,
249 				mode_lib->vba.SourcePixelFormat,
250 				mode_lib->vba.SurfaceTiling,
251 				mode_lib->vba.ViewportWidth,
252 				mode_lib->vba.ViewportHeight,
253 				mode_lib->vba.ViewportXStartY,
254 				mode_lib->vba.ViewportYStartY,
255 				mode_lib->vba.ViewportXStartC,
256 				mode_lib->vba.ViewportYStartC,
257 				mode_lib->vba.SurfaceWidthY,
258 				mode_lib->vba.SurfaceWidthC,
259 				mode_lib->vba.SurfaceHeightY,
260 				mode_lib->vba.SurfaceHeightC,
261 				v->BlockHeight256BytesY,
262 				v->BlockHeight256BytesC,
263 				v->BlockWidth256BytesY,
264 				v->BlockWidth256BytesC,
265 				mode_lib->vba.ODMCombineEnabled,
266 				mode_lib->vba.BlendingAndTiming,
267 				v->BytePerPixelY,
268 				v->BytePerPixelC,
269 				v->BytePerPixelDETY,
270 				v->BytePerPixelDETC,
271 				mode_lib->vba.HActive,
272 				mode_lib->vba.HRatio,
273 				mode_lib->vba.HRatioChroma,
274 				mode_lib->vba.DPPPerPlane,
275 
276 				/* Output */
277 				v->dummy_vars
278 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
279 					.dummy_long_array[0], /* Long swath_width_luma_ub[] */
280 				v->dummy_vars
281 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
282 					.dummy_long_array[1], /* Long swath_width_chroma_ub[] */
283 				v->dummy_vars
284 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
285 					.dummy_double_array[0], /* Long SwathWidth[] */
286 				v->dummy_vars
287 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
288 					.dummy_double_array[1], /* Long SwathWidthChroma[] */
289 				mode_lib->vba.SwathHeightY,
290 				mode_lib->vba.SwathHeightC,
291 				mode_lib->vba.DETBufferSizeInKByte,
292 				mode_lib->vba.DETBufferSizeY,
293 				mode_lib->vba.DETBufferSizeC,
294 				&v->UnboundedRequestEnabled,
295 				&v->CompressedBufferSizeInkByte,
296 				&v->CompBufReservedSpaceKBytes,
297 				&v->dummy_vars
298 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
299 					.dummy_boolean,       /* bool *CompBufReservedSpaceNeedAjustment */
300 				v->dummy_vars
301 					.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
302 					.dummy_boolean_array, /* bool ViewportSizeSupportPerSurface[] */
303 				&v->dummy_vars
304 					 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
305 					 .dummy_boolean); /* bool *ViewportSizeSupport */
306 	}
307 
308 	v->CompBufReservedSpaceZs     = v->CompBufReservedSpaceKBytes * 1024.0 / 256.0;
309 	v->CompBufReservedSpace64B    = v->CompBufReservedSpaceKBytes * 1024.0 / 64.0;
310 
311 	// DCFCLK Deep Sleep
312 	dml32_CalculateDCFCLKDeepSleep(
313 			mode_lib->vba.NumberOfActiveSurfaces,
314 			v->BytePerPixelY,
315 			v->BytePerPixelC,
316 			mode_lib->vba.VRatio,
317 			mode_lib->vba.VRatioChroma,
318 			v->SwathWidthY,
319 			v->SwathWidthC,
320 			mode_lib->vba.DPPPerPlane,
321 			mode_lib->vba.HRatio,
322 			mode_lib->vba.HRatioChroma,
323 			mode_lib->vba.PixelClock,
324 			v->PSCL_THROUGHPUT_LUMA,
325 			v->PSCL_THROUGHPUT_CHROMA,
326 			mode_lib->vba.DPPCLK,
327 			v->ReadBandwidthSurfaceLuma,
328 			v->ReadBandwidthSurfaceChroma,
329 			mode_lib->vba.ReturnBusWidth,
330 
331 			/* Output */
332 			&v->DCFCLKDeepSleep);
333 
334 	// DSCCLK
335 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
336 		if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
337 			v->DSCCLK_calculated[k] = 0.0;
338 		} else {
339 			if (mode_lib->vba.OutputFormat[k] == dm_420)
340 				mode_lib->vba.DSCFormatFactor = 2;
341 			else if (mode_lib->vba.OutputFormat[k] == dm_444)
342 				mode_lib->vba.DSCFormatFactor = 1;
343 			else if (mode_lib->vba.OutputFormat[k] == dm_n422)
344 				mode_lib->vba.DSCFormatFactor = 2;
345 			else
346 				mode_lib->vba.DSCFormatFactor = 1;
347 			if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
348 				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 12
349 						/ mode_lib->vba.DSCFormatFactor
350 						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
351 			else if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
352 				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 6
353 						/ mode_lib->vba.DSCFormatFactor
354 						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
355 			else
356 				v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 3
357 						/ mode_lib->vba.DSCFormatFactor
358 						/ (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
359 		}
360 	}
361 
362 	// DSC Delay
363 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
364 		v->DSCDelay[k] = dml32_DSCDelayRequirement(mode_lib->vba.DSCEnabled[k],
365 				mode_lib->vba.ODMCombineEnabled[k], mode_lib->vba.DSCInputBitPerComponent[k],
366 				mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k],
367 				mode_lib->vba.HActive[k], mode_lib->vba.HTotal[k],
368 				mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.OutputFormat[k],
369 				mode_lib->vba.Output[k], mode_lib->vba.PixelClock[k],
370 				mode_lib->vba.PixelClockBackEnd[k], mode_lib->vba.ip.dsc_delay_factor_wa);
371 	}
372 
373 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
374 		for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) // NumberOfSurfaces
375 			if (j != k && mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.DSCEnabled[j])
376 				v->DSCDelay[k] = v->DSCDelay[j];
377 
378 	//Immediate Flip
379 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
380 		v->ImmediateFlipSupportedSurface[k] = mode_lib->vba.ImmediateFlipSupport
381 				&& (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required);
382 	}
383 
384 	// Prefetch
385 	dml32_CalculateSurfaceSizeInMall(
386 				mode_lib->vba.NumberOfActiveSurfaces,
387 				mode_lib->vba.MALLAllocatedForDCNFinal,
388 				mode_lib->vba.UseMALLForStaticScreen,
389 				mode_lib->vba.UsesMALLForPStateChange,
390 				mode_lib->vba.DCCEnable,
391 				mode_lib->vba.ViewportStationary,
392 				mode_lib->vba.ViewportXStartY,
393 				mode_lib->vba.ViewportYStartY,
394 				mode_lib->vba.ViewportXStartC,
395 				mode_lib->vba.ViewportYStartC,
396 				mode_lib->vba.ViewportWidth,
397 				mode_lib->vba.ViewportHeight,
398 				v->BytePerPixelY,
399 				mode_lib->vba.ViewportWidthChroma,
400 				mode_lib->vba.ViewportHeightChroma,
401 				v->BytePerPixelC,
402 				mode_lib->vba.SurfaceWidthY,
403 				mode_lib->vba.SurfaceWidthC,
404 				mode_lib->vba.SurfaceHeightY,
405 				mode_lib->vba.SurfaceHeightC,
406 				v->BlockWidth256BytesY,
407 				v->BlockWidth256BytesC,
408 				v->BlockHeight256BytesY,
409 				v->BlockHeight256BytesC,
410 				v->BlockWidthY,
411 				v->BlockWidthC,
412 				v->BlockHeightY,
413 				v->BlockHeightC,
414 				mode_lib->vba.DCCMetaPitchY,
415 				mode_lib->vba.DCCMetaPitchC,
416 
417 				/* Output */
418 				v->SurfaceSizeInMALL,
419 				&v->dummy_vars.
420 				DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
421 				.dummy_boolean2); /* Boolean *ExceededMALLSize */
422 
423 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
424 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
425 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
426 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
427 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
428 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
429 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesY = v->BlockWidth256BytesY[k];
430 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesY = v->BlockHeight256BytesY[k];
431 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesC = v->BlockWidth256BytesC[k];
432 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesC = v->BlockHeight256BytesC[k];
433 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthY = v->BlockWidthY[k];
434 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightY = v->BlockHeightY[k];
435 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthC = v->BlockWidthC[k];
436 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightC = v->BlockHeightC[k];
437 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
438 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].HTotal = mode_lib->vba.HTotal[k];
439 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
440 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
441 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
442 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelY = v->BytePerPixelY[k];
443 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelC = v->BytePerPixelC[k];
444 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
445 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatio = mode_lib->vba.VRatio[k];
446 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
447 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTaps = mode_lib->vba.vtaps[k];
448 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
449 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchY = mode_lib->vba.PitchY[k];
450 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
451 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchC = mode_lib->vba.PitchC[k];
452 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
453 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
454 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
455 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
456 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
457 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
458 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
459 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightY = mode_lib->vba.SwathHeightY[k];
460 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightC = mode_lib->vba.SwathHeightC[k];
461 	}
462 
463 	{
464 
465 		dml32_CalculateVMRowAndSwath(
466 				mode_lib->vba.NumberOfActiveSurfaces,
467 				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters,
468 				v->SurfaceSizeInMALL,
469 				mode_lib->vba.PTEBufferSizeInRequestsLuma,
470 				mode_lib->vba.PTEBufferSizeInRequestsChroma,
471 				mode_lib->vba.DCCMetaBufferSizeBytes,
472 				mode_lib->vba.UseMALLForStaticScreen,
473 				mode_lib->vba.UsesMALLForPStateChange,
474 				mode_lib->vba.MALLAllocatedForDCNFinal,
475 				v->SwathWidthY,
476 				v->SwathWidthC,
477 				mode_lib->vba.GPUVMEnable,
478 				mode_lib->vba.HostVMEnable,
479 				mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
480 				mode_lib->vba.GPUVMMaxPageTableLevels,
481 				mode_lib->vba.GPUVMMinPageSizeKBytes,
482 				mode_lib->vba.HostVMMinPageSize,
483 
484 				/* Output */
485 				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[0],  // Boolean PTEBufferSizeNotExceeded[]
486 				v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[1],  // Boolean DCCMetaBufferSizeNotExceeded[]
487 				v->dpte_row_width_luma_ub,
488 				v->dpte_row_width_chroma_ub,
489 				v->dpte_row_height,
490 				v->dpte_row_height_chroma,
491 				v->dpte_row_height_linear,
492 				v->dpte_row_height_linear_chroma,
493 				v->meta_req_width,
494 				v->meta_req_width_chroma,
495 				v->meta_req_height,
496 				v->meta_req_height_chroma,
497 				v->meta_row_width,
498 				v->meta_row_width_chroma,
499 				v->meta_row_height,
500 				v->meta_row_height_chroma,
501 				v->vm_group_bytes,
502 				v->dpte_group_bytes,
503 				v->PixelPTEReqWidthY,
504 				v->PixelPTEReqHeightY,
505 				v->PTERequestSizeY,
506 				v->PixelPTEReqWidthC,
507 				v->PixelPTEReqHeightC,
508 				v->PTERequestSizeC,
509 				v->dpde0_bytes_per_frame_ub_l,
510 				v->meta_pte_bytes_per_frame_ub_l,
511 				v->dpde0_bytes_per_frame_ub_c,
512 				v->meta_pte_bytes_per_frame_ub_c,
513 				v->PrefetchSourceLinesY,
514 				v->PrefetchSourceLinesC,
515 				v->VInitPreFillY, v->VInitPreFillC,
516 				v->MaxNumSwathY,
517 				v->MaxNumSwathC,
518 				v->meta_row_bw,
519 				v->dpte_row_bw,
520 				v->PixelPTEBytesPerRow,
521 				v->PDEAndMetaPTEBytesFrame,
522 				v->MetaRowByte,
523 				v->Use_One_Row_For_Frame,
524 				v->Use_One_Row_For_Frame_Flip,
525 				v->UsesMALLForStaticScreen,
526 				v->PTE_BUFFER_MODE,
527 				v->BIGK_FRAGMENT_SIZE);
528 	}
529 
530 
531 	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes = mode_lib->vba.NumberOfChannels
532 			* dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
533 					mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
534 					mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
535 
536 	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.VMDataOnlyReturnBW = dml32_get_return_bw_mbps_vm_only(
537 			&mode_lib->vba.soc,
538 			mode_lib->vba.VoltageLevel,
539 			mode_lib->vba.DCFCLK,
540 			mode_lib->vba.FabricClock,
541 			mode_lib->vba.DRAMSpeed);
542 
543 #ifdef __DML_VBA_DEBUG__
544 	dml_print("DML::%s: mode_lib->vba.ReturnBusWidth = %f\n", __func__, mode_lib->vba.ReturnBusWidth);
545 	dml_print("DML::%s: mode_lib->vba.DCFCLK = %f\n", __func__, mode_lib->vba.DCFCLK);
546 	dml_print("DML::%s: mode_lib->vba.FabricClock = %f\n", __func__, mode_lib->vba.FabricClock);
547 	dml_print("DML::%s: mode_lib->vba.FabricDatapathToDCNDataReturn = %f\n", __func__,
548 			mode_lib->vba.FabricDatapathToDCNDataReturn);
549 	dml_print("DML::%s: mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency = %f\n",
550 			__func__, mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency);
551 	dml_print("DML::%s: mode_lib->vba.DRAMSpeed = %f\n", __func__, mode_lib->vba.DRAMSpeed);
552 	dml_print("DML::%s: mode_lib->vba.NumberOfChannels = %f\n", __func__, mode_lib->vba.NumberOfChannels);
553 	dml_print("DML::%s: mode_lib->vba.DRAMChannelWidth = %f\n", __func__, mode_lib->vba.DRAMChannelWidth);
554 	dml_print("DML::%s: mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly = %f\n",
555 			__func__, mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly);
556 	dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
557 	dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->vba.ReturnBW);
558 #endif
559 
560 	v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor = 1.0;
561 
562 	if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
563 		v->dummy_vars
564 			.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
565 			.HostVMInefficiencyFactor =
566 			mode_lib->vba.ReturnBW / v->dummy_vars
567 				.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
568 				.VMDataOnlyReturnBW;
569 
570 	mode_lib->vba.TotalDCCActiveDPP = 0;
571 	mode_lib->vba.TotalActiveDPP = 0;
572 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
573 		mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + mode_lib->vba.DPPPerPlane[k];
574 		if (mode_lib->vba.DCCEnable[k])
575 			mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP
576 					+ mode_lib->vba.DPPPerPlane[k];
577 	}
578 
579 	v->UrgentExtraLatency = dml32_CalculateExtraLatency(
580 			mode_lib->vba.RoundTripPingLatencyCycles,
581 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes,
582 			mode_lib->vba.DCFCLK,
583 			mode_lib->vba.TotalActiveDPP,
584 			mode_lib->vba.PixelChunkSizeInKByte,
585 			mode_lib->vba.TotalDCCActiveDPP,
586 			mode_lib->vba.MetaChunkSize,
587 			mode_lib->vba.ReturnBW,
588 			mode_lib->vba.GPUVMEnable,
589 			mode_lib->vba.HostVMEnable,
590 			mode_lib->vba.NumberOfActiveSurfaces,
591 			mode_lib->vba.DPPPerPlane,
592 			v->dpte_group_bytes,
593 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
594 			mode_lib->vba.HostVMMinPageSize,
595 			mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
596 
597 	mode_lib->vba.TCalc = 24.0 / v->DCFCLKDeepSleep;
598 
599 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
600 		if (mode_lib->vba.BlendingAndTiming[k] == k) {
601 			if (mode_lib->vba.WritebackEnable[k] == true) {
602 				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = mode_lib->vba.WritebackLatency
603 						+ dml32_CalculateWriteBackDelay(
604 								mode_lib->vba.WritebackPixelFormat[k],
605 								mode_lib->vba.WritebackHRatio[k],
606 								mode_lib->vba.WritebackVRatio[k],
607 								mode_lib->vba.WritebackVTaps[k],
608 								mode_lib->vba.WritebackDestinationWidth[k],
609 								mode_lib->vba.WritebackDestinationHeight[k],
610 								mode_lib->vba.WritebackSourceHeight[k],
611 								mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK;
612 			} else
613 				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
614 			for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
615 				if (mode_lib->vba.BlendingAndTiming[j] == k &&
616 					mode_lib->vba.WritebackEnable[j] == true) {
617 					v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
618 						dml_max(v->WritebackDelay[mode_lib->vba.VoltageLevel][k],
619 						mode_lib->vba.WritebackLatency +
620 						dml32_CalculateWriteBackDelay(
621 								mode_lib->vba.WritebackPixelFormat[j],
622 								mode_lib->vba.WritebackHRatio[j],
623 								mode_lib->vba.WritebackVRatio[j],
624 								mode_lib->vba.WritebackVTaps[j],
625 								mode_lib->vba.WritebackDestinationWidth[j],
626 								mode_lib->vba.WritebackDestinationHeight[j],
627 								mode_lib->vba.WritebackSourceHeight[j],
628 								mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK);
629 				}
630 			}
631 		}
632 	}
633 
634 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
635 		for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j)
636 			if (mode_lib->vba.BlendingAndTiming[k] == j)
637 				v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
638 						v->WritebackDelay[mode_lib->vba.VoltageLevel][j];
639 
640 	v->UrgentLatency = dml32_CalculateUrgentLatency(mode_lib->vba.UrgentLatencyPixelDataOnly,
641 			mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
642 			mode_lib->vba.UrgentLatencyVMDataOnly,
643 			mode_lib->vba.DoUrgentLatencyAdjustment,
644 			mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
645 			mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
646 			mode_lib->vba.FabricClock);
647 
648 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
649 		dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
650 				v->swath_width_luma_ub[k],
651 				v->swath_width_chroma_ub[k],
652 				mode_lib->vba.SwathHeightY[k],
653 				mode_lib->vba.SwathHeightC[k],
654 				mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
655 				v->UrgentLatency,
656 				mode_lib->vba.CursorBufferSize,
657 				mode_lib->vba.CursorWidth[k][0],
658 				mode_lib->vba.CursorBPP[k][0],
659 				mode_lib->vba.VRatio[k],
660 				mode_lib->vba.VRatioChroma[k],
661 				v->BytePerPixelDETY[k],
662 				v->BytePerPixelDETC[k],
663 				mode_lib->vba.DETBufferSizeY[k],
664 				mode_lib->vba.DETBufferSizeC[k],
665 
666 				/* output */
667 				&v->UrgBurstFactorCursor[k],
668 				&v->UrgBurstFactorLuma[k],
669 				&v->UrgBurstFactorChroma[k],
670 				&v->NoUrgentLatencyHiding[k]);
671 
672 		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];
673 	}
674 
675 	v->NotEnoughDETSwathFillLatencyHiding = dml32_CalculateDETSwathFillLatencyHiding(
676 						mode_lib->vba.NumberOfActiveSurfaces,
677 						mode_lib->vba.ReturnBW,
678 						v->UrgentLatency,
679 						mode_lib->vba.SwathHeightY,
680 						mode_lib->vba.SwathHeightC,
681 						v->swath_width_luma_ub,
682 						v->swath_width_chroma_ub,
683 						v->BytePerPixelDETY,
684 						v->BytePerPixelDETC,
685 						mode_lib->vba.DETBufferSizeY,
686 						mode_lib->vba.DETBufferSizeC,
687 						mode_lib->vba.DPPPerPlane,
688 						mode_lib->vba.HTotal,
689 						mode_lib->vba.PixelClock,
690 						mode_lib->vba.VRatio,
691 						mode_lib->vba.VRatioChroma,
692 						mode_lib->vba.UsesMALLForPStateChange,
693 						mode_lib->vba.UseUnboundedRequesting);
694 
695 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
696 		v->MaxVStartupLines[k] = ((mode_lib->vba.Interlace[k] &&
697 				!mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
698 				dml_floor((mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) / 2.0, 1.0) :
699 				mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) - dml_max(1.0,
700 				dml_ceil((double) v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
701 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1));
702 
703 		// Clamp to max OTG vstartup register limit
704 		if (v->MaxVStartupLines[k] > 1023)
705 			v->MaxVStartupLines[k] = 1023;
706 
707 #ifdef __DML_VBA_DEBUG__
708 		dml_print("DML::%s: k=%d MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
709 		dml_print("DML::%s: k=%d VoltageLevel = %d\n", __func__, k, mode_lib->vba.VoltageLevel);
710 		dml_print("DML::%s: k=%d WritebackDelay = %f\n", __func__,
711 				k, v->WritebackDelay[mode_lib->vba.VoltageLevel][k]);
712 #endif
713 	}
714 
715 	v->MaximumMaxVStartupLines = 0;
716 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
717 		v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);
718 
719 	ImmediateFlipRequirementFinal = false;
720 
721 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
722 		ImmediateFlipRequirementFinal = ImmediateFlipRequirementFinal
723 				|| (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
724 	}
725 #ifdef __DML_VBA_DEBUG__
726 	dml_print("DML::%s: ImmediateFlipRequirementFinal = %d\n", __func__, ImmediateFlipRequirementFinal);
727 #endif
728 	// ModeProgramming will not repeat the schedule calculation using different prefetch mode,
729 	//it is just calcualated once with given prefetch mode
730 	dml32_CalculateMinAndMaxPrefetchMode(
731 			mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
732 			&mode_lib->vba.MinPrefetchMode,
733 			&mode_lib->vba.MaxPrefetchMode);
734 
735 	v->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
736 
737 	iteration = 0;
738 	MaxTotalRDBandwidth = 0;
739 	NextPrefetchMode = mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb];
740 
741 	do {
742 		MaxTotalRDBandwidth = 0;
743 		DestinationLineTimesForPrefetchLessThan2 = false;
744 		VRatioPrefetchMoreThanMax = false;
745 #ifdef __DML_VBA_DEBUG__
746 		dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);
747 #endif
748 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
749 			/* NOTE PerfetchMode variable is invalid in DAL as per the input received.
750 			 * Hence the direction is to use PrefetchModePerState.
751 			 */
752 			TWait = dml32_CalculateTWait(
753 				mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
754 				mode_lib->vba.UsesMALLForPStateChange[k],
755 				mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
756 				mode_lib->vba.DRRDisplay[k],
757 				mode_lib->vba.DRAMClockChangeLatency,
758 				mode_lib->vba.FCLKChangeLatency, v->UrgentLatency,
759 				mode_lib->vba.SREnterPlusExitTime);
760 
761 			memset(&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe, 0, sizeof(DmlPipe));
762 
763 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dppclk = mode_lib->vba.DPPCLK[k];
764 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dispclk = mode_lib->vba.DISPCLK;
765 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
766 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCFClkDeepSleep = v->DCFCLKDeepSleep;
767 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
768 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
769 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
770 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
771 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
772 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
773 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
774 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
775 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
776 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
777 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HTotal = mode_lib->vba.HTotal[k];
778 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HActive = mode_lib->vba.HActive[k];
779 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
780 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ODMMode = mode_lib->vba.ODMCombineEnabled[k];
781 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
782 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelY = v->BytePerPixelY[k];
783 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelC = v->BytePerPixelC[k];
784 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
785 			v->ErrorResult[k] = dml32_CalculatePrefetchSchedule(
786 					v,
787 					k,
788 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
789 					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe,
790 					v->DSCDelay[k],
791 					(unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
792 					dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
793 					v->MaxVStartupLines[k],
794 					v->UrgentLatency,
795 					v->UrgentExtraLatency,
796 					v->TCalc,
797 					v->PDEAndMetaPTEBytesFrame[k],
798 					v->MetaRowByte[k],
799 					v->PixelPTEBytesPerRow[k],
800 					v->PrefetchSourceLinesY[k],
801 					v->SwathWidthY[k],
802 					v->VInitPreFillY[k],
803 					v->MaxNumSwathY[k],
804 					v->PrefetchSourceLinesC[k],
805 					v->SwathWidthC[k],
806 					v->VInitPreFillC[k],
807 					v->MaxNumSwathC[k],
808 					v->swath_width_luma_ub[k],
809 					v->swath_width_chroma_ub[k],
810 					v->SwathHeightY[k],
811 					v->SwathHeightC[k],
812 					TWait,
813 					(v->DRAMSpeedPerState[mode_lib->vba.VoltageLevel] <= MEM_STROBE_FREQ_MHZ ||
814 						v->DCFCLKPerState[mode_lib->vba.VoltageLevel] <= DCFCLK_FREQ_EXTRA_PREFETCH_REQ_MHZ) ?
815 							mode_lib->vba.ip.min_prefetch_in_strobe_us : 0,
816 					mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] > 0 || mode_lib->vba.DRAMClockChangeRequirementFinal == false,
817 
818 					/* Output */
819 					&v->DSTXAfterScaler[k],
820 					&v->DSTYAfterScaler[k],
821 					&v->DestinationLinesForPrefetch[k],
822 					&v->PrefetchBandwidth[k],
823 					&v->DestinationLinesToRequestVMInVBlank[k],
824 					&v->DestinationLinesToRequestRowInVBlank[k],
825 					&v->VRatioPrefetchY[k],
826 					&v->VRatioPrefetchC[k],
827 					&v->RequiredPrefetchPixDataBWLuma[k],
828 					&v->RequiredPrefetchPixDataBWChroma[k],
829 					&v->NotEnoughTimeForDynamicMetadata[k],
830 					&v->Tno_bw[k], &v->prefetch_vmrow_bw[k],
831 					&v->Tdmdl_vm[k],
832 					&v->Tdmdl[k],
833 					&v->TSetup[k],
834 					&v->VUpdateOffsetPix[k],
835 					&v->VUpdateWidthPix[k],
836 					&v->VReadyOffsetPix[k]);
837 
838 #ifdef __DML_VBA_DEBUG__
839 			dml_print("DML::%s: k=%0d Prefetch calculation errResult=%0d\n",
840 					__func__, k, mode_lib->vba.ErrorResult[k]);
841 #endif
842 			v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
843 		}
844 
845 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
846 			dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
847 					v->swath_width_luma_ub[k],
848 					v->swath_width_chroma_ub[k],
849 					mode_lib->vba.SwathHeightY[k],
850 					mode_lib->vba.SwathHeightC[k],
851 					mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
852 					v->UrgentLatency,
853 					mode_lib->vba.CursorBufferSize,
854 					mode_lib->vba.CursorWidth[k][0],
855 					mode_lib->vba.CursorBPP[k][0],
856 					v->VRatioPrefetchY[k],
857 					v->VRatioPrefetchC[k],
858 					v->BytePerPixelDETY[k],
859 					v->BytePerPixelDETC[k],
860 					mode_lib->vba.DETBufferSizeY[k],
861 					mode_lib->vba.DETBufferSizeC[k],
862 					/* Output */
863 					&v->UrgBurstFactorCursorPre[k],
864 					&v->UrgBurstFactorLumaPre[k],
865 					&v->UrgBurstFactorChromaPre[k],
866 					&v->NoUrgentLatencyHidingPre[k]);
867 
868 			v->cursor_bw_pre[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] /
869 					8.0 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * v->VRatioPrefetchY[k];
870 
871 #ifdef __DML_VBA_DEBUG__
872 			dml_print("DML::%s: k=%0d DPPPerSurface=%d\n", __func__, k, mode_lib->vba.DPPPerPlane[k]);
873 			dml_print("DML::%s: k=%0d UrgBurstFactorLuma=%f\n", __func__, k, v->UrgBurstFactorLuma[k]);
874 			dml_print("DML::%s: k=%0d UrgBurstFactorChroma=%f\n", __func__, k, v->UrgBurstFactorChroma[k]);
875 			dml_print("DML::%s: k=%0d UrgBurstFactorLumaPre=%f\n", __func__, k,
876 					v->UrgBurstFactorLumaPre[k]);
877 			dml_print("DML::%s: k=%0d UrgBurstFactorChromaPre=%f\n", __func__, k,
878 					v->UrgBurstFactorChromaPre[k]);
879 
880 			dml_print("DML::%s: k=%0d VRatioPrefetchY=%f\n", __func__, k, v->VRatioPrefetchY[k]);
881 			dml_print("DML::%s: k=%0d VRatioY=%f\n", __func__, k, mode_lib->vba.VRatio[k]);
882 
883 			dml_print("DML::%s: k=%0d prefetch_vmrow_bw=%f\n", __func__, k, v->prefetch_vmrow_bw[k]);
884 			dml_print("DML::%s: k=%0d ReadBandwidthSurfaceLuma=%f\n", __func__, k,
885 					v->ReadBandwidthSurfaceLuma[k]);
886 			dml_print("DML::%s: k=%0d ReadBandwidthSurfaceChroma=%f\n", __func__, k,
887 					v->ReadBandwidthSurfaceChroma[k]);
888 			dml_print("DML::%s: k=%0d cursor_bw=%f\n", __func__, k, v->cursor_bw[k]);
889 			dml_print("DML::%s: k=%0d meta_row_bw=%f\n", __func__, k, v->meta_row_bw[k]);
890 			dml_print("DML::%s: k=%0d dpte_row_bw=%f\n", __func__, k, v->dpte_row_bw[k]);
891 			dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWLuma=%f\n", __func__, k,
892 					v->RequiredPrefetchPixDataBWLuma[k]);
893 			dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWChroma=%f\n", __func__, k,
894 					v->RequiredPrefetchPixDataBWChroma[k]);
895 			dml_print("DML::%s: k=%0d cursor_bw_pre=%f\n", __func__, k, v->cursor_bw_pre[k]);
896 			dml_print("DML::%s: k=%0d MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k,
897 					MaxTotalRDBandwidthNoUrgentBurst);
898 #endif
899 			if (v->DestinationLinesForPrefetch[k] < 2)
900 				DestinationLineTimesForPrefetchLessThan2 = true;
901 
902 			if (v->VRatioPrefetchY[k] > v->MaxVRatioPre
903 					|| v->VRatioPrefetchC[k] > v->MaxVRatioPre)
904 				VRatioPrefetchMoreThanMax = true;
905 
906 			//bool DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
907 			//bool DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
908 			//if (v->DestinationLinesToRequestVMInVBlank[k] >= 32) {
909 			//    DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
910 			//}
911 
912 			//if (v->DestinationLinesToRequestRowInVBlank[k] >= 16) {
913 			//    DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
914 			//}
915 		}
916 
917 		v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / mode_lib->vba.ReturnBW;
918 
919 #ifdef __DML_VBA_DEBUG__
920 		dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f\n",
921 				__func__, MaxTotalRDBandwidthNoUrgentBurst);
922 		dml_print("DML::%s: ReturnBW=%f\n", __func__, mode_lib->vba.ReturnBW);
923 		dml_print("DML::%s: FractionOfUrgentBandwidth=%f\n",
924 				__func__, mode_lib->vba.FractionOfUrgentBandwidth);
925 #endif
926 
927 		{
928 			dml32_CalculatePrefetchBandwithSupport(
929 					mode_lib->vba.NumberOfActiveSurfaces,
930 					mode_lib->vba.ReturnBW,
931 					v->NoUrgentLatencyHidingPre,
932 					v->ReadBandwidthSurfaceLuma,
933 					v->ReadBandwidthSurfaceChroma,
934 					v->RequiredPrefetchPixDataBWLuma,
935 					v->RequiredPrefetchPixDataBWChroma,
936 					v->cursor_bw,
937 					v->meta_row_bw,
938 					v->dpte_row_bw,
939 					v->cursor_bw_pre,
940 					v->prefetch_vmrow_bw,
941 					mode_lib->vba.DPPPerPlane,
942 					v->UrgBurstFactorLuma,
943 					v->UrgBurstFactorChroma,
944 					v->UrgBurstFactorCursor,
945 					v->UrgBurstFactorLumaPre,
946 					v->UrgBurstFactorChromaPre,
947 					v->UrgBurstFactorCursorPre,
948 					v->PrefetchBandwidth,
949 					v->VRatio,
950 					v->MaxVRatioPre,
951 
952 					/* output */
953 					&MaxTotalRDBandwidth,
954 					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
955 					&v->PrefetchModeSupported);
956 		}
957 
958 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
959 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector[k] = 1.0;
960 
961 		{
962 			dml32_CalculatePrefetchBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
963 					mode_lib->vba.ReturnBW,
964 					v->NoUrgentLatencyHidingPre,
965 					v->ReadBandwidthSurfaceLuma,
966 					v->ReadBandwidthSurfaceChroma,
967 					v->RequiredPrefetchPixDataBWLuma,
968 					v->RequiredPrefetchPixDataBWChroma,
969 					v->cursor_bw,
970 					v->meta_row_bw,
971 					v->dpte_row_bw,
972 					v->cursor_bw_pre,
973 					v->prefetch_vmrow_bw,
974 					mode_lib->vba.DPPPerPlane,
975 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
976 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
977 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
978 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
979 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
980 					v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
981 					v->PrefetchBandwidth,
982 					v->VRatio,
983 					v->MaxVRatioPre,
984 
985 					/* output */
986 					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
987 					&v->FractionOfUrgentBandwidth,
988 					&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
989 		}
990 
991 		if (VRatioPrefetchMoreThanMax != false || DestinationLineTimesForPrefetchLessThan2 != false) {
992 			v->PrefetchModeSupported = false;
993 		}
994 
995 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
996 			if (v->ErrorResult[k] == true || v->NotEnoughTimeForDynamicMetadata[k]) {
997 				v->PrefetchModeSupported = false;
998 			}
999 		}
1000 
1001 		if (v->PrefetchModeSupported == true && mode_lib->vba.ImmediateFlipSupport == true) {
1002 			mode_lib->vba.BandwidthAvailableForImmediateFlip = dml32_CalculateBandwidthAvailableForImmediateFlip(
1003 					mode_lib->vba.NumberOfActiveSurfaces,
1004 					mode_lib->vba.ReturnBW,
1005 					v->ReadBandwidthSurfaceLuma,
1006 					v->ReadBandwidthSurfaceChroma,
1007 					v->RequiredPrefetchPixDataBWLuma,
1008 					v->RequiredPrefetchPixDataBWChroma,
1009 					v->cursor_bw,
1010 					v->cursor_bw_pre,
1011 					mode_lib->vba.DPPPerPlane,
1012 					v->UrgBurstFactorLuma,
1013 					v->UrgBurstFactorChroma,
1014 					v->UrgBurstFactorCursor,
1015 					v->UrgBurstFactorLumaPre,
1016 					v->UrgBurstFactorChromaPre,
1017 					v->UrgBurstFactorCursorPre);
1018 
1019 			mode_lib->vba.TotImmediateFlipBytes = 0;
1020 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1021 				if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) {
1022 					mode_lib->vba.TotImmediateFlipBytes = mode_lib->vba.TotImmediateFlipBytes
1023 							+ mode_lib->vba.DPPPerPlane[k]
1024 									* (v->PDEAndMetaPTEBytesFrame[k]
1025 											+ v->MetaRowByte[k]);
1026 					if (v->use_one_row_for_frame_flip[k][0][0]) {
1027 						mode_lib->vba.TotImmediateFlipBytes =
1028 								mode_lib->vba.TotImmediateFlipBytes
1029 										+ 2 * v->PixelPTEBytesPerRow[k];
1030 					} else {
1031 						mode_lib->vba.TotImmediateFlipBytes =
1032 								mode_lib->vba.TotImmediateFlipBytes
1033 										+ v->PixelPTEBytesPerRow[k];
1034 					}
1035 				}
1036 			}
1037 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1038 				dml32_CalculateFlipSchedule(v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
1039 						v->UrgentExtraLatency,
1040 						v->UrgentLatency,
1041 						mode_lib->vba.GPUVMMaxPageTableLevels,
1042 						mode_lib->vba.HostVMEnable,
1043 						mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
1044 						mode_lib->vba.GPUVMEnable,
1045 						mode_lib->vba.HostVMMinPageSize,
1046 						v->PDEAndMetaPTEBytesFrame[k],
1047 						v->MetaRowByte[k],
1048 						v->PixelPTEBytesPerRow[k],
1049 						mode_lib->vba.BandwidthAvailableForImmediateFlip,
1050 						mode_lib->vba.TotImmediateFlipBytes,
1051 						mode_lib->vba.SourcePixelFormat[k],
1052 						mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
1053 						mode_lib->vba.VRatio[k],
1054 						mode_lib->vba.VRatioChroma[k],
1055 						v->Tno_bw[k],
1056 						mode_lib->vba.DCCEnable[k],
1057 						v->dpte_row_height[k],
1058 						v->meta_row_height[k],
1059 						v->dpte_row_height_chroma[k],
1060 						v->meta_row_height_chroma[k],
1061 						v->Use_One_Row_For_Frame_Flip[k],
1062 
1063 						/* Output */
1064 						&v->DestinationLinesToRequestVMInImmediateFlip[k],
1065 						&v->DestinationLinesToRequestRowInImmediateFlip[k],
1066 						&v->final_flip_bw[k],
1067 						&v->ImmediateFlipSupportedForPipe[k]);
1068 			}
1069 
1070 			{
1071 				dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1072 						mode_lib->vba.ReturnBW,
1073 						mode_lib->vba.ImmediateFlipRequirement,
1074 						v->final_flip_bw,
1075 						v->ReadBandwidthSurfaceLuma,
1076 						v->ReadBandwidthSurfaceChroma,
1077 						v->RequiredPrefetchPixDataBWLuma,
1078 						v->RequiredPrefetchPixDataBWChroma,
1079 						v->cursor_bw,
1080 						v->meta_row_bw,
1081 						v->dpte_row_bw,
1082 						v->cursor_bw_pre,
1083 						v->prefetch_vmrow_bw,
1084 						mode_lib->vba.DPPPerPlane,
1085 						v->UrgBurstFactorLuma,
1086 						v->UrgBurstFactorChroma,
1087 						v->UrgBurstFactorCursor,
1088 						v->UrgBurstFactorLumaPre,
1089 						v->UrgBurstFactorChromaPre,
1090 						v->UrgBurstFactorCursorPre,
1091 
1092 						/* output */
1093 						&v->total_dcn_read_bw_with_flip,    // Single  *TotalBandwidth
1094 						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],                        // Single  *FractionOfUrgentBandwidth
1095 						&v->ImmediateFlipSupported);        // Boolean *ImmediateFlipBandwidthSupport
1096 
1097 				dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1098 						mode_lib->vba.ReturnBW,
1099 						mode_lib->vba.ImmediateFlipRequirement,
1100 						v->final_flip_bw,
1101 						v->ReadBandwidthSurfaceLuma,
1102 						v->ReadBandwidthSurfaceChroma,
1103 						v->RequiredPrefetchPixDataBWLuma,
1104 						v->RequiredPrefetchPixDataBWChroma,
1105 						v->cursor_bw,
1106 						v->meta_row_bw,
1107 						v->dpte_row_bw,
1108 						v->cursor_bw_pre,
1109 						v->prefetch_vmrow_bw,
1110 						mode_lib->vba.DPPPerPlane,
1111 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1112 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1113 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1114 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1115 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1116 						v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1117 
1118 						/* output */
1119 						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],                                // Single  *TotalBandwidth
1120 						&v->FractionOfUrgentBandwidthImmediateFlip, // Single  *FractionOfUrgentBandwidth
1121 						&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);                              // Boolean *ImmediateFlipBandwidthSupport
1122 			}
1123 
1124 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1125 				if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required && v->ImmediateFlipSupportedForPipe[k] == false) {
1126 					v->ImmediateFlipSupported = false;
1127 #ifdef __DML_VBA_DEBUG__
1128 					dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
1129 #endif
1130 				}
1131 			}
1132 		} else {
1133 			v->ImmediateFlipSupported = false;
1134 		}
1135 
1136 		/* 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) */
1137 		v->PrefetchAndImmediateFlipSupported = (v->PrefetchModeSupported == true &&
1138 				((!mode_lib->vba.ImmediateFlipSupport && !mode_lib->vba.HostVMEnable && !ImmediateFlipRequirementFinal) ||
1139 						v->ImmediateFlipSupported)) ? true : false;
1140 
1141 #ifdef __DML_VBA_DEBUG__
1142 		dml_print("DML::%s: PrefetchModeSupported = %d\n", __func__, locals->PrefetchModeSupported);
1143 		for (uint k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
1144 			dml_print("DML::%s: ImmediateFlipRequirement[%d] = %d\n", __func__, k,  mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
1145 		dml_print("DML::%s: ImmediateFlipSupported = %d\n", __func__, locals->ImmediateFlipSupported);
1146 		dml_print("DML::%s: ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
1147 		dml_print("DML::%s: HostVMEnable = %d\n", __func__, mode_lib->vba.HostVMEnable);
1148 		dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %d\n", __func__, locals->PrefetchAndImmediateFlipSupported);
1149 		dml_print("DML::%s: Done loop: Vstartup=%d, Max Vstartup=%d\n", __func__, locals->VStartupLines, locals->MaximumMaxVStartupLines);
1150 #endif
1151 
1152 		v->VStartupLines = v->VStartupLines + 1;
1153 
1154 		if (v->VStartupLines > v->MaximumMaxVStartupLines) {
1155 #ifdef __DML_VBA_DEBUG__
1156 			dml_print("DML::%s: Vstartup exceeds max vstartup, exiting loop\n", __func__);
1157 #endif
1158 			break; // VBA_DELTA: Implementation divergence! Gabe is *still* iterating across prefetch modes which we don't care to do
1159 		}
1160 		iteration++;
1161 		if (iteration > 2500) {
1162 #ifdef __DML_VBA_DEBUG__
1163 			dml_print("DML::%s: too many errors, exit now\n", __func__);
1164 			assert(0);
1165 #endif
1166 		}
1167 	} while (!(v->PrefetchAndImmediateFlipSupported || NextPrefetchMode > mode_lib->vba.MaxPrefetchMode));
1168 
1169 
1170 	if (v->VStartupLines <= v->MaximumMaxVStartupLines) {
1171 #ifdef __DML_VBA_DEBUG__
1172 		dml_print("DML::%s: Good, Prefetch and flip scheduling found solution at VStartupLines=%d\n", __func__, locals->VStartupLines-1);
1173 #endif
1174 	}
1175 
1176 
1177 	//Watermarks and NB P-State/DRAM Clock Change Support
1178 	{
1179 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.UrgentLatency = v->UrgentLatency;
1180 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.ExtraLatency = v->UrgentExtraLatency;
1181 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
1182 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
1183 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
1184 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
1185 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
1186 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
1187 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
1188 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
1189 		v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
1190 
1191 		dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
1192 			v,
1193 			v->PrefetchModePerState[v->VoltageLevel][v->maxMpcComb],
1194 			v->DCFCLK,
1195 			v->ReturnBW,
1196 			v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters,
1197 			v->SOCCLK,
1198 			v->DCFCLKDeepSleep,
1199 			v->DETBufferSizeY,
1200 			v->DETBufferSizeC,
1201 			v->SwathHeightY,
1202 			v->SwathHeightC,
1203 			v->SwathWidthY,
1204 			v->SwathWidthC,
1205 			v->DPPPerPlane,
1206 			v->BytePerPixelDETY,
1207 			v->BytePerPixelDETC,
1208 			v->DSTXAfterScaler,
1209 			v->DSTYAfterScaler,
1210 			v->UnboundedRequestEnabled,
1211 			v->CompressedBufferSizeInkByte,
1212 
1213 			/* Output */
1214 			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_dramchange_support,
1215 			v->MaxActiveDRAMClockChangeLatencySupported,
1216 			v->SubViewportLinesNeededInMALL,
1217 			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_fclkchange_support,
1218 			&v->MinActiveFCLKChangeLatencySupported,
1219 			&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_USRRetrainingSupport,
1220 			mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);
1221 
1222 		/* DCN32 has a new struct Watermarks (typedef) which is used to store
1223 		 * calculated WM values. Copy over values from struct to vba varaibles
1224 		 * to ensure that the DCN32 getters return the correct value.
1225 		 */
1226 		v->UrgentWatermark = v->Watermark.UrgentWatermark;
1227 		v->WritebackUrgentWatermark = v->Watermark.WritebackUrgentWatermark;
1228 		v->DRAMClockChangeWatermark = v->Watermark.DRAMClockChangeWatermark;
1229 		v->WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark;
1230 		v->StutterExitWatermark = v->Watermark.StutterExitWatermark;
1231 		v->StutterEnterPlusExitWatermark = v->Watermark.StutterEnterPlusExitWatermark;
1232 		v->Z8StutterExitWatermark = v->Watermark.Z8StutterExitWatermark;
1233 		v->Z8StutterEnterPlusExitWatermark = v->Watermark.Z8StutterEnterPlusExitWatermark;
1234 
1235 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1236 			if (mode_lib->vba.WritebackEnable[k] == true) {
1237 				v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
1238 						v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1239 								- v->Watermark.WritebackDRAMClockChangeWatermark);
1240 				v->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0,
1241 						v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1242 								- v->Watermark.WritebackFCLKChangeWatermark);
1243 			} else {
1244 				v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
1245 				v->WritebackAllowFCLKChangeEndPosition[k] = 0;
1246 			}
1247 		}
1248 	}
1249 
1250 	//Display Pipeline Delivery Time in Prefetch, Groups
1251 	dml32_CalculatePixelDeliveryTimes(
1252 			mode_lib->vba.NumberOfActiveSurfaces,
1253 			mode_lib->vba.VRatio,
1254 			mode_lib->vba.VRatioChroma,
1255 			v->VRatioPrefetchY,
1256 			v->VRatioPrefetchC,
1257 			v->swath_width_luma_ub,
1258 			v->swath_width_chroma_ub,
1259 			mode_lib->vba.DPPPerPlane,
1260 			mode_lib->vba.HRatio,
1261 			mode_lib->vba.HRatioChroma,
1262 			mode_lib->vba.PixelClock,
1263 			v->PSCL_THROUGHPUT_LUMA,
1264 			v->PSCL_THROUGHPUT_CHROMA,
1265 			mode_lib->vba.DPPCLK,
1266 			v->BytePerPixelC,
1267 			mode_lib->vba.SourceRotation,
1268 			mode_lib->vba.NumberOfCursors,
1269 			mode_lib->vba.CursorWidth,
1270 			mode_lib->vba.CursorBPP,
1271 			v->BlockWidth256BytesY,
1272 			v->BlockHeight256BytesY,
1273 			v->BlockWidth256BytesC,
1274 			v->BlockHeight256BytesC,
1275 
1276 			/* Output */
1277 			v->DisplayPipeLineDeliveryTimeLuma,
1278 			v->DisplayPipeLineDeliveryTimeChroma,
1279 			v->DisplayPipeLineDeliveryTimeLumaPrefetch,
1280 			v->DisplayPipeLineDeliveryTimeChromaPrefetch,
1281 			v->DisplayPipeRequestDeliveryTimeLuma,
1282 			v->DisplayPipeRequestDeliveryTimeChroma,
1283 			v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
1284 			v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
1285 			v->CursorRequestDeliveryTime,
1286 			v->CursorRequestDeliveryTimePrefetch);
1287 
1288 	dml32_CalculateMetaAndPTETimes(v->Use_One_Row_For_Frame,
1289 			mode_lib->vba.NumberOfActiveSurfaces,
1290 			mode_lib->vba.GPUVMEnable,
1291 			mode_lib->vba.MetaChunkSize,
1292 			mode_lib->vba.MinMetaChunkSizeBytes,
1293 			mode_lib->vba.HTotal,
1294 			mode_lib->vba.VRatio,
1295 			mode_lib->vba.VRatioChroma,
1296 			v->DestinationLinesToRequestRowInVBlank,
1297 			v->DestinationLinesToRequestRowInImmediateFlip,
1298 			mode_lib->vba.DCCEnable,
1299 			mode_lib->vba.PixelClock,
1300 			v->BytePerPixelY,
1301 			v->BytePerPixelC,
1302 			mode_lib->vba.SourceRotation,
1303 			v->dpte_row_height,
1304 			v->dpte_row_height_chroma,
1305 			v->meta_row_width,
1306 			v->meta_row_width_chroma,
1307 			v->meta_row_height,
1308 			v->meta_row_height_chroma,
1309 			v->meta_req_width,
1310 			v->meta_req_width_chroma,
1311 			v->meta_req_height,
1312 			v->meta_req_height_chroma,
1313 			v->dpte_group_bytes,
1314 			v->PTERequestSizeY,
1315 			v->PTERequestSizeC,
1316 			v->PixelPTEReqWidthY,
1317 			v->PixelPTEReqHeightY,
1318 			v->PixelPTEReqWidthC,
1319 			v->PixelPTEReqHeightC,
1320 			v->dpte_row_width_luma_ub,
1321 			v->dpte_row_width_chroma_ub,
1322 
1323 			/* Output */
1324 			v->DST_Y_PER_PTE_ROW_NOM_L,
1325 			v->DST_Y_PER_PTE_ROW_NOM_C,
1326 			v->DST_Y_PER_META_ROW_NOM_L,
1327 			v->DST_Y_PER_META_ROW_NOM_C,
1328 			v->TimePerMetaChunkNominal,
1329 			v->TimePerChromaMetaChunkNominal,
1330 			v->TimePerMetaChunkVBlank,
1331 			v->TimePerChromaMetaChunkVBlank,
1332 			v->TimePerMetaChunkFlip,
1333 			v->TimePerChromaMetaChunkFlip,
1334 			v->time_per_pte_group_nom_luma,
1335 			v->time_per_pte_group_vblank_luma,
1336 			v->time_per_pte_group_flip_luma,
1337 			v->time_per_pte_group_nom_chroma,
1338 			v->time_per_pte_group_vblank_chroma,
1339 			v->time_per_pte_group_flip_chroma);
1340 
1341 	dml32_CalculateVMGroupAndRequestTimes(
1342 			mode_lib->vba.NumberOfActiveSurfaces,
1343 			mode_lib->vba.GPUVMEnable,
1344 			mode_lib->vba.GPUVMMaxPageTableLevels,
1345 			mode_lib->vba.HTotal,
1346 			v->BytePerPixelC,
1347 			v->DestinationLinesToRequestVMInVBlank,
1348 			v->DestinationLinesToRequestVMInImmediateFlip,
1349 			mode_lib->vba.DCCEnable,
1350 			mode_lib->vba.PixelClock,
1351 			v->dpte_row_width_luma_ub,
1352 			v->dpte_row_width_chroma_ub,
1353 			v->vm_group_bytes,
1354 			v->dpde0_bytes_per_frame_ub_l,
1355 			v->dpde0_bytes_per_frame_ub_c,
1356 			v->meta_pte_bytes_per_frame_ub_l,
1357 			v->meta_pte_bytes_per_frame_ub_c,
1358 
1359 			/* Output */
1360 			v->TimePerVMGroupVBlank,
1361 			v->TimePerVMGroupFlip,
1362 			v->TimePerVMRequestVBlank,
1363 			v->TimePerVMRequestFlip);
1364 
1365 	// Min TTUVBlank
1366 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1367 		if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
1368 			v->MinTTUVBlank[k] = dml_max4(v->Watermark.DRAMClockChangeWatermark,
1369 					v->Watermark.FCLKChangeWatermark, v->Watermark.StutterEnterPlusExitWatermark,
1370 					v->Watermark.UrgentWatermark);
1371 		} else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1372 				== 1) {
1373 			v->MinTTUVBlank[k] = dml_max3(v->Watermark.FCLKChangeWatermark,
1374 					v->Watermark.StutterEnterPlusExitWatermark, v->Watermark.UrgentWatermark);
1375 		} else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1376 				== 2) {
1377 			v->MinTTUVBlank[k] = dml_max(v->Watermark.StutterEnterPlusExitWatermark,
1378 					v->Watermark.UrgentWatermark);
1379 		} else {
1380 			v->MinTTUVBlank[k] = v->Watermark.UrgentWatermark;
1381 		}
1382 		if (!mode_lib->vba.DynamicMetadataEnable[k])
1383 			v->MinTTUVBlank[k] = mode_lib->vba.TCalc + v->MinTTUVBlank[k];
1384 	}
1385 
1386 	// DCC Configuration
1387 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1388 #ifdef __DML_VBA_DEBUG__
1389 		dml_print("DML::%s: Calculate DCC configuration for surface k=%d\n", __func__, k);
1390 #endif
1391 		dml32_CalculateDCCConfiguration(
1392 				mode_lib->vba.DCCEnable[k],
1393 				mode_lib->vba.DCCProgrammingAssumesScanDirectionUnknownFinal,
1394 				mode_lib->vba.SourcePixelFormat[k], mode_lib->vba.SurfaceWidthY[k],
1395 				mode_lib->vba.SurfaceWidthC[k],
1396 				mode_lib->vba.SurfaceHeightY[k],
1397 				mode_lib->vba.SurfaceHeightC[k],
1398 				mode_lib->vba.nomDETInKByte,
1399 				v->BlockHeight256BytesY[k],
1400 				v->BlockHeight256BytesC[k],
1401 				mode_lib->vba.SurfaceTiling[k],
1402 				v->BytePerPixelY[k],
1403 				v->BytePerPixelC[k],
1404 				v->BytePerPixelDETY[k],
1405 				v->BytePerPixelDETC[k],
1406 				(enum dm_rotation_angle) mode_lib->vba.SourceScan[k],
1407 				/* Output */
1408 				&v->DCCYMaxUncompressedBlock[k],
1409 				&v->DCCCMaxUncompressedBlock[k],
1410 				&v->DCCYMaxCompressedBlock[k],
1411 				&v->DCCCMaxCompressedBlock[k],
1412 				&v->DCCYIndependentBlock[k],
1413 				&v->DCCCIndependentBlock[k]);
1414 	}
1415 
1416 	// VStartup Adjustment
1417 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1418 		bool isInterlaceTiming;
1419 		double Tvstartup_margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * mode_lib->vba.HTotal[k]
1420 				/ mode_lib->vba.PixelClock[k];
1421 #ifdef __DML_VBA_DEBUG__
1422 		dml_print("DML::%s: k=%d, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k,
1423 				v->MinTTUVBlank[k]);
1424 #endif
1425 
1426 		v->MinTTUVBlank[k] = v->MinTTUVBlank[k] + Tvstartup_margin;
1427 
1428 #ifdef __DML_VBA_DEBUG__
1429 		dml_print("DML::%s: k=%d, Tvstartup_margin = %f\n", __func__, k, Tvstartup_margin);
1430 		dml_print("DML::%s: k=%d, MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
1431 		dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1432 		dml_print("DML::%s: k=%d, MinTTUVBlank = %f\n", __func__, k, v->MinTTUVBlank[k]);
1433 #endif
1434 
1435 		v->Tdmdl[k] = v->Tdmdl[k] + Tvstartup_margin;
1436 		if (mode_lib->vba.DynamicMetadataEnable[k] && mode_lib->vba.DynamicMetadataVMEnabled)
1437 			v->Tdmdl_vm[k] = v->Tdmdl_vm[k] + Tvstartup_margin;
1438 
1439 		isInterlaceTiming = (mode_lib->vba.Interlace[k] &&
1440 				!mode_lib->vba.ProgressiveToInterlaceUnitInOPP);
1441 
1442 		v->MIN_DST_Y_NEXT_START[k] = ((isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k] -
1443 						mode_lib->vba.VFrontPorch[k]) / 2.0, 1.0) :
1444 						mode_lib->vba.VTotal[k]) - mode_lib->vba.VFrontPorch[k])
1445 						+ dml_max(1.0,
1446 						dml_ceil(v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
1447 						/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0))
1448 						+ dml_floor(4.0 * v->TSetup[k] / (mode_lib->vba.HTotal[k]
1449 						/ mode_lib->vba.PixelClock[k]), 1.0) / 4.0;
1450 
1451 		v->VStartup[k] = (isInterlaceTiming ? (2 * v->MaxVStartupLines[k]) : v->MaxVStartupLines[k]);
1452 
1453 		if (((v->VUpdateOffsetPix[k] + v->VUpdateWidthPix[k] + v->VReadyOffsetPix[k])
1454 			/ mode_lib->vba.HTotal[k]) <= (isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k]
1455 			- mode_lib->vba.VActive[k] - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]) / 2.0, 1.0) :
1456 			(int) (mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
1457 		       - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]))) {
1458 			v->VREADY_AT_OR_AFTER_VSYNC[k] = true;
1459 		} else {
1460 			v->VREADY_AT_OR_AFTER_VSYNC[k] = false;
1461 		}
1462 #ifdef __DML_VBA_DEBUG__
1463 		dml_print("DML::%s: k=%d, VStartup = %d (max)\n", __func__, k, v->VStartup[k]);
1464 		dml_print("DML::%s: k=%d, VUpdateOffsetPix = %d\n", __func__, k, v->VUpdateOffsetPix[k]);
1465 		dml_print("DML::%s: k=%d, VUpdateWidthPix = %d\n", __func__, k, v->VUpdateWidthPix[k]);
1466 		dml_print("DML::%s: k=%d, VReadyOffsetPix = %d\n", __func__, k, v->VReadyOffsetPix[k]);
1467 		dml_print("DML::%s: k=%d, HTotal = %d\n", __func__, k, mode_lib->vba.HTotal[k]);
1468 		dml_print("DML::%s: k=%d, VTotal = %d\n", __func__, k, mode_lib->vba.VTotal[k]);
1469 		dml_print("DML::%s: k=%d, VActive = %d\n", __func__, k, mode_lib->vba.VActive[k]);
1470 		dml_print("DML::%s: k=%d, VFrontPorch = %d\n", __func__, k, mode_lib->vba.VFrontPorch[k]);
1471 		dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1472 		dml_print("DML::%s: k=%d, TSetup = %f\n", __func__, k, v->TSetup[k]);
1473 		dml_print("DML::%s: k=%d, MIN_DST_Y_NEXT_START = %f\n", __func__, k, v->MIN_DST_Y_NEXT_START[k]);
1474 		dml_print("DML::%s: k=%d, VREADY_AT_OR_AFTER_VSYNC = %d\n", __func__, k,
1475 				v->VREADY_AT_OR_AFTER_VSYNC[k]);
1476 #endif
1477 	}
1478 
1479 	{
1480 		//Maximum Bandwidth Used
1481 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1482 			if (mode_lib->vba.WritebackEnable[k] == true
1483 					&& mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
1484 				WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1485 						* mode_lib->vba.WritebackDestinationHeight[k]
1486 						/ (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1487 								/ mode_lib->vba.PixelClock[k]) * 4;
1488 			} else if (mode_lib->vba.WritebackEnable[k] == true) {
1489 				WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1490 						* mode_lib->vba.WritebackDestinationHeight[k]
1491 						/ (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1492 								/ mode_lib->vba.PixelClock[k]) * 8;
1493 			}
1494 			TotalWRBandwidth = TotalWRBandwidth + WRBandwidth;
1495 		}
1496 
1497 		v->TotalDataReadBandwidth = 0;
1498 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1499 			v->TotalDataReadBandwidth = v->TotalDataReadBandwidth + v->ReadBandwidthSurfaceLuma[k]
1500 					+ v->ReadBandwidthSurfaceChroma[k];
1501 #ifdef __DML_VBA_DEBUG__
1502 			dml_print("DML::%s: k=%d, TotalDataReadBandwidth = %f\n",
1503 					__func__, k, v->TotalDataReadBandwidth);
1504 			dml_print("DML::%s: k=%d, ReadBandwidthSurfaceLuma = %f\n",
1505 					__func__, k, v->ReadBandwidthSurfaceLuma[k]);
1506 			dml_print("DML::%s: k=%d, ReadBandwidthSurfaceChroma = %f\n",
1507 					__func__, k, v->ReadBandwidthSurfaceChroma[k]);
1508 #endif
1509 		}
1510 	}
1511 
1512 	// Stutter Efficiency
1513 	dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1514 			mode_lib->vba.UsesMALLForPStateChange,
1515 			v->UnboundedRequestEnabled,
1516 			mode_lib->vba.MetaFIFOSizeInKEntries,
1517 			mode_lib->vba.ZeroSizeBufferEntries,
1518 			mode_lib->vba.PixelChunkSizeInKByte,
1519 			mode_lib->vba.NumberOfActiveSurfaces,
1520 			mode_lib->vba.ROBBufferSizeInKByte,
1521 			v->TotalDataReadBandwidth,
1522 			mode_lib->vba.DCFCLK,
1523 			mode_lib->vba.ReturnBW,
1524 			v->CompbufReservedSpace64B,
1525 			v->CompbufReservedSpaceZs,
1526 			mode_lib->vba.SRExitTime,
1527 			mode_lib->vba.SRExitZ8Time,
1528 			mode_lib->vba.SynchronizeTimingsFinal,
1529 			mode_lib->vba.BlendingAndTiming,
1530 			v->Watermark.StutterEnterPlusExitWatermark,
1531 			v->Watermark.Z8StutterEnterPlusExitWatermark,
1532 			mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1533 			mode_lib->vba.Interlace,
1534 			v->MinTTUVBlank, mode_lib->vba.DPPPerPlane,
1535 			mode_lib->vba.DETBufferSizeY,
1536 			v->BytePerPixelY,
1537 			v->BytePerPixelDETY,
1538 			v->SwathWidthY,
1539 			mode_lib->vba.SwathHeightY,
1540 			mode_lib->vba.SwathHeightC,
1541 			mode_lib->vba.DCCRateLuma,
1542 			mode_lib->vba.DCCRateChroma,
1543 			mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1544 			mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1545 			mode_lib->vba.HTotal, mode_lib->vba.VTotal,
1546 			mode_lib->vba.PixelClock,
1547 			mode_lib->vba.VRatio,
1548 			mode_lib->vba.SourceRotation,
1549 			v->BlockHeight256BytesY,
1550 			v->BlockWidth256BytesY,
1551 			v->BlockHeight256BytesC,
1552 			v->BlockWidth256BytesC,
1553 			v->DCCYMaxUncompressedBlock,
1554 			v->DCCCMaxUncompressedBlock,
1555 			mode_lib->vba.VActive,
1556 			mode_lib->vba.DCCEnable,
1557 			mode_lib->vba.WritebackEnable,
1558 			v->ReadBandwidthSurfaceLuma,
1559 			v->ReadBandwidthSurfaceChroma,
1560 			v->meta_row_bw,
1561 			v->dpte_row_bw,
1562 			/* Output */
1563 			&v->StutterEfficiencyNotIncludingVBlank,
1564 			&v->StutterEfficiency,
1565 			&v->NumberOfStutterBurstsPerFrame,
1566 			&v->Z8StutterEfficiencyNotIncludingVBlank,
1567 			&v->Z8StutterEfficiency,
1568 			&v->Z8NumberOfStutterBurstsPerFrame,
1569 			&v->StutterPeriod,
1570 			&v->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
1571 
1572 #ifdef __DML_VBA_ALLOW_DELTA__
1573 	{
1574 		unsigned int dummy_integer[1];
1575 
1576 		// Calculate z8 stutter eff assuming 0 reserved space
1577 		dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1578 				mode_lib->vba.UsesMALLForPStateChange,
1579 				v->UnboundedRequestEnabled,
1580 				mode_lib->vba.MetaFIFOSizeInKEntries,
1581 				mode_lib->vba.ZeroSizeBufferEntries,
1582 				mode_lib->vba.PixelChunkSizeInKByte,
1583 				mode_lib->vba.NumberOfActiveSurfaces,
1584 				mode_lib->vba.ROBBufferSizeInKByte,
1585 				v->TotalDataReadBandwidth,
1586 				mode_lib->vba.DCFCLK,
1587 				mode_lib->vba.ReturnBW,
1588 				0, //CompbufReservedSpace64B,
1589 				0, //CompbufReservedSpaceZs,
1590 				mode_lib->vba.SRExitTime,
1591 				mode_lib->vba.SRExitZ8Time,
1592 				mode_lib->vba.SynchronizeTimingsFinal,
1593 				mode_lib->vba.BlendingAndTiming,
1594 				v->Watermark.StutterEnterPlusExitWatermark,
1595 				v->Watermark.Z8StutterEnterPlusExitWatermark,
1596 				mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1597 				mode_lib->vba.Interlace,
1598 				v->MinTTUVBlank,
1599 				mode_lib->vba.DPPPerPlane,
1600 				mode_lib->vba.DETBufferSizeY,
1601 				v->BytePerPixelY, v->BytePerPixelDETY,
1602 				v->SwathWidthY, mode_lib->vba.SwathHeightY,
1603 				mode_lib->vba.SwathHeightC,
1604 				mode_lib->vba.DCCRateLuma,
1605 				mode_lib->vba.DCCRateChroma,
1606 				mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1607 				mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1608 				mode_lib->vba.HTotal,
1609 				mode_lib->vba.VTotal,
1610 				mode_lib->vba.PixelClock,
1611 				mode_lib->vba.VRatio,
1612 				mode_lib->vba.SourceRotation,
1613 				v->BlockHeight256BytesY,
1614 				v->BlockWidth256BytesY,
1615 				v->BlockHeight256BytesC,
1616 				v->BlockWidth256BytesC,
1617 				v->DCCYMaxUncompressedBlock,
1618 				v->DCCCMaxUncompressedBlock,
1619 				mode_lib->vba.VActive,
1620 				mode_lib->vba.DCCEnable,
1621 				mode_lib->vba.WritebackEnable,
1622 				v->ReadBandwidthSurfaceLuma,
1623 				v->ReadBandwidthSurfaceChroma,
1624 				v->meta_row_bw, v->dpte_row_bw,
1625 
1626 				/* Output */
1627 				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
1628 				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],
1629 				&dummy_integer[0],
1630 				&v->Z8StutterEfficiencyNotIncludingVBlankBestCase,
1631 				&v->Z8StutterEfficiencyBestCase,
1632 				&v->Z8NumberOfStutterBurstsPerFrameBestCase,
1633 				&v->StutterPeriodBestCase,
1634 				&v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
1635 	}
1636 #else
1637 	v->Z8StutterEfficiencyNotIncludingVBlankBestCase = v->Z8StutterEfficiencyNotIncludingVBlank;
1638 	v->Z8StutterEfficiencyBestCase = v->Z8StutterEfficiency;
1639 	v->Z8NumberOfStutterBurstsPerFrameBestCase = v->Z8NumberOfStutterBurstsPerFrame;
1640 	v->StutterPeriodBestCase = v->StutterPeriod;
1641 #endif
1642 
1643 #ifdef __DML_VBA_DEBUG__
1644 	dml_print("DML::%s: --- END ---\n", __func__);
1645 #endif
1646 }
1647 
mode_support_configuration(struct vba_vars_st * v,struct display_mode_lib * mode_lib)1648 static void mode_support_configuration(struct vba_vars_st *v,
1649 				  struct display_mode_lib *mode_lib)
1650 {
1651 	int i, j, start_state;
1652 
1653 	if (mode_lib->validate_max_state)
1654 		start_state = v->soc.num_states - 1;
1655 	else
1656 		start_state = 0;
1657 
1658 	for (i = v->soc.num_states - 1; i >= start_state; i--) {
1659 		for (j = 0; j < 2; j++) {
1660 			if (mode_lib->vba.ScaleRatioAndTapsSupport == true
1661 				&& mode_lib->vba.SourceFormatPixelAndScanSupport == true
1662 				&& mode_lib->vba.ViewportSizeSupport[i][j] == true
1663 				&& !mode_lib->vba.LinkRateDoesNotMatchDPVersion
1664 				&& !mode_lib->vba.LinkRateForMultistreamNotIndicated
1665 				&& !mode_lib->vba.BPPForMultistreamNotIndicated
1666 				&& !mode_lib->vba.MultistreamWithHDMIOreDP
1667 				&& !mode_lib->vba.ExceededMultistreamSlots[i]
1668 				&& !mode_lib->vba.MSOOrODMSplitWithNonDPLink
1669 				&& !mode_lib->vba.NotEnoughLanesForMSO
1670 				&& mode_lib->vba.LinkCapacitySupport[i] == true && !mode_lib->vba.P2IWith420
1671 				//&& !mode_lib->vba.DSCOnlyIfNecessaryWithBPP
1672 				&& !mode_lib->vba.DSC422NativeNotSupported
1673 				&& !mode_lib->vba.MPCCombineMethodIncompatible
1674 				&& mode_lib->vba.ODMCombine2To1SupportCheckOK[i] == true
1675 				&& mode_lib->vba.ODMCombine4To1SupportCheckOK[i] == true
1676 				&& mode_lib->vba.NotEnoughDSCUnits[i] == false
1677 				&& !mode_lib->vba.NotEnoughDSCSlices[i]
1678 				&& !mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
1679 				&& !mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
1680 				&& mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] == false
1681 				&& mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i]
1682 				&& mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] == false
1683 				&& !mode_lib->vba.InvalidCombinationOfMALLUseForPState
1684 				&& !mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
1685 				&& mode_lib->vba.ROBSupport[i][j] == true
1686 				&& mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] == true
1687 				&& mode_lib->vba.TotalAvailablePipesSupport[i][j] == true
1688 				&& mode_lib->vba.NumberOfOTGSupport == true
1689 				&& mode_lib->vba.NumberOfHDMIFRLSupport == true
1690 				&& mode_lib->vba.EnoughWritebackUnits == true
1691 				&& mode_lib->vba.WritebackLatencySupport == true
1692 				&& mode_lib->vba.WritebackScaleRatioAndTapsSupport == true
1693 				&& mode_lib->vba.CursorSupport == true && mode_lib->vba.PitchSupport == true
1694 				&& mode_lib->vba.ViewportExceedsSurface == false
1695 				&& mode_lib->vba.PrefetchSupported[i][j] == true
1696 				&& mode_lib->vba.VActiveBandwithSupport[i][j] == true
1697 				&& mode_lib->vba.DynamicMetadataSupported[i][j] == true
1698 				&& mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] == true
1699 				&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true
1700 				&& mode_lib->vba.PTEBufferSizeNotExceeded[i][j] == true
1701 				&& mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] == true
1702 				&& mode_lib->vba.NonsupportedDSCInputBPC == false
1703 				&& !mode_lib->vba.ExceededMALLSize
1704 				&& (mode_lib->vba.NotEnoughDETSwathFillLatencyHidingPerState[i][j] == false
1705 				|| i == v->soc.num_states - 1)
1706 				&& ((mode_lib->vba.HostVMEnable == false
1707 				&& !mode_lib->vba.ImmediateFlipRequiredFinal)
1708 				|| mode_lib->vba.ImmediateFlipSupportedForState[i][j])
1709 				&& (!mode_lib->vba.DRAMClockChangeRequirementFinal
1710 				|| i == v->soc.num_states - 1
1711 				|| mode_lib->vba.DRAMClockChangeSupport[i][j] != dm_dram_clock_change_unsupported)
1712 				&& (!mode_lib->vba.FCLKChangeRequirementFinal || i == v->soc.num_states - 1
1713 				|| mode_lib->vba.FCLKChangeSupport[i][j] != dm_fclock_change_unsupported)
1714 				&& (!mode_lib->vba.USRRetrainingRequiredFinal
1715 				|| mode_lib->vba.USRRetrainingSupport[i][j])) {
1716 				mode_lib->vba.ModeSupport[i][j] = true;
1717 			} else {
1718 				mode_lib->vba.ModeSupport[i][j] = false;
1719 			}
1720 		}
1721 	}
1722 }
1723 
dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib * mode_lib)1724 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
1725 {
1726 	struct vba_vars_st *v = &mode_lib->vba;
1727 	int i, j, start_state;
1728 	unsigned int k, m;
1729 	unsigned int MaximumMPCCombine;
1730 	unsigned int NumberOfNonCombinedSurfaceOfMaximumBandwidth;
1731 	unsigned int TotalSlots;
1732 	bool CompBufReservedSpaceNeedAdjustment;
1733 	bool CompBufReservedSpaceNeedAdjustmentSingleDPP;
1734 
1735 #ifdef __DML_VBA_DEBUG__
1736 	dml_print("DML::%s: called\n", __func__);
1737 #endif
1738 
1739 	/*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
1740 	if (mode_lib->validate_max_state)
1741 		start_state = v->soc.num_states - 1;
1742 	else
1743 		start_state = 0;
1744 
1745 	/*Scale Ratio, taps Support Check*/
1746 
1747 	mode_lib->vba.ScaleRatioAndTapsSupport = true;
1748 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1749 		if (mode_lib->vba.ScalerEnabled[k] == false
1750 				&& ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1751 						&& mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1752 						&& mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1753 						&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1754 						&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1755 						&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1756 						&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha)
1757 						|| mode_lib->vba.HRatio[k] != 1.0 || mode_lib->vba.htaps[k] != 1.0
1758 						|| mode_lib->vba.VRatio[k] != 1.0 || mode_lib->vba.vtaps[k] != 1.0)) {
1759 			mode_lib->vba.ScaleRatioAndTapsSupport = false;
1760 		} else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0 || mode_lib->vba.htaps[k] < 1.0
1761 				|| mode_lib->vba.htaps[k] > 8.0
1762 				|| (mode_lib->vba.htaps[k] > 1.0 && (mode_lib->vba.htaps[k] % 2) == 1)
1763 				|| mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
1764 				|| mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
1765 				|| mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
1766 				|| mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
1767 				|| (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1768 						&& mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1769 						&& mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1770 						&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1771 						&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1772 						&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1773 						&& (mode_lib->vba.VTAPsChroma[k] < 1
1774 								|| mode_lib->vba.VTAPsChroma[k] > 8
1775 								|| mode_lib->vba.HTAPsChroma[k] < 1
1776 								|| mode_lib->vba.HTAPsChroma[k] > 8
1777 								|| (mode_lib->vba.HTAPsChroma[k] > 1
1778 										&& mode_lib->vba.HTAPsChroma[k] % 2
1779 												== 1)
1780 								|| mode_lib->vba.HRatioChroma[k]
1781 										> mode_lib->vba.MaxHSCLRatio
1782 								|| mode_lib->vba.VRatioChroma[k]
1783 										> mode_lib->vba.MaxVSCLRatio
1784 								|| mode_lib->vba.HRatioChroma[k]
1785 										> mode_lib->vba.HTAPsChroma[k]
1786 								|| mode_lib->vba.VRatioChroma[k]
1787 										> mode_lib->vba.VTAPsChroma[k]))) {
1788 			mode_lib->vba.ScaleRatioAndTapsSupport = false;
1789 		}
1790 	}
1791 
1792 	/*Source Format, Pixel Format and Scan Support Check*/
1793 	mode_lib->vba.SourceFormatPixelAndScanSupport = true;
1794 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1795 		if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
1796 			&& (!(!IsVertical((enum dm_rotation_angle) mode_lib->vba.SourceScan[k]))
1797 				|| mode_lib->vba.DCCEnable[k] == true)) {
1798 			mode_lib->vba.SourceFormatPixelAndScanSupport = false;
1799 		}
1800 	}
1801 
1802 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1803 		dml32_CalculateBytePerPixelAndBlockSizes(
1804 				mode_lib->vba.SourcePixelFormat[k],
1805 				mode_lib->vba.SurfaceTiling[k],
1806 
1807 				/* Output */
1808 				&mode_lib->vba.BytePerPixelY[k],
1809 				&mode_lib->vba.BytePerPixelC[k],
1810 				&mode_lib->vba.BytePerPixelInDETY[k],
1811 				&mode_lib->vba.BytePerPixelInDETC[k],
1812 				&mode_lib->vba.Read256BlockHeightY[k],
1813 				&mode_lib->vba.Read256BlockHeightC[k],
1814 				&mode_lib->vba.Read256BlockWidthY[k],
1815 				&mode_lib->vba.Read256BlockWidthC[k],
1816 				&mode_lib->vba.MacroTileHeightY[k],
1817 				&mode_lib->vba.MacroTileHeightC[k],
1818 				&mode_lib->vba.MacroTileWidthY[k],
1819 				&mode_lib->vba.MacroTileWidthC[k]);
1820 	}
1821 
1822 	/*Bandwidth Support Check*/
1823 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1824 		if (!IsVertical(mode_lib->vba.SourceRotation[k])) {
1825 			v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
1826 			v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportWidthChroma[k];
1827 		} else {
1828 			v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
1829 			v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportHeightChroma[k];
1830 		}
1831 	}
1832 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1833 		v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0)
1834 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
1835 		v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0)
1836 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]
1837 				/ 2.0;
1838 	}
1839 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1840 		if (mode_lib->vba.WritebackEnable[k] == true && mode_lib->vba.WritebackPixelFormat[k] == dm_444_64) {
1841 			v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1842 					* mode_lib->vba.WritebackDestinationHeight[k]
1843 					/ (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1844 							/ mode_lib->vba.PixelClock[k]) * 8.0;
1845 		} else if (mode_lib->vba.WritebackEnable[k] == true) {
1846 			v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1847 					* mode_lib->vba.WritebackDestinationHeight[k]
1848 					/ (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1849 							/ mode_lib->vba.PixelClock[k]) * 4.0;
1850 		} else {
1851 			v->WriteBandwidth[k] = 0.0;
1852 		}
1853 	}
1854 
1855 	/*Writeback Latency support check*/
1856 
1857 	mode_lib->vba.WritebackLatencySupport = true;
1858 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1859 		if (mode_lib->vba.WritebackEnable[k] == true
1860 				&& (v->WriteBandwidth[k]
1861 						> mode_lib->vba.WritebackInterfaceBufferSize * 1024
1862 								/ mode_lib->vba.WritebackLatency)) {
1863 			mode_lib->vba.WritebackLatencySupport = false;
1864 		}
1865 	}
1866 
1867 	/*Writeback Mode Support Check*/
1868 	mode_lib->vba.EnoughWritebackUnits = true;
1869 	mode_lib->vba.TotalNumberOfActiveWriteback = 0;
1870 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1871 		if (mode_lib->vba.WritebackEnable[k] == true)
1872 			mode_lib->vba.TotalNumberOfActiveWriteback = mode_lib->vba.TotalNumberOfActiveWriteback + 1;
1873 	}
1874 
1875 	if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback)
1876 		mode_lib->vba.EnoughWritebackUnits = false;
1877 
1878 	/*Writeback Scale Ratio and Taps Support Check*/
1879 	mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
1880 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1881 		if (mode_lib->vba.WritebackEnable[k] == true) {
1882 			if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
1883 					|| mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackMaxVSCLRatio
1884 					|| mode_lib->vba.WritebackHRatio[k] < mode_lib->vba.WritebackMinHSCLRatio
1885 					|| mode_lib->vba.WritebackVRatio[k] < mode_lib->vba.WritebackMinVSCLRatio
1886 					|| mode_lib->vba.WritebackHTaps[k] > mode_lib->vba.WritebackMaxHSCLTaps
1887 					|| mode_lib->vba.WritebackVTaps[k] > mode_lib->vba.WritebackMaxVSCLTaps
1888 					|| mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackHTaps[k]
1889 					|| mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackVTaps[k]
1890 					|| (mode_lib->vba.WritebackHTaps[k] > 2.0
1891 							&& ((mode_lib->vba.WritebackHTaps[k] % 2) == 1))) {
1892 				mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1893 			}
1894 			if (2.0 * mode_lib->vba.WritebackDestinationWidth[k] * (mode_lib->vba.WritebackVTaps[k] - 1)
1895 					* 57 > mode_lib->vba.WritebackLineBufferSize) {
1896 				mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1897 			}
1898 		}
1899 	}
1900 
1901 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1902 		dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k], mode_lib->vba.HRatioChroma[k],
1903 				mode_lib->vba.VRatio[k], mode_lib->vba.VRatioChroma[k],
1904 				mode_lib->vba.MaxDCHUBToPSCLThroughput, mode_lib->vba.MaxPSCLToLBThroughput,
1905 				mode_lib->vba.PixelClock[k], mode_lib->vba.SourcePixelFormat[k],
1906 				mode_lib->vba.htaps[k], mode_lib->vba.HTAPsChroma[k], mode_lib->vba.vtaps[k],
1907 				mode_lib->vba.VTAPsChroma[k],
1908 				/* Output */
1909 				&mode_lib->vba.PSCL_FACTOR[k], &mode_lib->vba.PSCL_FACTOR_CHROMA[k],
1910 				&mode_lib->vba.MinDPPCLKUsingSingleDPP[k]);
1911 	}
1912 
1913 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1914 
1915 		if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
1916 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 8192;
1917 		} else if (!IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1918 				&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1919 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 7680;
1920 		} else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1921 				&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1922 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 4320;
1923 		} else if (mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
1924 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3840;
1925 		} else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelY[k] == 8 &&
1926 				mode_lib->vba.DCCEnable[k] == true) {
1927 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3072;
1928 		} else {
1929 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 6144;
1930 		}
1931 
1932 		if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
1933 				|| mode_lib->vba.SourcePixelFormat[k] == dm_420_12) {
1934 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma / 2.0;
1935 		} else {
1936 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma;
1937 		}
1938 		v->MaximumSwathWidthInLineBufferLuma = mode_lib->vba.LineBufferSizeFinal
1939 				* dml_max(mode_lib->vba.HRatio[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1940 				/ (mode_lib->vba.vtaps[k] + dml_max(dml_ceil(mode_lib->vba.VRatio[k], 1.0) - 2, 0.0));
1941 		if (v->BytePerPixelC[k] == 0.0) {
1942 			v->MaximumSwathWidthInLineBufferChroma = 0;
1943 		} else {
1944 			v->MaximumSwathWidthInLineBufferChroma = mode_lib->vba.LineBufferSizeFinal
1945 					* dml_max(mode_lib->vba.HRatioChroma[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1946 					/ (mode_lib->vba.VTAPsChroma[k]
1947 							+ dml_max(dml_ceil(mode_lib->vba.VRatioChroma[k], 1.0) - 2,
1948 									0.0));
1949 		}
1950 		v->MaximumSwathWidthLuma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma,
1951 				v->MaximumSwathWidthInLineBufferLuma);
1952 		v->MaximumSwathWidthChroma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma,
1953 				v->MaximumSwathWidthInLineBufferChroma);
1954 	}
1955 
1956 	dml32_CalculateSwathAndDETConfiguration(
1957 			mode_lib->vba.DETSizeOverride,
1958 			mode_lib->vba.UsesMALLForPStateChange,
1959 			mode_lib->vba.ConfigReturnBufferSizeInKByte,
1960 			mode_lib->vba.MaxTotalDETInKByte,
1961 			mode_lib->vba.MinCompressedBufferSizeInKByte,
1962 			1, /* ForceSingleDPP */
1963 			mode_lib->vba.NumberOfActiveSurfaces,
1964 			mode_lib->vba.nomDETInKByte,
1965 			mode_lib->vba.UseUnboundedRequesting,
1966 			mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
1967 			mode_lib->vba.ip.pixel_chunk_size_kbytes,
1968 			mode_lib->vba.ip.rob_buffer_size_kbytes,
1969 			mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
1970 			mode_lib->vba.Output,
1971 			mode_lib->vba.ReadBandwidthLuma,
1972 			mode_lib->vba.ReadBandwidthChroma,
1973 			mode_lib->vba.MaximumSwathWidthLuma,
1974 			mode_lib->vba.MaximumSwathWidthChroma,
1975 			mode_lib->vba.SourceRotation,
1976 			mode_lib->vba.ViewportStationary,
1977 			mode_lib->vba.SourcePixelFormat,
1978 			mode_lib->vba.SurfaceTiling,
1979 			mode_lib->vba.ViewportWidth,
1980 			mode_lib->vba.ViewportHeight,
1981 			mode_lib->vba.ViewportXStartY,
1982 			mode_lib->vba.ViewportYStartY,
1983 			mode_lib->vba.ViewportXStartC,
1984 			mode_lib->vba.ViewportYStartC,
1985 			mode_lib->vba.SurfaceWidthY,
1986 			mode_lib->vba.SurfaceWidthC,
1987 			mode_lib->vba.SurfaceHeightY,
1988 			mode_lib->vba.SurfaceHeightC,
1989 			mode_lib->vba.Read256BlockHeightY,
1990 			mode_lib->vba.Read256BlockHeightC,
1991 			mode_lib->vba.Read256BlockWidthY,
1992 			mode_lib->vba.Read256BlockWidthC,
1993 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_odm_mode,
1994 			mode_lib->vba.BlendingAndTiming,
1995 			mode_lib->vba.BytePerPixelY,
1996 			mode_lib->vba.BytePerPixelC,
1997 			mode_lib->vba.BytePerPixelInDETY,
1998 			mode_lib->vba.BytePerPixelInDETC,
1999 			mode_lib->vba.HActive,
2000 			mode_lib->vba.HRatio,
2001 			mode_lib->vba.HRatioChroma,
2002 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0], /*  Integer DPPPerSurface[] */
2003 
2004 			/* Output */
2005 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1], /* Long            swath_width_luma_ub[] */
2006 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2], /* Long            swath_width_chroma_ub[]  */
2007 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[0], /* Long            SwathWidth[]  */
2008 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[1], /* Long            SwathWidthChroma[]  */
2009 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3], /* Integer         SwathHeightY[]  */
2010 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4], /* Integer         SwathHeightC[]  */
2011 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5], /* Long            DETBufferSizeInKByte[]  */
2012 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6], /* Long            DETBufferSizeY[]  */
2013 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7], /* Long            DETBufferSizeC[]  */
2014 			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0][0], /* bool           *UnboundedRequestEnabled  */
2015 			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0][0], /* Long           *CompressedBufferSizeInkByte  */
2016 			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1][0], /* Long           *CompBufReservedSpaceKBytes */
2017 			&CompBufReservedSpaceNeedAdjustmentSingleDPP,
2018 			mode_lib->vba.SingleDPPViewportSizeSupportPerSurface,/* bool ViewportSizeSupportPerSurface[] */
2019 			&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1][0]); /* bool           *ViewportSizeSupport */
2020 
2021 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
2022 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = false;
2023 
2024 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2025 		if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_reduce_voltage_and_clocks)
2026 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
2027 		if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_always_when_possible)
2028 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = true;
2029 	}
2030 	mode_lib->vba.MPCCombineMethodIncompatible = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage
2031 			&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible;
2032 
2033 	for (i = start_state; i < v->soc.num_states; i++) {
2034 		for (j = 0; j < 2; j++) {
2035 			mode_lib->vba.TotalNumberOfActiveDPP[i][j] = 0;
2036 			mode_lib->vba.TotalAvailablePipesSupport[i][j] = true;
2037 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC = dm_odm_combine_mode_disabled;
2038 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC = dm_odm_combine_mode_disabled;
2039 
2040 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2041 				dml32_CalculateODMMode(
2042 						mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
2043 						mode_lib->vba.HActive[k],
2044 						mode_lib->vba.OutputFormat[k],
2045 						mode_lib->vba.Output[k],
2046 						mode_lib->vba.ODMUse[k],
2047 						mode_lib->vba.MaxDispclk[i],
2048 						mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
2049 						false,
2050 						mode_lib->vba.TotalNumberOfActiveDPP[i][j],
2051 						mode_lib->vba.MaxNumDPP,
2052 						mode_lib->vba.PixelClock[k],
2053 						mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2054 						mode_lib->vba.DISPCLKRampingMargin,
2055 						mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
2056 						mode_lib->vba.NumberOfDSCSlices[k],
2057 
2058 						/* Output */
2059 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC,
2060 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC,
2061 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
2062 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC);
2063 
2064 				dml32_CalculateODMMode(
2065 						mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
2066 						mode_lib->vba.HActive[k],
2067 						mode_lib->vba.OutputFormat[k],
2068 						mode_lib->vba.Output[k],
2069 						mode_lib->vba.ODMUse[k],
2070 						mode_lib->vba.MaxDispclk[i],
2071 						mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
2072 						true,
2073 						mode_lib->vba.TotalNumberOfActiveDPP[i][j],
2074 						mode_lib->vba.MaxNumDPP,
2075 						mode_lib->vba.PixelClock[k],
2076 						mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2077 						mode_lib->vba.DISPCLKRampingMargin,
2078 						mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
2079 						mode_lib->vba.NumberOfDSCSlices[k],
2080 
2081 						/* Output */
2082 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC,
2083 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC,
2084 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2085 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC);
2086 
2087 				dml32_CalculateOutputLink(
2088 						mode_lib->vba.PHYCLKPerState[i],
2089 						mode_lib->vba.PHYCLKD18PerState[i],
2090 						mode_lib->vba.PHYCLKD32PerState[i],
2091 						mode_lib->vba.Downspreading,
2092 						(mode_lib->vba.BlendingAndTiming[k] == k),
2093 						mode_lib->vba.Output[k],
2094 						mode_lib->vba.OutputFormat[k],
2095 						mode_lib->vba.HTotal[k],
2096 						mode_lib->vba.HActive[k],
2097 						mode_lib->vba.PixelClockBackEnd[k],
2098 						mode_lib->vba.ForcedOutputLinkBPP[k],
2099 						mode_lib->vba.DSCInputBitPerComponent[k],
2100 						mode_lib->vba.NumberOfDSCSlices[k],
2101 						mode_lib->vba.AudioSampleRate[k],
2102 						mode_lib->vba.AudioSampleLayout[k],
2103 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
2104 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2105 						mode_lib->vba.DSCEnable[k],
2106 						mode_lib->vba.OutputLinkDPLanes[k],
2107 						mode_lib->vba.OutputLinkDPRate[k],
2108 
2109 						/* Output */
2110 						&mode_lib->vba.RequiresDSC[i][k],
2111 						&mode_lib->vba.RequiresFEC[i][k],
2112 						&mode_lib->vba.OutputBppPerState[i][k],
2113 						&mode_lib->vba.OutputTypePerState[i][k],
2114 						&mode_lib->vba.OutputRatePerState[i][k],
2115 						&mode_lib->vba.RequiredSlots[i][k]);
2116 
2117 				if (mode_lib->vba.RequiresDSC[i][k] == false) {
2118 					mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC;
2119 					mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2120 							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC;
2121 					if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC)
2122 						mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2123 					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2124 							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC;
2125 				} else {
2126 					mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC;
2127 					mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2128 							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC;
2129 					if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC)
2130 						mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2131 					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2132 							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC;
2133 				}
2134 			}
2135 
2136 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2137 				if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2138 					mode_lib->vba.MPCCombine[i][j][k] = false;
2139 					mode_lib->vba.NoOfDPP[i][j][k] = 4;
2140 				} else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2141 					mode_lib->vba.MPCCombine[i][j][k] = false;
2142 					mode_lib->vba.NoOfDPP[i][j][k] = 2;
2143 				} else if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_never) {
2144 					mode_lib->vba.MPCCombine[i][j][k] = false;
2145 					mode_lib->vba.NoOfDPP[i][j][k] = 1;
2146 				} else if (dml32_RoundToDFSGranularity(
2147 						mode_lib->vba.MinDPPCLKUsingSingleDPP[k]
2148 								* (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
2149 												/ 100), 1,
2150 						mode_lib->vba.DISPCLKDPPCLKVCOSpeed) <= mode_lib->vba.MaxDppclk[i] &&
2151 				mode_lib->vba.SingleDPPViewportSizeSupportPerSurface[k] == true) {
2152 					mode_lib->vba.MPCCombine[i][j][k] = false;
2153 					mode_lib->vba.NoOfDPP[i][j][k] = 1;
2154 				} else if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP) {
2155 					mode_lib->vba.MPCCombine[i][j][k] = true;
2156 					mode_lib->vba.NoOfDPP[i][j][k] = 2;
2157 					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2158 							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2159 				} else {
2160 					mode_lib->vba.MPCCombine[i][j][k] = false;
2161 					mode_lib->vba.NoOfDPP[i][j][k] = 1;
2162 					mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2163 				}
2164 			}
2165 
2166 			mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] = 0;
2167 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = true;
2168 
2169 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2170 				if (mode_lib->vba.NoOfDPP[i][j][k] == 1)
2171 					mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2172 							mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] + 1;
2173 				if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2174 						|| mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2175 						|| mode_lib->vba.SourcePixelFormat[k] == dm_420_12
2176 						|| mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
2177 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = false;
2178 				}
2179 			}
2180 
2181 			// if TotalNumberOfActiveDPP is > 1, then there should be no unbounded req mode (hw limitation), the comp buf reserved adjustment is not needed regardless
2182 			// if TotalNumberOfActiveDPP is == 1, then will use the SingleDPP version of unbounded_req for the decision
2183 			CompBufReservedSpaceNeedAdjustment = (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > 1) ? 0 : CompBufReservedSpaceNeedAdjustmentSingleDPP;
2184 
2185 
2186 
2187 			if (j == 1 && !dml32_UnboundedRequest(mode_lib->vba.UseUnboundedRequesting,
2188 					mode_lib->vba.TotalNumberOfActiveDPP[i][j], v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma,
2189 					mode_lib->vba.Output[0],
2190 					mode_lib->vba.SurfaceTiling[0],
2191 					CompBufReservedSpaceNeedAdjustment,
2192 					mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)) {
2193 				while (!(mode_lib->vba.TotalNumberOfActiveDPP[i][j] >= mode_lib->vba.MaxNumDPP
2194 						|| mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] == 0)) {
2195 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2196 					NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2197 
2198 					for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2199 						if (mode_lib->vba.MPCCombineUse[k]
2200 							!= dm_mpc_never &&
2201 							mode_lib->vba.MPCCombineUse[k] != dm_mpc_reduce_voltage &&
2202 							mode_lib->vba.ReadBandwidthLuma[k] +
2203 							mode_lib->vba.ReadBandwidthChroma[k] >
2204 							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth &&
2205 							(mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2206 							dm_odm_combine_mode_2to1 &&
2207 							mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2208 							dm_odm_combine_mode_4to1) &&
2209 								mode_lib->vba.MPCCombine[i][j][k] == false) {
2210 							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth =
2211 								mode_lib->vba.ReadBandwidthLuma[k]
2212 								+ mode_lib->vba.ReadBandwidthChroma[k];
2213 							NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
2214 						}
2215 					}
2216 					mode_lib->vba.MPCCombine[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] =
2217 							true;
2218 					mode_lib->vba.NoOfDPP[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
2219 					mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2220 							mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2221 					mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2222 							mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] - 1;
2223 				}
2224 			}
2225 
2226 			//DISPCLK/DPPCLK
2227 			mode_lib->vba.WritebackRequiredDISPCLK = 0;
2228 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2229 				if (mode_lib->vba.WritebackEnable[k]) {
2230 					mode_lib->vba.WritebackRequiredDISPCLK = dml_max(
2231 							mode_lib->vba.WritebackRequiredDISPCLK,
2232 							dml32_CalculateWriteBackDISPCLK(
2233 									mode_lib->vba.WritebackPixelFormat[k],
2234 									mode_lib->vba.PixelClock[k],
2235 									mode_lib->vba.WritebackHRatio[k],
2236 									mode_lib->vba.WritebackVRatio[k],
2237 									mode_lib->vba.WritebackHTaps[k],
2238 									mode_lib->vba.WritebackVTaps[k],
2239 									mode_lib->vba.WritebackSourceWidth[k],
2240 									mode_lib->vba.WritebackDestinationWidth[k],
2241 									mode_lib->vba.HTotal[k],
2242 									mode_lib->vba.WritebackLineBufferSize,
2243 									mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
2244 				}
2245 			}
2246 
2247 			mode_lib->vba.RequiredDISPCLK[i][j] = mode_lib->vba.WritebackRequiredDISPCLK;
2248 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2249 				mode_lib->vba.RequiredDISPCLK[i][j] = dml_max(mode_lib->vba.RequiredDISPCLK[i][j],
2250 						mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k]);
2251 			}
2252 
2253 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2254 				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2255 
2256 			dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces,
2257 					mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2258 					mode_lib->vba.DISPCLKDPPCLKVCOSpeed, mode_lib->vba.MinDPPCLKUsingSingleDPP,
2259 					mode_lib->vba.NoOfDPPThisState,
2260 					/* Output */
2261 					&mode_lib->vba.GlobalDPPCLK, mode_lib->vba.RequiredDPPCLKThisState);
2262 
2263 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2264 				mode_lib->vba.RequiredDPPCLK[i][j][k] = mode_lib->vba.RequiredDPPCLKThisState[k];
2265 
2266 			mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] = !((mode_lib->vba.RequiredDISPCLK[i][j]
2267 					> mode_lib->vba.MaxDispclk[i])
2268 					|| (mode_lib->vba.GlobalDPPCLK > mode_lib->vba.MaxDppclk[i]));
2269 
2270 			if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP)
2271 				mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2272 		} // j
2273 	} // i (VOLTAGE_STATE)
2274 
2275 	/* Total Available OTG, HDMIFRL, DP Support Check */
2276 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = 0;
2277 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL = 0;
2278 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = 0;
2279 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = 0;
2280 
2281 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2282 		if (mode_lib->vba.BlendingAndTiming[k] == k) {
2283 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG + 1;
2284 			if (mode_lib->vba.Output[k] == dm_dp2p0) {
2285 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 + 1;
2286 				if (mode_lib->vba.OutputMultistreamId[k]
2287 						== k || mode_lib->vba.OutputMultistreamEn[k] == false) {
2288 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs + 1;
2289 				}
2290 			}
2291 		}
2292 	}
2293 
2294 	mode_lib->vba.NumberOfOTGSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG);
2295 	mode_lib->vba.NumberOfHDMIFRLSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL <= mode_lib->vba.MaxNumHDMIFRLOutputs);
2296 	mode_lib->vba.NumberOfDP2p0Support = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 <= mode_lib->vba.MaxNumDP2p0Streams
2297 			&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs <= mode_lib->vba.MaxNumDP2p0Outputs);
2298 
2299 	/* Display IO and DSC Support Check */
2300 	mode_lib->vba.NonsupportedDSCInputBPC = false;
2301 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2302 		if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
2303 				|| mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
2304 				|| mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)
2305 				|| mode_lib->vba.DSCInputBitPerComponent[k] > mode_lib->vba.MaximumDSCBitsPerComponent) {
2306 			mode_lib->vba.NonsupportedDSCInputBPC = true;
2307 		}
2308 	}
2309 
2310 	for (i = start_state; i < v->soc.num_states; ++i) {
2311 		mode_lib->vba.ExceededMultistreamSlots[i] = false;
2312 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2313 			if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == k) {
2314 				TotalSlots = mode_lib->vba.RequiredSlots[i][k];
2315 				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2316 					if (mode_lib->vba.OutputMultistreamId[j] == k)
2317 						TotalSlots = TotalSlots + mode_lib->vba.RequiredSlots[i][j];
2318 				}
2319 				if (mode_lib->vba.Output[k] == dm_dp && TotalSlots > 63)
2320 					mode_lib->vba.ExceededMultistreamSlots[i] = true;
2321 				if (mode_lib->vba.Output[k] == dm_dp2p0 && TotalSlots > 64)
2322 					mode_lib->vba.ExceededMultistreamSlots[i] = true;
2323 			}
2324 		}
2325 		mode_lib->vba.LinkCapacitySupport[i] = true;
2326 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2327 			if (mode_lib->vba.BlendingAndTiming[k] == k
2328 				&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2329 					|| mode_lib->vba.Output[k] == dm_edp
2330 					|| mode_lib->vba.Output[k] == dm_hdmi)
2331 				&& mode_lib->vba.OutputBppPerState[i][k] == 0 &&
2332 				(mode_lib->vba.UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe)) {
2333 				/* Phantom pipes don't consider DSC in DML, so it could fail link check.
2334 				 * However, we don't care about the link for phantom pipes.
2335 				 */
2336 				mode_lib->vba.LinkCapacitySupport[i] = false;
2337 			}
2338 		}
2339 	}
2340 
2341 	mode_lib->vba.P2IWith420 = false;
2342 	mode_lib->vba.DSCOnlyIfNecessaryWithBPP = false;
2343 	mode_lib->vba.DSC422NativeNotSupported = false;
2344 	mode_lib->vba.LinkRateDoesNotMatchDPVersion = false;
2345 	mode_lib->vba.LinkRateForMultistreamNotIndicated = false;
2346 	mode_lib->vba.BPPForMultistreamNotIndicated = false;
2347 	mode_lib->vba.MultistreamWithHDMIOreDP = false;
2348 	mode_lib->vba.MSOOrODMSplitWithNonDPLink = false;
2349 	mode_lib->vba.NotEnoughLanesForMSO = false;
2350 
2351 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2352 		if (mode_lib->vba.BlendingAndTiming[k] == k
2353 				&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2354 						|| mode_lib->vba.Output[k] == dm_edp
2355 						|| mode_lib->vba.Output[k] == dm_hdmi)) {
2356 			if (mode_lib->vba.OutputFormat[k]
2357 					== dm_420 && mode_lib->vba.Interlace[k] == 1 &&
2358 					mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)
2359 				mode_lib->vba.P2IWith420 = true;
2360 
2361 			if (mode_lib->vba.DSCEnable[k] && mode_lib->vba.ForcedOutputLinkBPP[k] != 0)
2362 				mode_lib->vba.DSCOnlyIfNecessaryWithBPP = true;
2363 			if (mode_lib->vba.DSCEnable[k] && mode_lib->vba.OutputFormat[k] == dm_n422
2364 					&& !mode_lib->vba.DSC422NativeSupport)
2365 				mode_lib->vba.DSC422NativeNotSupported = true;
2366 
2367 			if (((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr
2368 					|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr2
2369 					|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr3)
2370 					&& mode_lib->vba.Output[k] != dm_dp && mode_lib->vba.Output[k] != dm_edp)
2371 					|| ((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr10
2372 							|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5
2373 							|| mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr20)
2374 							&& mode_lib->vba.Output[k] != dm_dp2p0))
2375 				mode_lib->vba.LinkRateDoesNotMatchDPVersion = true;
2376 
2377 			if (mode_lib->vba.OutputMultistreamEn[k] == true) {
2378 				if (mode_lib->vba.OutputMultistreamId[k] == k
2379 					&& mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_na)
2380 					mode_lib->vba.LinkRateForMultistreamNotIndicated = true;
2381 				if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2382 					mode_lib->vba.BPPForMultistreamNotIndicated = true;
2383 				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2384 					if (mode_lib->vba.OutputMultistreamId[k] == j
2385 						&& mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2386 						mode_lib->vba.BPPForMultistreamNotIndicated = true;
2387 				}
2388 			}
2389 
2390 			if ((mode_lib->vba.Output[k] == dm_edp || mode_lib->vba.Output[k] == dm_hdmi)) {
2391 				if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == k)
2392 					mode_lib->vba.MultistreamWithHDMIOreDP = true;
2393 				for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2394 					if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == j)
2395 						mode_lib->vba.MultistreamWithHDMIOreDP = true;
2396 				}
2397 			}
2398 
2399 			if (mode_lib->vba.Output[k] != dm_dp
2400 					&& (mode_lib->vba.ODMUse[k] == dm_odm_split_policy_1to2
2401 							|| mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2402 							|| mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4))
2403 				mode_lib->vba.MSOOrODMSplitWithNonDPLink = true;
2404 
2405 			if ((mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2406 					&& mode_lib->vba.OutputLinkDPLanes[k] < 2)
2407 					|| (mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4
2408 							&& mode_lib->vba.OutputLinkDPLanes[k] < 4))
2409 				mode_lib->vba.NotEnoughLanesForMSO = true;
2410 		}
2411 	}
2412 
2413 	for (i = start_state; i < v->soc.num_states; ++i) {
2414 		mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = false;
2415 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2416 			if (mode_lib->vba.BlendingAndTiming[k] == k
2417 					&& dml32_RequiredDTBCLK(mode_lib->vba.RequiresDSC[i][k],
2418 							mode_lib->vba.PixelClockBackEnd[k],
2419 							mode_lib->vba.OutputFormat[k],
2420 							mode_lib->vba.OutputBppPerState[i][k],
2421 							mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.HTotal[k],
2422 							mode_lib->vba.HActive[k], mode_lib->vba.AudioSampleRate[k],
2423 							mode_lib->vba.AudioSampleLayout[k])
2424 							> mode_lib->vba.DTBCLKPerState[i]) {
2425 				mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = true;
2426 			}
2427 		}
2428 	}
2429 
2430 	for (i = start_state; i < v->soc.num_states; ++i) {
2431 		mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = true;
2432 		mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = true;
2433 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2434 			if (mode_lib->vba.BlendingAndTiming[k] == k
2435 					&& mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1
2436 					&& mode_lib->vba.Output[k] == dm_hdmi) {
2437 				mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = false;
2438 			}
2439 			if (mode_lib->vba.BlendingAndTiming[k] == k
2440 					&& mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
2441 					&& (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_edp
2442 							|| mode_lib->vba.Output[k] == dm_hdmi)) {
2443 				mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = false;
2444 			}
2445 		}
2446 	}
2447 
2448 	for (i = start_state; i < v->soc.num_states; i++) {
2449 		mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = false;
2450 		for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2451 			if (mode_lib->vba.BlendingAndTiming[k] == k) {
2452 				if (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2453 						|| mode_lib->vba.Output[k] == dm_edp) {
2454 					if (mode_lib->vba.OutputFormat[k] == dm_420) {
2455 						mode_lib->vba.DSCFormatFactor = 2;
2456 					} else if (mode_lib->vba.OutputFormat[k] == dm_444) {
2457 						mode_lib->vba.DSCFormatFactor = 1;
2458 					} else if (mode_lib->vba.OutputFormat[k] == dm_n422) {
2459 						mode_lib->vba.DSCFormatFactor = 2;
2460 					} else {
2461 						mode_lib->vba.DSCFormatFactor = 1;
2462 					}
2463 					if (mode_lib->vba.RequiresDSC[i][k] == true) {
2464 						if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2465 								== dm_odm_combine_mode_4to1) {
2466 							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])
2467 								mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2468 						} else if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2469 								== dm_odm_combine_mode_2to1) {
2470 							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])
2471 								mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2472 						} else {
2473 							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])
2474 								mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2475 						}
2476 					}
2477 				}
2478 			}
2479 		}
2480 	}
2481 
2482 	/* Check DSC Unit and Slices Support */
2483 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2484 
2485 	for (i = start_state; i < v->soc.num_states; ++i) {
2486 		mode_lib->vba.NotEnoughDSCUnits[i] = false;
2487 		mode_lib->vba.NotEnoughDSCSlices[i] = false;
2488 		v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2489 		mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = true;
2490 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2491 			if (mode_lib->vba.RequiresDSC[i][k] == true) {
2492 				if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2493 					if (mode_lib->vba.HActive[k]
2494 							> 4 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2495 						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2496 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 4;
2497 					if (mode_lib->vba.NumberOfDSCSlices[k] > 16)
2498 						mode_lib->vba.NotEnoughDSCSlices[i] = true;
2499 				} else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2500 					if (mode_lib->vba.HActive[k]
2501 							> 2 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2502 						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2503 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 2;
2504 					if (mode_lib->vba.NumberOfDSCSlices[k] > 8)
2505 						mode_lib->vba.NotEnoughDSCSlices[i] = true;
2506 				} else {
2507 					if (mode_lib->vba.HActive[k] > mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2508 						mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2509 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 1;
2510 					if (mode_lib->vba.NumberOfDSCSlices[k] > 4)
2511 						mode_lib->vba.NotEnoughDSCSlices[i] = true;
2512 				}
2513 			}
2514 		}
2515 		if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC)
2516 			mode_lib->vba.NotEnoughDSCUnits[i] = true;
2517 	}
2518 
2519 	/*DSC Delay per state*/
2520 	for (i = start_state; i < v->soc.num_states; ++i) {
2521 		for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2522 			mode_lib->vba.DSCDelayPerState[i][k] = dml32_DSCDelayRequirement(
2523 					mode_lib->vba.RequiresDSC[i][k], mode_lib->vba.ODMCombineEnablePerState[i][k],
2524 					mode_lib->vba.DSCInputBitPerComponent[k],
2525 					mode_lib->vba.OutputBppPerState[i][k], mode_lib->vba.HActive[k],
2526 					mode_lib->vba.HTotal[k], mode_lib->vba.NumberOfDSCSlices[k],
2527 					mode_lib->vba.OutputFormat[k], mode_lib->vba.Output[k],
2528 					mode_lib->vba.PixelClock[k], mode_lib->vba.PixelClockBackEnd[k],
2529 					mode_lib->vba.ip.dsc_delay_factor_wa);
2530 		}
2531 
2532 		for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2533 			for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2534 				for (j = 0; j <= mode_lib->vba.NumberOfActiveSurfaces - 1; j++) {
2535 					if (mode_lib->vba.BlendingAndTiming[k] == m &&
2536 							mode_lib->vba.RequiresDSC[i][m] == true) {
2537 						mode_lib->vba.DSCDelayPerState[i][k] =
2538 							mode_lib->vba.DSCDelayPerState[i][m];
2539 					}
2540 				}
2541 			}
2542 		}
2543 	}
2544 
2545 	//Calculate Swath, DET Configuration, DCFCLKDeepSleep
2546 	//
2547 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
2548 		for (j = 0; j <= 1; ++j) {
2549 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2550 				mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2551 				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2552 				mode_lib->vba.ODMCombineEnableThisState[k] =
2553 						mode_lib->vba.ODMCombineEnablePerState[i][k];
2554 			}
2555 
2556 			dml32_CalculateSwathAndDETConfiguration(
2557 					mode_lib->vba.DETSizeOverride,
2558 					mode_lib->vba.UsesMALLForPStateChange,
2559 					mode_lib->vba.ConfigReturnBufferSizeInKByte,
2560 					mode_lib->vba.MaxTotalDETInKByte,
2561 					mode_lib->vba.MinCompressedBufferSizeInKByte,
2562 					false, /* ForceSingleDPP */
2563 					mode_lib->vba.NumberOfActiveSurfaces,
2564 					mode_lib->vba.nomDETInKByte,
2565 					mode_lib->vba.UseUnboundedRequesting,
2566 					mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
2567 					mode_lib->vba.ip.pixel_chunk_size_kbytes,
2568 					mode_lib->vba.ip.rob_buffer_size_kbytes,
2569 					mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
2570 					mode_lib->vba.Output,
2571 					mode_lib->vba.ReadBandwidthLuma,
2572 					mode_lib->vba.ReadBandwidthChroma,
2573 					mode_lib->vba.MaximumSwathWidthLuma,
2574 					mode_lib->vba.MaximumSwathWidthChroma,
2575 					mode_lib->vba.SourceRotation,
2576 					mode_lib->vba.ViewportStationary,
2577 					mode_lib->vba.SourcePixelFormat,
2578 					mode_lib->vba.SurfaceTiling,
2579 					mode_lib->vba.ViewportWidth,
2580 					mode_lib->vba.ViewportHeight,
2581 					mode_lib->vba.ViewportXStartY,
2582 					mode_lib->vba.ViewportYStartY,
2583 					mode_lib->vba.ViewportXStartC,
2584 					mode_lib->vba.ViewportYStartC,
2585 					mode_lib->vba.SurfaceWidthY,
2586 					mode_lib->vba.SurfaceWidthC,
2587 					mode_lib->vba.SurfaceHeightY,
2588 					mode_lib->vba.SurfaceHeightC,
2589 					mode_lib->vba.Read256BlockHeightY,
2590 					mode_lib->vba.Read256BlockHeightC,
2591 					mode_lib->vba.Read256BlockWidthY,
2592 					mode_lib->vba.Read256BlockWidthC,
2593 					mode_lib->vba.ODMCombineEnableThisState,
2594 					mode_lib->vba.BlendingAndTiming,
2595 					mode_lib->vba.BytePerPixelY,
2596 					mode_lib->vba.BytePerPixelC,
2597 					mode_lib->vba.BytePerPixelInDETY,
2598 					mode_lib->vba.BytePerPixelInDETC,
2599 					mode_lib->vba.HActive,
2600 					mode_lib->vba.HRatio,
2601 					mode_lib->vba.HRatioChroma,
2602 					mode_lib->vba.NoOfDPPThisState,
2603 					/* Output */
2604 					mode_lib->vba.swath_width_luma_ub_this_state,
2605 					mode_lib->vba.swath_width_chroma_ub_this_state,
2606 					mode_lib->vba.SwathWidthYThisState,
2607 					mode_lib->vba.SwathWidthCThisState,
2608 					mode_lib->vba.SwathHeightYThisState,
2609 					mode_lib->vba.SwathHeightCThisState,
2610 					mode_lib->vba.DETBufferSizeInKByteThisState,
2611 					mode_lib->vba.DETBufferSizeYThisState,
2612 					mode_lib->vba.DETBufferSizeCThisState,
2613 					&mode_lib->vba.UnboundedRequestEnabledThisState,
2614 					&mode_lib->vba.CompressedBufferSizeInkByteThisState,
2615 					&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], /* Long CompBufReservedSpaceKBytes */
2616 					&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean[0], /* bool CompBufReservedSpaceNeedAdjustment */
2617 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0],
2618 					&mode_lib->vba.ViewportSizeSupport[i][j]);
2619 
2620 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2621 				mode_lib->vba.swath_width_luma_ub_all_states[i][j][k] =
2622 						mode_lib->vba.swath_width_luma_ub_this_state[k];
2623 				mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k] =
2624 						mode_lib->vba.swath_width_chroma_ub_this_state[k];
2625 				mode_lib->vba.SwathWidthYAllStates[i][j][k] = mode_lib->vba.SwathWidthYThisState[k];
2626 				mode_lib->vba.SwathWidthCAllStates[i][j][k] = mode_lib->vba.SwathWidthCThisState[k];
2627 				mode_lib->vba.SwathHeightYAllStates[i][j][k] = mode_lib->vba.SwathHeightYThisState[k];
2628 				mode_lib->vba.SwathHeightCAllStates[i][j][k] = mode_lib->vba.SwathHeightCThisState[k];
2629 				mode_lib->vba.UnboundedRequestEnabledAllStates[i][j] =
2630 						mode_lib->vba.UnboundedRequestEnabledThisState;
2631 				mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j] =
2632 						mode_lib->vba.CompressedBufferSizeInkByteThisState;
2633 				mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k] =
2634 						mode_lib->vba.DETBufferSizeInKByteThisState[k];
2635 				mode_lib->vba.DETBufferSizeYAllStates[i][j][k] =
2636 						mode_lib->vba.DETBufferSizeYThisState[k];
2637 				mode_lib->vba.DETBufferSizeCAllStates[i][j][k] =
2638 						mode_lib->vba.DETBufferSizeCThisState[k];
2639 			}
2640 		}
2641 	}
2642 
2643 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2644 		mode_lib->vba.cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0]
2645 				* mode_lib->vba.CursorBPP[k][0] / 8.0
2646 				/ (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
2647 	}
2648 
2649 	dml32_CalculateSurfaceSizeInMall(
2650 			mode_lib->vba.NumberOfActiveSurfaces,
2651 			mode_lib->vba.MALLAllocatedForDCNFinal,
2652 			mode_lib->vba.UseMALLForStaticScreen,
2653 			mode_lib->vba.UsesMALLForPStateChange,
2654 			mode_lib->vba.DCCEnable,
2655 			mode_lib->vba.ViewportStationary,
2656 			mode_lib->vba.ViewportXStartY,
2657 			mode_lib->vba.ViewportYStartY,
2658 			mode_lib->vba.ViewportXStartC,
2659 			mode_lib->vba.ViewportYStartC,
2660 			mode_lib->vba.ViewportWidth,
2661 			mode_lib->vba.ViewportHeight,
2662 			mode_lib->vba.BytePerPixelY,
2663 			mode_lib->vba.ViewportWidthChroma,
2664 			mode_lib->vba.ViewportHeightChroma,
2665 			mode_lib->vba.BytePerPixelC,
2666 			mode_lib->vba.SurfaceWidthY,
2667 			mode_lib->vba.SurfaceWidthC,
2668 			mode_lib->vba.SurfaceHeightY,
2669 			mode_lib->vba.SurfaceHeightC,
2670 			mode_lib->vba.Read256BlockWidthY,
2671 			mode_lib->vba.Read256BlockWidthC,
2672 			mode_lib->vba.Read256BlockHeightY,
2673 			mode_lib->vba.Read256BlockHeightC,
2674 			mode_lib->vba.MacroTileWidthY,
2675 			mode_lib->vba.MacroTileWidthC,
2676 			mode_lib->vba.MacroTileHeightY,
2677 			mode_lib->vba.MacroTileHeightC,
2678 			mode_lib->vba.DCCMetaPitchY,
2679 			mode_lib->vba.DCCMetaPitchC,
2680 
2681 			/* Output */
2682 			mode_lib->vba.SurfaceSizeInMALL,
2683 			&mode_lib->vba.ExceededMALLSize);
2684 
2685 	for (i = start_state; i < v->soc.num_states; i++) {
2686 		for (j = 0; j < 2; j++) {
2687 			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2688 				mode_lib->vba.swath_width_luma_ub_this_state[k] =
2689 						mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
2690 				mode_lib->vba.swath_width_chroma_ub_this_state[k] =
2691 						mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
2692 				mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
2693 				mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
2694 				mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
2695 				mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
2696 				mode_lib->vba.DETBufferSizeInKByteThisState[k] =
2697 						mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
2698 				mode_lib->vba.DETBufferSizeYThisState[k] =
2699 						mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
2700 				mode_lib->vba.DETBufferSizeCThisState[k] =
2701 						mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
2702 				mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2703 				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2704 			}
2705 
2706 			mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] = 0;
2707 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2708 				if (mode_lib->vba.DCCEnable[k] == true) {
2709 					mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] =
2710 							mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
2711 									+ mode_lib->vba.NoOfDPP[i][j][k];
2712 				}
2713 			}
2714 
2715 
2716 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2717 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
2718 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
2719 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
2720 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
2721 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
2722 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
2723 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
2724 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
2725 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
2726 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthY = mode_lib->vba.MacroTileWidthY[k];
2727 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightY = mode_lib->vba.MacroTileHeightY[k];
2728 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthC = mode_lib->vba.MacroTileWidthC[k];
2729 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightC = mode_lib->vba.MacroTileHeightC[k];
2730 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
2731 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].HTotal = mode_lib->vba.HTotal[k];
2732 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
2733 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
2734 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
2735 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
2736 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
2737 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ProgressiveToInterlaceUnitInOPP =
2738 				mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
2739 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatio = mode_lib->vba.VRatio[k];
2740 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
2741 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTaps = mode_lib->vba.vtaps[k];
2742 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
2743 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchY = mode_lib->vba.PitchY[k];
2744 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
2745 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchC = mode_lib->vba.PitchC[k];
2746 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
2747 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
2748 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
2749 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
2750 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
2751 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
2752 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
2753 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightY = mode_lib->vba.SwathHeightYThisState[k];
2754 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightC = mode_lib->vba.SwathHeightCThisState[k];
2755 			}
2756 
2757 			{
2758 				dml32_CalculateVMRowAndSwath(
2759 						mode_lib->vba.NumberOfActiveSurfaces,
2760 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters,
2761 						mode_lib->vba.SurfaceSizeInMALL,
2762 						mode_lib->vba.PTEBufferSizeInRequestsLuma,
2763 						mode_lib->vba.PTEBufferSizeInRequestsChroma,
2764 						mode_lib->vba.DCCMetaBufferSizeBytes,
2765 						mode_lib->vba.UseMALLForStaticScreen,
2766 						mode_lib->vba.UsesMALLForPStateChange,
2767 						mode_lib->vba.MALLAllocatedForDCNFinal,
2768 						mode_lib->vba.SwathWidthYThisState,
2769 						mode_lib->vba.SwathWidthCThisState,
2770 						mode_lib->vba.GPUVMEnable,
2771 						mode_lib->vba.HostVMEnable,
2772 						mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
2773 						mode_lib->vba.GPUVMMaxPageTableLevels,
2774 						mode_lib->vba.GPUVMMinPageSizeKBytes,
2775 						mode_lib->vba.HostVMMinPageSize,
2776 
2777 						/* Output */
2778 						mode_lib->vba.PTEBufferSizeNotExceededPerState,
2779 						mode_lib->vba.DCCMetaBufferSizeNotExceededPerState,
2780 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0],
2781 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1],
2782 						mode_lib->vba.dpte_row_height,
2783 						mode_lib->vba.dpte_row_height_chroma,
2784 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2],
2785 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3],
2786 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4],
2787 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5],
2788 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6],
2789 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7],
2790 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[8],
2791 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[9],
2792 						mode_lib->vba.meta_row_height,
2793 						mode_lib->vba.meta_row_height_chroma,
2794 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[10],
2795 						mode_lib->vba.dpte_group_bytes,
2796 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[11],
2797 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[12],
2798 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[13],
2799 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[14],
2800 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[15],
2801 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[16],
2802 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[17],
2803 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[18],
2804 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[19],
2805 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[20],
2806 						mode_lib->vba.PrefetchLinesYThisState,
2807 						mode_lib->vba.PrefetchLinesCThisState,
2808 						mode_lib->vba.PrefillY,
2809 						mode_lib->vba.PrefillC,
2810 						mode_lib->vba.MaxNumSwY,
2811 						mode_lib->vba.MaxNumSwC,
2812 						mode_lib->vba.meta_row_bandwidth_this_state,
2813 						mode_lib->vba.dpte_row_bandwidth_this_state,
2814 						mode_lib->vba.DPTEBytesPerRowThisState,
2815 						mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState,
2816 						mode_lib->vba.MetaRowBytesThisState,
2817 						mode_lib->vba.use_one_row_for_frame_this_state,
2818 						mode_lib->vba.use_one_row_for_frame_flip_this_state,
2819 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0], // Boolean UsesMALLForStaticScreen[]
2820 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1], // Boolean PTE_BUFFER_MODE[]
2821 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[21]); // Long BIGK_FRAGMENT_SIZE[]
2822 			}
2823 
2824 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2825 				mode_lib->vba.PrefetchLinesY[i][j][k] = mode_lib->vba.PrefetchLinesYThisState[k];
2826 				mode_lib->vba.PrefetchLinesC[i][j][k] = mode_lib->vba.PrefetchLinesCThisState[k];
2827 				mode_lib->vba.meta_row_bandwidth[i][j][k] =
2828 						mode_lib->vba.meta_row_bandwidth_this_state[k];
2829 				mode_lib->vba.dpte_row_bandwidth[i][j][k] =
2830 						mode_lib->vba.dpte_row_bandwidth_this_state[k];
2831 				mode_lib->vba.DPTEBytesPerRow[i][j][k] = mode_lib->vba.DPTEBytesPerRowThisState[k];
2832 				mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k] =
2833 						mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState[k];
2834 				mode_lib->vba.MetaRowBytes[i][j][k] = mode_lib->vba.MetaRowBytesThisState[k];
2835 				mode_lib->vba.use_one_row_for_frame[i][j][k] =
2836 						mode_lib->vba.use_one_row_for_frame_this_state[k];
2837 				mode_lib->vba.use_one_row_for_frame_flip[i][j][k] =
2838 						mode_lib->vba.use_one_row_for_frame_flip_this_state[k];
2839 			}
2840 
2841 			mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = true;
2842 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2843 				if (mode_lib->vba.PTEBufferSizeNotExceededPerState[k] == false)
2844 					mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = false;
2845 			}
2846 
2847 			mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = true;
2848 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2849 				if (mode_lib->vba.DCCMetaBufferSizeNotExceededPerState[k] == false)
2850 					mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = false;
2851 			}
2852 
2853 			mode_lib->vba.UrgLatency[i] = dml32_CalculateUrgentLatency(
2854 					mode_lib->vba.UrgentLatencyPixelDataOnly,
2855 					mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
2856 					mode_lib->vba.UrgentLatencyVMDataOnly, mode_lib->vba.DoUrgentLatencyAdjustment,
2857 					mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
2858 					mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
2859 					mode_lib->vba.FabricClockPerState[i]);
2860 
2861 			//bool   NotUrgentLatencyHiding[DC__NUM_DPP__MAX];
2862 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2863 				dml32_CalculateUrgentBurstFactor(
2864 						mode_lib->vba.UsesMALLForPStateChange[k],
2865 						mode_lib->vba.swath_width_luma_ub_this_state[k],
2866 						mode_lib->vba.swath_width_chroma_ub_this_state[k],
2867 						mode_lib->vba.SwathHeightYThisState[k],
2868 						mode_lib->vba.SwathHeightCThisState[k],
2869 						(double) mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2870 						mode_lib->vba.UrgLatency[i],
2871 						mode_lib->vba.CursorBufferSize,
2872 						mode_lib->vba.CursorWidth[k][0],
2873 						mode_lib->vba.CursorBPP[k][0],
2874 						mode_lib->vba.VRatio[k],
2875 						mode_lib->vba.VRatioChroma[k],
2876 						mode_lib->vba.BytePerPixelInDETY[k],
2877 						mode_lib->vba.BytePerPixelInDETC[k],
2878 						mode_lib->vba.DETBufferSizeYThisState[k],
2879 						mode_lib->vba.DETBufferSizeCThisState[k],
2880 						/* Output */
2881 						&mode_lib->vba.UrgentBurstFactorCursor[k],
2882 						&mode_lib->vba.UrgentBurstFactorLuma[k],
2883 						&mode_lib->vba.UrgentBurstFactorChroma[k],
2884 						&mode_lib->vba.NoUrgentLatencyHiding[k]);
2885 			}
2886 
2887 			dml32_CalculateDCFCLKDeepSleep(
2888 					mode_lib->vba.NumberOfActiveSurfaces,
2889 					mode_lib->vba.BytePerPixelY,
2890 					mode_lib->vba.BytePerPixelC,
2891 					mode_lib->vba.VRatio,
2892 					mode_lib->vba.VRatioChroma,
2893 					mode_lib->vba.SwathWidthYThisState,
2894 					mode_lib->vba.SwathWidthCThisState,
2895 					mode_lib->vba.NoOfDPPThisState,
2896 					mode_lib->vba.HRatio,
2897 					mode_lib->vba.HRatioChroma,
2898 					mode_lib->vba.PixelClock,
2899 					mode_lib->vba.PSCL_FACTOR,
2900 					mode_lib->vba.PSCL_FACTOR_CHROMA,
2901 					mode_lib->vba.RequiredDPPCLKThisState,
2902 					mode_lib->vba.ReadBandwidthLuma,
2903 					mode_lib->vba.ReadBandwidthChroma,
2904 					mode_lib->vba.ReturnBusWidth,
2905 
2906 					/* Output */
2907 					&mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j]);
2908 		}
2909 	}
2910 
2911 	//Calculate Return BW
2912 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
2913 		for (j = 0; j <= 1; ++j) {
2914 			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2915 				if (mode_lib->vba.BlendingAndTiming[k] == k) {
2916 					if (mode_lib->vba.WritebackEnable[k] == true) {
2917 						mode_lib->vba.WritebackDelayTime[k] =
2918 							mode_lib->vba.WritebackLatency
2919 						+ dml32_CalculateWriteBackDelay(
2920 							mode_lib->vba.WritebackPixelFormat[k],
2921 							mode_lib->vba.WritebackHRatio[k],
2922 							mode_lib->vba.WritebackVRatio[k],
2923 							mode_lib->vba.WritebackVTaps[k],
2924 							mode_lib->vba.WritebackDestinationWidth[k],
2925 							mode_lib->vba.WritebackDestinationHeight[k],
2926 							mode_lib->vba.WritebackSourceHeight[k],
2927 							mode_lib->vba.HTotal[k])
2928 							/ mode_lib->vba.RequiredDISPCLK[i][j];
2929 					} else {
2930 						mode_lib->vba.WritebackDelayTime[k] = 0.0;
2931 					}
2932 					for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2933 						if (mode_lib->vba.BlendingAndTiming[m]
2934 								== k && mode_lib->vba.WritebackEnable[m] == true) {
2935 							mode_lib->vba.WritebackDelayTime[k] =
2936 								dml_max(mode_lib->vba.WritebackDelayTime[k],
2937 									mode_lib->vba.WritebackLatency
2938 								+ dml32_CalculateWriteBackDelay(
2939 									mode_lib->vba.WritebackPixelFormat[m],
2940 									mode_lib->vba.WritebackHRatio[m],
2941 									mode_lib->vba.WritebackVRatio[m],
2942 									mode_lib->vba.WritebackVTaps[m],
2943 									mode_lib->vba.WritebackDestinationWidth[m],
2944 									mode_lib->vba.WritebackDestinationHeight[m],
2945 									mode_lib->vba.WritebackSourceHeight[m],
2946 									mode_lib->vba.HTotal[m]) /
2947 									mode_lib->vba.RequiredDISPCLK[i][j]);
2948 						}
2949 					}
2950 				}
2951 			}
2952 			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2953 				for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2954 					if (mode_lib->vba.BlendingAndTiming[k] == m) {
2955 						mode_lib->vba.WritebackDelayTime[k] =
2956 								mode_lib->vba.WritebackDelayTime[m];
2957 					}
2958 				}
2959 			}
2960 			mode_lib->vba.MaxMaxVStartup[i][j] = 0;
2961 			for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2962 				mode_lib->vba.MaximumVStartup[i][j][k] = ((mode_lib->vba.Interlace[k] &&
2963 								!mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
2964 								dml_floor((mode_lib->vba.VTotal[k] -
2965 									mode_lib->vba.VActive[k]) / 2.0, 1.0) :
2966 								mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k])
2967 								- dml_max(1.0, dml_ceil(1.0 *
2968 									mode_lib->vba.WritebackDelayTime[k] /
2969 									(mode_lib->vba.HTotal[k] /
2970 									mode_lib->vba.PixelClock[k]), 1.0));
2971 
2972 				// Clamp to max OTG vstartup register limit
2973 				if (mode_lib->vba.MaximumVStartup[i][j][k] > 1023)
2974 					mode_lib->vba.MaximumVStartup[i][j][k] = 1023;
2975 
2976 				mode_lib->vba.MaxMaxVStartup[i][j] = dml_max(mode_lib->vba.MaxMaxVStartup[i][j],
2977 						mode_lib->vba.MaximumVStartup[i][j][k]);
2978 			}
2979 		}
2980 	}
2981 
2982 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes = mode_lib->vba.NumberOfChannels
2983 			* dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2984 					mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2985 					mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
2986 
2987 	dml32_CalculateMinAndMaxPrefetchMode(mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
2988 			&mode_lib->vba.MinPrefetchMode,
2989 			&mode_lib->vba.MaxPrefetchMode);
2990 
2991 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
2992 		for (j = 0; j <= 1; ++j)
2993 			mode_lib->vba.DCFCLKState[i][j] = mode_lib->vba.DCFCLKPerState[i];
2994 	}
2995 
2996 	/* Immediate Flip and MALL parameters */
2997 	mode_lib->vba.ImmediateFlipRequiredFinal = false;
2998 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2999 		mode_lib->vba.ImmediateFlipRequiredFinal = mode_lib->vba.ImmediateFlipRequiredFinal
3000 				|| (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
3001 	}
3002 
3003 	mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
3004 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3005 		mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
3006 				mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
3007 						|| ((mode_lib->vba.ImmediateFlipRequirement[k]
3008 								!= dm_immediate_flip_required)
3009 								&& (mode_lib->vba.ImmediateFlipRequirement[k]
3010 										!= dm_immediate_flip_not_required));
3011 	}
3012 	mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
3013 			mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
3014 					&& mode_lib->vba.ImmediateFlipRequiredFinal;
3015 
3016 	mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
3017 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3018 		mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
3019 			mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe ||
3020 			((mode_lib->vba.HostVMEnable == true || mode_lib->vba.ImmediateFlipRequirement[k] !=
3021 					dm_immediate_flip_not_required) &&
3022 			(mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame ||
3023 			mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe));
3024 	}
3025 
3026 	mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
3027 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3028 		mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen =
3029 			mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
3030 			|| ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable
3031 			|| mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
3032 			&& (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe))
3033 			|| ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_disable
3034 			|| mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
3035 			&& (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame));
3036 	}
3037 
3038 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = false;
3039 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = false;
3040 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = false;
3041 
3042 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3043 		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame)
3044 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = true;
3045 		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport)
3046 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = true;
3047 		if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe)
3048 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = true;
3049 	}
3050 	mode_lib->vba.InvalidCombinationOfMALLUseForPState = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod
3051 			!= v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod) || (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod);
3052 
3053 	if (mode_lib->vba.UseMinimumRequiredDCFCLK == true) {
3054 		dml32_UseMinimumDCFCLK(
3055 				mode_lib->vba.UsesMALLForPStateChange,
3056 				mode_lib->vba.DRRDisplay,
3057 				mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3058 				mode_lib->vba.MaxInterDCNTileRepeaters,
3059 				mode_lib->vba.MaxPrefetchMode,
3060 				mode_lib->vba.DRAMClockChangeLatency,
3061 				mode_lib->vba.FCLKChangeLatency,
3062 				mode_lib->vba.SREnterPlusExitTime,
3063 				mode_lib->vba.ReturnBusWidth,
3064 				mode_lib->vba.RoundTripPingLatencyCycles,
3065 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
3066 				mode_lib->vba.PixelChunkSizeInKByte,
3067 				mode_lib->vba.MetaChunkSize,
3068 				mode_lib->vba.GPUVMEnable,
3069 				mode_lib->vba.GPUVMMaxPageTableLevels,
3070 				mode_lib->vba.HostVMEnable,
3071 				mode_lib->vba.NumberOfActiveSurfaces,
3072 				mode_lib->vba.HostVMMinPageSize,
3073 				mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3074 				mode_lib->vba.DynamicMetadataVMEnabled,
3075 				mode_lib->vba.ImmediateFlipRequiredFinal,
3076 				mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
3077 				mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
3078 				mode_lib->vba.PercentOfIdealFabricAndSDPPortBWReceivedAfterUrgLatency,
3079 				mode_lib->vba.VTotal,
3080 				mode_lib->vba.VActive,
3081 				mode_lib->vba.DynamicMetadataTransmittedBytes,
3082 				mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired,
3083 				mode_lib->vba.Interlace,
3084 				mode_lib->vba.RequiredDPPCLK,
3085 				mode_lib->vba.RequiredDISPCLK,
3086 				mode_lib->vba.UrgLatency,
3087 				mode_lib->vba.NoOfDPP,
3088 				mode_lib->vba.ProjectedDCFCLKDeepSleep,
3089 				mode_lib->vba.MaximumVStartup,
3090 				mode_lib->vba.TotalNumberOfActiveDPP,
3091 				mode_lib->vba.TotalNumberOfDCCActiveDPP,
3092 				mode_lib->vba.dpte_group_bytes,
3093 				mode_lib->vba.PrefetchLinesY,
3094 				mode_lib->vba.PrefetchLinesC,
3095 				mode_lib->vba.swath_width_luma_ub_all_states,
3096 				mode_lib->vba.swath_width_chroma_ub_all_states,
3097 				mode_lib->vba.BytePerPixelY,
3098 				mode_lib->vba.BytePerPixelC,
3099 				mode_lib->vba.HTotal,
3100 				mode_lib->vba.PixelClock,
3101 				mode_lib->vba.PDEAndMetaPTEBytesPerFrame,
3102 				mode_lib->vba.DPTEBytesPerRow,
3103 				mode_lib->vba.MetaRowBytes,
3104 				mode_lib->vba.DynamicMetadataEnable,
3105 				mode_lib->vba.ReadBandwidthLuma,
3106 				mode_lib->vba.ReadBandwidthChroma,
3107 				mode_lib->vba.DCFCLKPerState,
3108 
3109 				/* Output */
3110 				mode_lib->vba.DCFCLKState);
3111 	} // UseMinimumRequiredDCFCLK == true
3112 
3113 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
3114 		for (j = 0; j <= 1; ++j) {
3115 			mode_lib->vba.ReturnBWPerState[i][j] = dml32_get_return_bw_mbps(&mode_lib->vba.soc, i,
3116 					mode_lib->vba.HostVMEnable, mode_lib->vba.DCFCLKState[i][j],
3117 					mode_lib->vba.FabricClockPerState[i], mode_lib->vba.DRAMSpeedPerState[i]);
3118 		}
3119 	}
3120 
3121 	//Re-ordering Buffer Support Check
3122 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
3123 		for (j = 0; j <= 1; ++j) {
3124 			if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024
3125 					/ mode_lib->vba.ReturnBWPerState[i][j]
3126 					> (mode_lib->vba.RoundTripPingLatencyCycles + 32)
3127 							/ mode_lib->vba.DCFCLKState[i][j]
3128 							+ v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes / mode_lib->vba.ReturnBWPerState[i][j]) {
3129 				mode_lib->vba.ROBSupport[i][j] = true;
3130 			} else {
3131 				mode_lib->vba.ROBSupport[i][j] = false;
3132 			}
3133 		}
3134 	}
3135 
3136 	//Vertical Active BW support check
3137 	v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth = 0;
3138 
3139 	for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3140 		v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth += mode_lib->vba.ReadBandwidthLuma[k]
3141 				+ mode_lib->vba.ReadBandwidthChroma[k];
3142 	}
3143 
3144 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
3145 		for (j = 0; j <= 1; ++j) {
3146 			mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j] =
3147 				dml_min3(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKState[i][j]
3148 					* mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
3149 					mode_lib->vba.FabricClockPerState[i]
3150 					* mode_lib->vba.FabricDatapathToDCNDataReturn
3151 					* mode_lib->vba.MaxAveragePercentOfIdealFabricBWDisplayCanUseInNormalSystemOperation / 100,
3152 					mode_lib->vba.DRAMSpeedPerState[i]
3153 					* mode_lib->vba.NumberOfChannels
3154 					* mode_lib->vba.DRAMChannelWidth
3155 					* (i < 2 ? mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperationSTROBE : mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation) / 100);
3156 
3157 			if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth
3158 					<= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
3159 				mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = true;
3160 			} else {
3161 				mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = false;
3162 			}
3163 		}
3164 	}
3165 
3166 	/* Prefetch Check */
3167 
3168 	for (i = start_state; i < (int) v->soc.num_states; ++i) {
3169 		for (j = 0; j <= 1; ++j) {
3170 
3171 			mode_lib->vba.TimeCalc = 24 / mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3172 
3173 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3174 				mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
3175 				mode_lib->vba.swath_width_luma_ub_this_state[k] =
3176 						mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
3177 				mode_lib->vba.swath_width_chroma_ub_this_state[k] =
3178 						mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
3179 				mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
3180 				mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
3181 				mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
3182 				mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
3183 				mode_lib->vba.UnboundedRequestEnabledThisState =
3184 						mode_lib->vba.UnboundedRequestEnabledAllStates[i][j];
3185 				mode_lib->vba.CompressedBufferSizeInkByteThisState =
3186 						mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j];
3187 				mode_lib->vba.DETBufferSizeInKByteThisState[k] =
3188 						mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
3189 				mode_lib->vba.DETBufferSizeYThisState[k] =
3190 						mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
3191 				mode_lib->vba.DETBufferSizeCThisState[k] =
3192 						mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
3193 			}
3194 
3195 			mode_lib->vba.VActiveBandwithSupport[i][j] = dml32_CalculateVActiveBandwithSupport(
3196 					mode_lib->vba.NumberOfActiveSurfaces,
3197 					mode_lib->vba.ReturnBWPerState[i][j],
3198 					mode_lib->vba.NoUrgentLatencyHiding,
3199 					mode_lib->vba.ReadBandwidthLuma,
3200 					mode_lib->vba.ReadBandwidthChroma,
3201 					mode_lib->vba.cursor_bw,
3202 					mode_lib->vba.meta_row_bandwidth_this_state,
3203 					mode_lib->vba.dpte_row_bandwidth_this_state,
3204 					mode_lib->vba.NoOfDPPThisState,
3205 					mode_lib->vba.UrgentBurstFactorLuma,
3206 					mode_lib->vba.UrgentBurstFactorChroma,
3207 					mode_lib->vba.UrgentBurstFactorCursor);
3208 
3209 			mode_lib->vba.NotEnoughDETSwathFillLatencyHidingPerState[i][j] = dml32_CalculateDETSwathFillLatencyHiding(
3210 					mode_lib->vba.NumberOfActiveSurfaces,
3211 					mode_lib->vba.ReturnBWPerState[i][j],
3212 					mode_lib->vba.UrgLatency[i],
3213 					mode_lib->vba.SwathHeightYThisState,
3214 					mode_lib->vba.SwathHeightCThisState,
3215 					mode_lib->vba.swath_width_luma_ub_this_state,
3216 					mode_lib->vba.swath_width_chroma_ub_this_state,
3217 					mode_lib->vba.BytePerPixelInDETY,
3218 					mode_lib->vba.BytePerPixelInDETC,
3219 					mode_lib->vba.DETBufferSizeYThisState,
3220 					mode_lib->vba.DETBufferSizeCThisState,
3221 					mode_lib->vba.NoOfDPPThisState,
3222 					mode_lib->vba.HTotal,
3223 					mode_lib->vba.PixelClock,
3224 					mode_lib->vba.VRatio,
3225 					mode_lib->vba.VRatioChroma,
3226 					mode_lib->vba.UsesMALLForPStateChange,
3227 					mode_lib->vba.UseUnboundedRequesting);
3228 
3229 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState = dml32_get_return_bw_mbps_vm_only(&mode_lib->vba.soc, i,
3230 					mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.FabricClockPerState[i],
3231 					mode_lib->vba.DRAMSpeedPerState[i]);
3232 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = 1;
3233 
3234 			if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
3235 				v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = mode_lib->vba.ReturnBWPerState[i][j]
3236 						/ v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState;
3237 
3238 			mode_lib->vba.ExtraLatency = dml32_CalculateExtraLatency(
3239 					mode_lib->vba.RoundTripPingLatencyCycles, v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
3240 					mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.TotalNumberOfActiveDPP[i][j],
3241 					mode_lib->vba.PixelChunkSizeInKByte,
3242 					mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j], mode_lib->vba.MetaChunkSize,
3243 					mode_lib->vba.ReturnBWPerState[i][j], mode_lib->vba.GPUVMEnable,
3244 					mode_lib->vba.HostVMEnable, mode_lib->vba.NumberOfActiveSurfaces,
3245 					mode_lib->vba.NoOfDPPThisState, mode_lib->vba.dpte_group_bytes,
3246 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor, mode_lib->vba.HostVMMinPageSize,
3247 					mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
3248 
3249 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = mode_lib->vba.MinPrefetchMode;
3250 
3251 			mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3252 
3253 			do {
3254 				mode_lib->vba.PrefetchModePerState[i][j] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState;
3255 				mode_lib->vba.MaxVStartup = mode_lib->vba.NextMaxVStartup;
3256 
3257 				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3258 					mode_lib->vba.TWait = dml32_CalculateTWait(
3259 							mode_lib->vba.PrefetchModePerState[i][j],
3260 							mode_lib->vba.UsesMALLForPStateChange[k],
3261 							mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3262 							mode_lib->vba.DRRDisplay[k],
3263 							mode_lib->vba.DRAMClockChangeLatency,
3264 							mode_lib->vba.FCLKChangeLatency, mode_lib->vba.UrgLatency[i],
3265 							mode_lib->vba.SREnterPlusExitTime);
3266 
3267 					memset(&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull, 0, sizeof(DmlPipe));
3268 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dppclk = mode_lib->vba.RequiredDPPCLK[i][j][k];
3269 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dispclk = mode_lib->vba.RequiredDISPCLK[i][j];
3270 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
3271 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCFClkDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3272 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
3273 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
3274 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
3275 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
3276 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
3277 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
3278 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
3279 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
3280 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
3281 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
3282 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HTotal = mode_lib->vba.HTotal[k];
3283 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HActive = mode_lib->vba.HActive[k];
3284 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
3285 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ODMMode = mode_lib->vba.ODMCombineEnablePerState[i][k];
3286 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
3287 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
3288 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
3289 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ProgressiveToInterlaceUnitInOPP =
3290 							mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
3291 
3292 					mode_lib->vba.NoTimeForPrefetch[i][j][k] =
3293 						dml32_CalculatePrefetchSchedule(
3294 							v,
3295 							k,
3296 							v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3297 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe,
3298 							v->DSCDelayPerState[i][k],
3299 							v->SwathWidthYThisState[k] / v->HRatio[k],
3300 							dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
3301 							v->MaximumVStartup[i][j][k],
3302 							v->UrgLatency[i],
3303 							v->ExtraLatency,
3304 							v->TimeCalc,
3305 							v->PDEAndMetaPTEBytesPerFrame[i][j][k],
3306 							v->MetaRowBytes[i][j][k],
3307 							v->DPTEBytesPerRow[i][j][k],
3308 							v->PrefetchLinesY[i][j][k],
3309 							v->SwathWidthYThisState[k],
3310 							v->PrefillY[k],
3311 							v->MaxNumSwY[k],
3312 							v->PrefetchLinesC[i][j][k],
3313 							v->SwathWidthCThisState[k],
3314 							v->PrefillC[k],
3315 							v->MaxNumSwC[k],
3316 							v->swath_width_luma_ub_this_state[k],
3317 							v->swath_width_chroma_ub_this_state[k],
3318 							v->SwathHeightYThisState[k],
3319 							v->SwathHeightCThisState[k], v->TWait,
3320 							(v->DRAMSpeedPerState[i] <= MEM_STROBE_FREQ_MHZ || v->DCFCLKState[i][j] <= DCFCLK_FREQ_EXTRA_PREFETCH_REQ_MHZ) ?
3321 									mode_lib->vba.ip.min_prefetch_in_strobe_us : 0,
3322 							mode_lib->vba.PrefetchModePerState[i][j] > 0 || mode_lib->vba.DRAMClockChangeRequirementFinal == false,
3323 
3324 							/* Output */
3325 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler[k],
3326 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler[k],
3327 							&v->LineTimesForPrefetch[k],
3328 							&v->PrefetchBW[k],
3329 							&v->LinesForMetaPTE[k],
3330 							&v->LinesForMetaAndDPTERow[k],
3331 							&v->VRatioPreY[i][j][k],
3332 							&v->VRatioPreC[i][j][k],
3333 							&v->RequiredPrefetchPixelDataBWLuma[0][0][k],
3334 							&v->RequiredPrefetchPixelDataBWChroma[0][0][k],
3335 							&v->NoTimeForDynamicMetadata[i][j][k],
3336 							&v->Tno_bw[k],
3337 							&v->prefetch_vmrow_bw[k],
3338 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],         // double *Tdmdl_vm
3339 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],         // double *Tdmdl
3340 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[2],         // double *TSetup
3341 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0],         							    // unsigned int   *VUpdateOffsetPix
3342 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[3],         // unsigned int   *VUpdateWidthPix
3343 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[4]);        // unsigned int   *VReadyOffsetPix
3344 				}
3345 
3346 				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3347 					dml32_CalculateUrgentBurstFactor(
3348 							mode_lib->vba.UsesMALLForPStateChange[k],
3349 							mode_lib->vba.swath_width_luma_ub_this_state[k],
3350 							mode_lib->vba.swath_width_chroma_ub_this_state[k],
3351 							mode_lib->vba.SwathHeightYThisState[k],
3352 							mode_lib->vba.SwathHeightCThisState[k],
3353 							mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
3354 							mode_lib->vba.UrgLatency[i], mode_lib->vba.CursorBufferSize,
3355 							mode_lib->vba.CursorWidth[k][0], mode_lib->vba.CursorBPP[k][0],
3356 							mode_lib->vba.VRatioPreY[i][j][k],
3357 							mode_lib->vba.VRatioPreC[i][j][k],
3358 							mode_lib->vba.BytePerPixelInDETY[k],
3359 							mode_lib->vba.BytePerPixelInDETC[k],
3360 							mode_lib->vba.DETBufferSizeYThisState[k],
3361 							mode_lib->vba.DETBufferSizeCThisState[k],
3362 							/* Output */
3363 							&mode_lib->vba.UrgentBurstFactorCursorPre[k],
3364 							&mode_lib->vba.UrgentBurstFactorLumaPre[k],
3365 							&mode_lib->vba.UrgentBurstFactorChromaPre[k],
3366 							&mode_lib->vba.NotUrgentLatencyHidingPre[k]);
3367 				}
3368 
3369 				{
3370 					dml32_CalculatePrefetchBandwithSupport(
3371 							mode_lib->vba.NumberOfActiveSurfaces,
3372 							mode_lib->vba.ReturnBWPerState[i][j],
3373 							mode_lib->vba.NotUrgentLatencyHidingPre,
3374 							mode_lib->vba.ReadBandwidthLuma,
3375 							mode_lib->vba.ReadBandwidthChroma,
3376 							mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3377 							mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3378 							mode_lib->vba.cursor_bw,
3379 							mode_lib->vba.meta_row_bandwidth_this_state,
3380 							mode_lib->vba.dpte_row_bandwidth_this_state,
3381 							mode_lib->vba.cursor_bw_pre,
3382 							mode_lib->vba.prefetch_vmrow_bw,
3383 							mode_lib->vba.NoOfDPPThisState,
3384 							mode_lib->vba.UrgentBurstFactorLuma,
3385 							mode_lib->vba.UrgentBurstFactorChroma,
3386 							mode_lib->vba.UrgentBurstFactorCursor,
3387 							mode_lib->vba.UrgentBurstFactorLumaPre,
3388 							mode_lib->vba.UrgentBurstFactorChromaPre,
3389 							mode_lib->vba.UrgentBurstFactorCursorPre,
3390 							v->PrefetchBW,
3391 							v->VRatio,
3392 							v->MaxVRatioPre,
3393 
3394 							/* output */
3395 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],   // Single  *PrefetchBandwidth
3396 							&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],   // Single  *FractionOfUrgentBandwidth
3397 							&mode_lib->vba.PrefetchSupported[i][j]);
3398 				}
3399 
3400 				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3401 					if (mode_lib->vba.LineTimesForPrefetch[k]
3402 							< 2.0 || mode_lib->vba.LinesForMetaPTE[k] >= 32.0
3403 							|| mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16.0
3404 							|| mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3405 						mode_lib->vba.PrefetchSupported[i][j] = false;
3406 					}
3407 				}
3408 
3409 				mode_lib->vba.DynamicMetadataSupported[i][j] = true;
3410 				for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3411 					if (mode_lib->vba.NoTimeForDynamicMetadata[i][j][k] == true)
3412 						mode_lib->vba.DynamicMetadataSupported[i][j] = false;
3413 				}
3414 
3415 				mode_lib->vba.VRatioInPrefetchSupported[i][j] = true;
3416 				for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3417 					if (mode_lib->vba.VRatioPreY[i][j][k] > mode_lib->vba.MaxVRatioPre
3418 							|| mode_lib->vba.VRatioPreC[i][j][k] > mode_lib->vba.MaxVRatioPre
3419 							|| mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3420 						mode_lib->vba.VRatioInPrefetchSupported[i][j] = false;
3421 					}
3422 				}
3423 				mode_lib->vba.AnyLinesForVMOrRowTooLarge = false;
3424 				for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3425 					if (mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16
3426 							|| mode_lib->vba.LinesForMetaPTE[k] >= 32) {
3427 						mode_lib->vba.AnyLinesForVMOrRowTooLarge = true;
3428 					}
3429 				}
3430 
3431 				if (mode_lib->vba.PrefetchSupported[i][j] == true
3432 						&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
3433 					mode_lib->vba.BandwidthAvailableForImmediateFlip =
3434 							dml32_CalculateBandwidthAvailableForImmediateFlip(
3435 							mode_lib->vba.NumberOfActiveSurfaces,
3436 							mode_lib->vba.ReturnBWPerState[i][j],
3437 							mode_lib->vba.ReadBandwidthLuma,
3438 							mode_lib->vba.ReadBandwidthChroma,
3439 							mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3440 							mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3441 							mode_lib->vba.cursor_bw,
3442 							mode_lib->vba.cursor_bw_pre,
3443 							mode_lib->vba.NoOfDPPThisState,
3444 							mode_lib->vba.UrgentBurstFactorLuma,
3445 							mode_lib->vba.UrgentBurstFactorChroma,
3446 							mode_lib->vba.UrgentBurstFactorCursor,
3447 							mode_lib->vba.UrgentBurstFactorLumaPre,
3448 							mode_lib->vba.UrgentBurstFactorChromaPre,
3449 							mode_lib->vba.UrgentBurstFactorCursorPre);
3450 
3451 					mode_lib->vba.TotImmediateFlipBytes = 0.0;
3452 					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3453 						if (!(mode_lib->vba.ImmediateFlipRequirement[k] ==
3454 								dm_immediate_flip_not_required)) {
3455 							mode_lib->vba.TotImmediateFlipBytes =
3456 									mode_lib->vba.TotImmediateFlipBytes
3457 								+ mode_lib->vba.NoOfDPP[i][j][k]
3458 								* mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k]
3459 								+ mode_lib->vba.MetaRowBytes[i][j][k];
3460 							if (mode_lib->vba.use_one_row_for_frame_flip[i][j][k]) {
3461 								mode_lib->vba.TotImmediateFlipBytes =
3462 									mode_lib->vba.TotImmediateFlipBytes + 2
3463 								* mode_lib->vba.DPTEBytesPerRow[i][j][k];
3464 							} else {
3465 								mode_lib->vba.TotImmediateFlipBytes =
3466 									mode_lib->vba.TotImmediateFlipBytes
3467 								+ mode_lib->vba.DPTEBytesPerRow[i][j][k];
3468 							}
3469 						}
3470 					}
3471 
3472 					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3473 						dml32_CalculateFlipSchedule(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3474 							mode_lib->vba.ExtraLatency,
3475 							mode_lib->vba.UrgLatency[i],
3476 							mode_lib->vba.GPUVMMaxPageTableLevels,
3477 							mode_lib->vba.HostVMEnable,
3478 							mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3479 							mode_lib->vba.GPUVMEnable,
3480 							mode_lib->vba.HostVMMinPageSize,
3481 							mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k],
3482 							mode_lib->vba.MetaRowBytes[i][j][k],
3483 							mode_lib->vba.DPTEBytesPerRow[i][j][k],
3484 							mode_lib->vba.BandwidthAvailableForImmediateFlip,
3485 							mode_lib->vba.TotImmediateFlipBytes,
3486 							mode_lib->vba.SourcePixelFormat[k],
3487 							(mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]),
3488 							mode_lib->vba.VRatio[k],
3489 							mode_lib->vba.VRatioChroma[k],
3490 							mode_lib->vba.Tno_bw[k],
3491 								mode_lib->vba.DCCEnable[k],
3492 							mode_lib->vba.dpte_row_height[k],
3493 							mode_lib->vba.meta_row_height[k],
3494 							mode_lib->vba.dpte_row_height_chroma[k],
3495 							mode_lib->vba.meta_row_height_chroma[k],
3496 							mode_lib->vba.use_one_row_for_frame_flip[i][j][k], // 24
3497 
3498 							/* Output */
3499 							&mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
3500 							&mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
3501 							&mode_lib->vba.final_flip_bw[k],
3502 							&mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
3503 					}
3504 
3505 					{
3506 						dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
3507 								mode_lib->vba.ReturnBWPerState[i][j],
3508 								mode_lib->vba.ImmediateFlipRequirement,
3509 								mode_lib->vba.final_flip_bw,
3510 								mode_lib->vba.ReadBandwidthLuma,
3511 								mode_lib->vba.ReadBandwidthChroma,
3512 								mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3513 								mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3514 								mode_lib->vba.cursor_bw,
3515 								mode_lib->vba.meta_row_bandwidth_this_state,
3516 								mode_lib->vba.dpte_row_bandwidth_this_state,
3517 								mode_lib->vba.cursor_bw_pre,
3518 								mode_lib->vba.prefetch_vmrow_bw,
3519 								mode_lib->vba.DPPPerPlane,
3520 								mode_lib->vba.UrgentBurstFactorLuma,
3521 								mode_lib->vba.UrgentBurstFactorChroma,
3522 								mode_lib->vba.UrgentBurstFactorCursor,
3523 								mode_lib->vba.UrgentBurstFactorLumaPre,
3524 								mode_lib->vba.UrgentBurstFactorChromaPre,
3525 								mode_lib->vba.UrgentBurstFactorCursorPre,
3526 
3527 								/* output */
3528 								&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0], //  Single  *TotalBandwidth
3529 								&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1], //  Single  *FractionOfUrgentBandwidth
3530 								&mode_lib->vba.ImmediateFlipSupportedForState[i][j]); // Boolean *ImmediateFlipBandwidthSupport
3531 					}
3532 
3533 					for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3534 						if (!(mode_lib->vba.ImmediateFlipRequirement[k]
3535 								== dm_immediate_flip_not_required)
3536 								&& (mode_lib->vba.ImmediateFlipSupportedForPipe[k]
3537 										== false))
3538 							mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3539 					}
3540 				} else { // if prefetch not support, assume iflip not supported
3541 					mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3542 				}
3543 
3544 				if (mode_lib->vba.MaxVStartup <= __DML_VBA_MIN_VSTARTUP__
3545 						|| mode_lib->vba.AnyLinesForVMOrRowTooLarge == false) {
3546 					mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3547 					v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState + 1;
3548 				} else {
3549 					mode_lib->vba.NextMaxVStartup = mode_lib->vba.NextMaxVStartup - 1;
3550 				}
3551 			} while (!((mode_lib->vba.PrefetchSupported[i][j] == true
3552 					&& mode_lib->vba.DynamicMetadataSupported[i][j] == true
3553 					&& mode_lib->vba.VRatioInPrefetchSupported[i][j] == true &&
3554 					// consider flip support is okay if when there is no hostvm and the
3555 					// user does't require a iflip OR the flip bw is ok
3556 					// If there is hostvm, DCN needs to support iflip for invalidation
3557 					((mode_lib->vba.HostVMEnable == false
3558 							&& !mode_lib->vba.ImmediateFlipRequiredFinal)
3559 							|| mode_lib->vba.ImmediateFlipSupportedForState[i][j] == true))
3560 					|| (mode_lib->vba.NextMaxVStartup == mode_lib->vba.MaxMaxVStartup[i][j]
3561 							&& v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState > mode_lib->vba.MaxPrefetchMode)));
3562 
3563 			for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3564 				mode_lib->vba.use_one_row_for_frame_this_state[k] =
3565 						mode_lib->vba.use_one_row_for_frame[i][j][k];
3566 			}
3567 
3568 
3569 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.UrgentLatency = mode_lib->vba.UrgLatency[i];
3570 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.ExtraLatency = mode_lib->vba.ExtraLatency;
3571 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
3572 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
3573 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
3574 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
3575 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
3576 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
3577 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
3578 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
3579 			v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
3580 
3581 			{
3582 				dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
3583 						v,
3584 						v->PrefetchModePerState[i][j],
3585 						v->DCFCLKState[i][j],
3586 						v->ReturnBWPerState[i][j],
3587 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters,
3588 						v->SOCCLKPerState[i],
3589 						v->ProjectedDCFCLKDeepSleep[i][j],
3590 						v->DETBufferSizeYThisState,
3591 						v->DETBufferSizeCThisState,
3592 						v->SwathHeightYThisState,
3593 						v->SwathHeightCThisState,
3594 						v->SwathWidthYThisState, // 24
3595 						v->SwathWidthCThisState,
3596 						v->NoOfDPPThisState,
3597 						v->BytePerPixelInDETY,
3598 						v->BytePerPixelInDETC,
3599 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler,
3600 						v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler,
3601 						v->UnboundedRequestEnabledThisState,
3602 						v->CompressedBufferSizeInkByteThisState,
3603 
3604 						/* Output */
3605 						&v->DRAMClockChangeSupport[i][j],
3606 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[0], // double *MaxActiveDRAMClockChangeLatencySupported
3607 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], // Long SubViewportLinesNeededInMALL[]
3608 						&v->FCLKChangeSupport[i][j],
3609 						&v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[1], // double *MinActiveFCLKChangeLatencySupported
3610 						&mode_lib->vba.USRRetrainingSupport[i][j],
3611 						mode_lib->vba.ActiveDRAMClockChangeLatencyMarginPerState[i][j]);
3612 			}
3613 		}
3614 	} // End of Prefetch Check
3615 
3616 	/*Cursor Support Check*/
3617 	mode_lib->vba.CursorSupport = true;
3618 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3619 		if (mode_lib->vba.CursorWidth[k][0] > 0.0) {
3620 			if (mode_lib->vba.CursorBPP[k][0] == 64 && mode_lib->vba.Cursor64BppSupport == false)
3621 				mode_lib->vba.CursorSupport = false;
3622 		}
3623 	}
3624 
3625 	/*Valid Pitch Check*/
3626 	mode_lib->vba.PitchSupport = true;
3627 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3628 		mode_lib->vba.AlignedYPitch[k] = dml_ceil(
3629 				dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3630 				mode_lib->vba.MacroTileWidthY[k]);
3631 		if (mode_lib->vba.DCCEnable[k] == true) {
3632 			mode_lib->vba.AlignedDCCMetaPitchY[k] = dml_ceil(
3633 					dml_max(mode_lib->vba.DCCMetaPitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3634 					64.0 * mode_lib->vba.Read256BlockWidthY[k]);
3635 		} else {
3636 			mode_lib->vba.AlignedDCCMetaPitchY[k] = mode_lib->vba.DCCMetaPitchY[k];
3637 		}
3638 		if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3639 				&& mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3640 				&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3641 				&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
3642 				&& mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
3643 			mode_lib->vba.AlignedCPitch[k] = dml_ceil(
3644 					dml_max(mode_lib->vba.PitchC[k], mode_lib->vba.SurfaceWidthC[k]),
3645 					mode_lib->vba.MacroTileWidthC[k]);
3646 			if (mode_lib->vba.DCCEnable[k] == true) {
3647 				mode_lib->vba.AlignedDCCMetaPitchC[k] = dml_ceil(
3648 						dml_max(mode_lib->vba.DCCMetaPitchC[k],
3649 								mode_lib->vba.SurfaceWidthC[k]),
3650 						64.0 * mode_lib->vba.Read256BlockWidthC[k]);
3651 			} else {
3652 				mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3653 			}
3654 		} else {
3655 			mode_lib->vba.AlignedCPitch[k] = mode_lib->vba.PitchC[k];
3656 			mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3657 		}
3658 		if (mode_lib->vba.AlignedYPitch[k] > mode_lib->vba.PitchY[k]
3659 				|| mode_lib->vba.AlignedCPitch[k] > mode_lib->vba.PitchC[k]
3660 				|| mode_lib->vba.AlignedDCCMetaPitchY[k] > mode_lib->vba.DCCMetaPitchY[k]
3661 				|| mode_lib->vba.AlignedDCCMetaPitchC[k] > mode_lib->vba.DCCMetaPitchC[k]) {
3662 			mode_lib->vba.PitchSupport = false;
3663 		}
3664 	}
3665 
3666 	mode_lib->vba.ViewportExceedsSurface = false;
3667 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3668 		if (mode_lib->vba.ViewportWidth[k] > mode_lib->vba.SurfaceWidthY[k]
3669 				|| mode_lib->vba.ViewportHeight[k] > mode_lib->vba.SurfaceHeightY[k]) {
3670 			mode_lib->vba.ViewportExceedsSurface = true;
3671 			if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3672 					&& mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3673 					&& mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3674 					&& mode_lib->vba.SourcePixelFormat[k] != dm_444_8
3675 					&& mode_lib->vba.SourcePixelFormat[k] != dm_rgbe) {
3676 				if (mode_lib->vba.ViewportWidthChroma[k] > mode_lib->vba.SurfaceWidthC[k]
3677 						|| mode_lib->vba.ViewportHeightChroma[k]
3678 								> mode_lib->vba.SurfaceHeightC[k]) {
3679 					mode_lib->vba.ViewportExceedsSurface = true;
3680 				}
3681 			}
3682 		}
3683 	}
3684 
3685 	/*Mode Support, Voltage State and SOC Configuration*/
3686 	mode_support_configuration(v, mode_lib);
3687 
3688 	MaximumMPCCombine = 0;
3689 
3690 	for (i = v->soc.num_states; i >= start_state; i--) {
3691 		if (i == v->soc.num_states || mode_lib->vba.ModeSupport[i][0] == true ||
3692 				mode_lib->vba.ModeSupport[i][1] == true) {
3693 			mode_lib->vba.VoltageLevel = i;
3694 			mode_lib->vba.ModeIsSupported = mode_lib->vba.ModeSupport[i][0] == true
3695 					|| mode_lib->vba.ModeSupport[i][1] == true;
3696 
3697 			if (mode_lib->vba.ModeSupport[i][0] == true)
3698 				MaximumMPCCombine = 0;
3699 			else
3700 				MaximumMPCCombine = 1;
3701 		}
3702 	}
3703 
3704 	mode_lib->vba.ImmediateFlipSupport =
3705 			mode_lib->vba.ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3706 	mode_lib->vba.UnboundedRequestEnabled =
3707 			mode_lib->vba.UnboundedRequestEnabledAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3708 	mode_lib->vba.CompressedBufferSizeInkByte =
3709 			mode_lib->vba.CompressedBufferSizeInkByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; // Not used, informational
3710 
3711 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3712 		mode_lib->vba.MPCCombineEnable[k] =
3713 				mode_lib->vba.MPCCombine[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3714 		mode_lib->vba.DPPPerPlane[k] = mode_lib->vba.NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3715 		mode_lib->vba.SwathHeightY[k] =
3716 				mode_lib->vba.SwathHeightYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3717 		mode_lib->vba.SwathHeightC[k] =
3718 				mode_lib->vba.SwathHeightCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3719 		mode_lib->vba.DETBufferSizeInKByte[k] =
3720 			mode_lib->vba.DETBufferSizeInKByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3721 		mode_lib->vba.DETBufferSizeY[k] =
3722 				mode_lib->vba.DETBufferSizeYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3723 		mode_lib->vba.DETBufferSizeC[k] =
3724 				mode_lib->vba.DETBufferSizeCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3725 		mode_lib->vba.OutputType[k] = mode_lib->vba.OutputTypePerState[mode_lib->vba.VoltageLevel][k];
3726 		mode_lib->vba.OutputRate[k] = mode_lib->vba.OutputRatePerState[mode_lib->vba.VoltageLevel][k];
3727 	}
3728 
3729 	mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3730 	mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
3731 	mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
3732 	mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
3733 	mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBWPerState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3734 	mode_lib->vba.DISPCLK = mode_lib->vba.RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3735 	mode_lib->vba.maxMpcComb = MaximumMPCCombine;
3736 
3737 	for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3738 		if (mode_lib->vba.BlendingAndTiming[k] == k) {
3739 			mode_lib->vba.ODMCombineEnabled[k] =
3740 					mode_lib->vba.ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
3741 		} else {
3742 			mode_lib->vba.ODMCombineEnabled[k] = dm_odm_combine_mode_disabled;
3743 		}
3744 
3745 		mode_lib->vba.DSCEnabled[k] = mode_lib->vba.RequiresDSC[mode_lib->vba.VoltageLevel][k];
3746 		mode_lib->vba.FECEnable[k] = mode_lib->vba.RequiresFEC[mode_lib->vba.VoltageLevel][k];
3747 		mode_lib->vba.OutputBpp[k] = mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k];
3748 	}
3749 
3750 	mode_lib->vba.UrgentWatermark = mode_lib->vba.Watermark.UrgentWatermark;
3751 	mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.Watermark.StutterEnterPlusExitWatermark;
3752 	mode_lib->vba.StutterExitWatermark = mode_lib->vba.Watermark.StutterExitWatermark;
3753 	mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.Watermark.WritebackDRAMClockChangeWatermark;
3754 	mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.Watermark.DRAMClockChangeWatermark;
3755 	mode_lib->vba.UrgentLatency = mode_lib->vba.UrgLatency[mode_lib->vba.VoltageLevel];
3756 	mode_lib->vba.DCFCLKDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3757 
3758 	/* VBA has Error type to Error Msg output here, but not necessary for DML-C */
3759 } // ModeSupportAndSystemConfigurationFull
3760