1 /*
2  * Copyright 2020 Advanced Micro Devices, Inc.
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_30.h"
29 #include "../dml_inline_defs.h"
30 
31 
32 /*
33  * NOTE:
34  *   This file is gcc-parsable HW gospel, coming straight from HW engineers.
35  *
36  * It doesn't adhere to Linux kernel style and sometimes will do things in odd
37  * ways. Unless there is something clearly wrong with it the code should
38  * remain as-is as it provides us with a guarantee from HW that it is correct.
39  */
40 
41 
42 typedef struct {
43 	double DPPCLK;
44 	double DISPCLK;
45 	double PixelClock;
46 	double DCFCLKDeepSleep;
47 	unsigned int DPPPerPlane;
48 	bool ScalerEnabled;
49 	enum scan_direction_class SourceScan;
50 	unsigned int BlockWidth256BytesY;
51 	unsigned int BlockHeight256BytesY;
52 	unsigned int BlockWidth256BytesC;
53 	unsigned int BlockHeight256BytesC;
54 	unsigned int InterlaceEnable;
55 	unsigned int NumberOfCursors;
56 	unsigned int VBlank;
57 	unsigned int HTotal;
58 	unsigned int DCCEnable;
59 	bool ODMCombineEnabled;
60 } Pipe;
61 
62 #define BPP_INVALID 0
63 #define BPP_BLENDED_PIPE 0xffffffff
64 #define DCN30_MAX_DSC_IMAGE_WIDTH 5184
65 #define DCN30_MAX_FMT_420_BUFFER_WIDTH 4096
66 
67 static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib);
68 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
69 		struct display_mode_lib *mode_lib);
70 static unsigned int dscceComputeDelay(
71 		unsigned int bpc,
72 		double BPP,
73 		unsigned int sliceWidth,
74 		unsigned int numSlices,
75 		enum output_format_class pixelFormat,
76 		enum output_encoder_class Output);
77 static unsigned int dscComputeDelay(
78 		enum output_format_class pixelFormat,
79 		enum output_encoder_class Output);
80 // Super monster function with some 45 argument
81 static bool CalculatePrefetchSchedule(
82 		struct display_mode_lib *mode_lib,
83 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
84 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
85 		Pipe *myPipe,
86 		unsigned int DSCDelay,
87 		double DPPCLKDelaySubtotalPlusCNVCFormater,
88 		double DPPCLKDelaySCL,
89 		double DPPCLKDelaySCLLBOnly,
90 		double DPPCLKDelayCNVCCursor,
91 		double DISPCLKDelaySubtotal,
92 		unsigned int DPP_RECOUT_WIDTH,
93 		enum output_format_class OutputFormat,
94 		unsigned int MaxInterDCNTileRepeaters,
95 		unsigned int VStartup,
96 		unsigned int MaxVStartup,
97 		unsigned int GPUVMPageTableLevels,
98 		bool GPUVMEnable,
99 		bool HostVMEnable,
100 		unsigned int HostVMMaxNonCachedPageTableLevels,
101 		double HostVMMinPageSize,
102 		bool DynamicMetadataEnable,
103 		bool DynamicMetadataVMEnabled,
104 		int DynamicMetadataLinesBeforeActiveRequired,
105 		unsigned int DynamicMetadataTransmittedBytes,
106 		double UrgentLatency,
107 		double UrgentExtraLatency,
108 		double TCalc,
109 		unsigned int PDEAndMetaPTEBytesFrame,
110 		unsigned int MetaRowByte,
111 		unsigned int PixelPTEBytesPerRow,
112 		double PrefetchSourceLinesY,
113 		unsigned int SwathWidthY,
114 		int BytePerPixelY,
115 		double VInitPreFillY,
116 		unsigned int MaxNumSwathY,
117 		double PrefetchSourceLinesC,
118 		unsigned int SwathWidthC,
119 		int BytePerPixelC,
120 		double VInitPreFillC,
121 		unsigned int MaxNumSwathC,
122 		long swath_width_luma_ub,
123 		long swath_width_chroma_ub,
124 		unsigned int SwathHeightY,
125 		unsigned int SwathHeightC,
126 		double TWait,
127 		bool ProgressiveToInterlaceUnitInOPP,
128 		double *DSTXAfterScaler,
129 		double *DSTYAfterScaler,
130 		double *DestinationLinesForPrefetch,
131 		double *PrefetchBandwidth,
132 		double *DestinationLinesToRequestVMInVBlank,
133 		double *DestinationLinesToRequestRowInVBlank,
134 		double *VRatioPrefetchY,
135 		double *VRatioPrefetchC,
136 		double *RequiredPrefetchPixDataBWLuma,
137 		double *RequiredPrefetchPixDataBWChroma,
138 		bool *NotEnoughTimeForDynamicMetadata,
139 		double *Tno_bw,
140 		double *prefetch_vmrow_bw,
141 		double *Tdmdl_vm,
142 		double *Tdmdl,
143 		unsigned int *VUpdateOffsetPix,
144 		double *VUpdateWidthPix,
145 		double *VReadyOffsetPix);
146 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed);
147 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed);
148 static void CalculateDCCConfiguration(
149 		bool DCCEnabled,
150 		bool DCCProgrammingAssumesScanDirectionUnknown,
151 		enum source_format_class SourcePixelFormat,
152 		unsigned int ViewportWidthLuma,
153 		unsigned int ViewportWidthChroma,
154 		unsigned int ViewportHeightLuma,
155 		unsigned int ViewportHeightChroma,
156 		double DETBufferSize,
157 		unsigned int RequestHeight256ByteLuma,
158 		unsigned int RequestHeight256ByteChroma,
159 		enum dm_swizzle_mode TilingFormat,
160 		unsigned int BytePerPixelY,
161 		unsigned int BytePerPixelC,
162 		double BytePerPixelDETY,
163 		double BytePerPixelDETC,
164 		enum scan_direction_class ScanOrientation,
165 		unsigned int *MaxUncompressedBlockLuma,
166 		unsigned int *MaxUncompressedBlockChroma,
167 		unsigned int *MaxCompressedBlockLuma,
168 		unsigned int *MaxCompressedBlockChroma,
169 		unsigned int *IndependentBlockLuma,
170 		unsigned int *IndependentBlockChroma);
171 static double CalculatePrefetchSourceLines(
172 		struct display_mode_lib *mode_lib,
173 		double VRatio,
174 		double vtaps,
175 		bool Interlace,
176 		bool ProgressiveToInterlaceUnitInOPP,
177 		unsigned int SwathHeight,
178 		unsigned int ViewportYStart,
179 		double *VInitPreFill,
180 		unsigned int *MaxNumSwath);
181 static unsigned int CalculateVMAndRowBytes(
182 		struct display_mode_lib *mode_lib,
183 		bool DCCEnable,
184 		unsigned int BlockHeight256Bytes,
185 		unsigned int BlockWidth256Bytes,
186 		enum source_format_class SourcePixelFormat,
187 		unsigned int SurfaceTiling,
188 		unsigned int BytePerPixel,
189 		enum scan_direction_class ScanDirection,
190 		unsigned int SwathWidth,
191 		unsigned int ViewportHeight,
192 		bool GPUVMEnable,
193 		bool HostVMEnable,
194 		unsigned int HostVMMaxNonCachedPageTableLevels,
195 		unsigned int GPUVMMinPageSize,
196 		unsigned int HostVMMinPageSize,
197 		unsigned int PTEBufferSizeInRequests,
198 		unsigned int Pitch,
199 		unsigned int DCCMetaPitch,
200 		unsigned int *MacroTileWidth,
201 		unsigned int *MetaRowByte,
202 		unsigned int *PixelPTEBytesPerRow,
203 		bool *PTEBufferSizeNotExceeded,
204 		unsigned int *dpte_row_width_ub,
205 		unsigned int *dpte_row_height,
206 		unsigned int *MetaRequestWidth,
207 		unsigned int *MetaRequestHeight,
208 		unsigned int *meta_row_width,
209 		unsigned int *meta_row_height,
210 		unsigned int *vm_group_bytes,
211 		unsigned int *dpte_group_bytes,
212 		unsigned int *PixelPTEReqWidth,
213 		unsigned int *PixelPTEReqHeight,
214 		unsigned int *PTERequestSize,
215 		unsigned int *DPDE0BytesFrame,
216 		unsigned int *MetaPTEBytesFrame);
217 static double CalculateTWait(
218 		unsigned int PrefetchMode,
219 		double DRAMClockChangeLatency,
220 		double UrgentLatency,
221 		double SREnterPlusExitTime);
222 static void CalculateRowBandwidth(
223 		bool GPUVMEnable,
224 		enum source_format_class SourcePixelFormat,
225 		double VRatio,
226 		double VRatioChroma,
227 		bool DCCEnable,
228 		double LineTime,
229 		unsigned int MetaRowByteLuma,
230 		unsigned int MetaRowByteChroma,
231 		unsigned int meta_row_height_luma,
232 		unsigned int meta_row_height_chroma,
233 		unsigned int PixelPTEBytesPerRowLuma,
234 		unsigned int PixelPTEBytesPerRowChroma,
235 		unsigned int dpte_row_height_luma,
236 		unsigned int dpte_row_height_chroma,
237 		double *meta_row_bw,
238 		double *dpte_row_bw);
239 static void CalculateFlipSchedule(
240 		struct display_mode_lib *mode_lib,
241 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
242 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
243 		double UrgentExtraLatency,
244 		double UrgentLatency,
245 		unsigned int GPUVMMaxPageTableLevels,
246 		bool HostVMEnable,
247 		unsigned int HostVMMaxNonCachedPageTableLevels,
248 		bool GPUVMEnable,
249 		double HostVMMinPageSize,
250 		double PDEAndMetaPTEBytesPerFrame,
251 		double MetaRowBytes,
252 		double DPTEBytesPerRow,
253 		double BandwidthAvailableForImmediateFlip,
254 		unsigned int TotImmediateFlipBytes,
255 		enum source_format_class SourcePixelFormat,
256 		double LineTime,
257 		double VRatio,
258 		double VRatioChroma,
259 		double Tno_bw,
260 		bool DCCEnable,
261 		unsigned int dpte_row_height,
262 		unsigned int meta_row_height,
263 		unsigned int dpte_row_height_chroma,
264 		unsigned int meta_row_height_chroma,
265 		double *DestinationLinesToRequestVMInImmediateFlip,
266 		double *DestinationLinesToRequestRowInImmediateFlip,
267 		double *final_flip_bw,
268 		bool *ImmediateFlipSupportedForPipe);
269 static double CalculateWriteBackDelay(
270 		enum source_format_class WritebackPixelFormat,
271 		double WritebackHRatio,
272 		double WritebackVRatio,
273 		unsigned int WritebackVTaps,
274 		long WritebackDestinationWidth,
275 		long WritebackDestinationHeight,
276 		long WritebackSourceHeight,
277 		unsigned int HTotal);
278 static void CalculateDynamicMetadataParameters(
279 		int MaxInterDCNTileRepeaters,
280 		double DPPCLK,
281 		double DISPCLK,
282 		double DCFClkDeepSleep,
283 		double PixelClock,
284 		long HTotal,
285 		long VBlank,
286 		long DynamicMetadataTransmittedBytes,
287 		long DynamicMetadataLinesBeforeActiveRequired,
288 		int InterlaceEnable,
289 		bool ProgressiveToInterlaceUnitInOPP,
290 		double *Tsetup,
291 		double *Tdmbf,
292 		double *Tdmec,
293 		double *Tdmsks);
294 static void CalculateWatermarksAndDRAMSpeedChangeSupport(
295 		struct display_mode_lib *mode_lib,
296 		unsigned int PrefetchMode,
297 		unsigned int NumberOfActivePlanes,
298 		unsigned int MaxLineBufferLines,
299 		unsigned int LineBufferSize,
300 		unsigned int DPPOutputBufferPixels,
301 		unsigned int DETBufferSizeInKByte,
302 		unsigned int WritebackInterfaceBufferSize,
303 		double DCFCLK,
304 		double ReturnBW,
305 		bool GPUVMEnable,
306 		unsigned int dpte_group_bytes[],
307 		unsigned int MetaChunkSize,
308 		double UrgentLatency,
309 		double ExtraLatency,
310 		double WritebackLatency,
311 		double WritebackChunkSize,
312 		double SOCCLK,
313 		double DRAMClockChangeLatency,
314 		double SRExitTime,
315 		double SREnterPlusExitTime,
316 		double DCFCLKDeepSleep,
317 		unsigned int DPPPerPlane[],
318 		bool DCCEnable[],
319 		double DPPCLK[],
320 		unsigned int DETBufferSizeY[],
321 		unsigned int DETBufferSizeC[],
322 		unsigned int SwathHeightY[],
323 		unsigned int SwathHeightC[],
324 		unsigned int LBBitPerPixel[],
325 		double SwathWidthY[],
326 		double SwathWidthC[],
327 		double HRatio[],
328 		double HRatioChroma[],
329 		unsigned int vtaps[],
330 		unsigned int VTAPsChroma[],
331 		double VRatio[],
332 		double VRatioChroma[],
333 		unsigned int HTotal[],
334 		double PixelClock[],
335 		unsigned int BlendingAndTiming[],
336 		double BytePerPixelDETY[],
337 		double BytePerPixelDETC[],
338 		double DSTXAfterScaler[],
339 		double DSTYAfterScaler[],
340 		bool WritebackEnable[],
341 		enum source_format_class WritebackPixelFormat[],
342 		double WritebackDestinationWidth[],
343 		double WritebackDestinationHeight[],
344 		double WritebackSourceHeight[],
345 		enum clock_change_support *DRAMClockChangeSupport,
346 		double *UrgentWatermark,
347 		double *WritebackUrgentWatermark,
348 		double *DRAMClockChangeWatermark,
349 		double *WritebackDRAMClockChangeWatermark,
350 		double *StutterExitWatermark,
351 		double *StutterEnterPlusExitWatermark,
352 		double *MinActiveDRAMClockChangeLatencySupported);
353 static void CalculateDCFCLKDeepSleep(
354 		struct display_mode_lib *mode_lib,
355 		unsigned int NumberOfActivePlanes,
356 		int BytePerPixelY[],
357 		int BytePerPixelC[],
358 		double VRatio[],
359 		double VRatioChroma[],
360 		double SwathWidthY[],
361 		double SwathWidthC[],
362 		unsigned int DPPPerPlane[],
363 		double HRatio[],
364 		double HRatioChroma[],
365 		double PixelClock[],
366 		double PSCL_THROUGHPUT[],
367 		double PSCL_THROUGHPUT_CHROMA[],
368 		double DPPCLK[],
369 		double ReadBandwidthLuma[],
370 		double ReadBandwidthChroma[],
371 		int ReturnBusWidth,
372 		double *DCFCLKDeepSleep);
373 static void CalculateUrgentBurstFactor(
374 		long swath_width_luma_ub,
375 		long swath_width_chroma_ub,
376 		unsigned int DETBufferSizeInKByte,
377 		unsigned int SwathHeightY,
378 		unsigned int SwathHeightC,
379 		double LineTime,
380 		double UrgentLatency,
381 		double CursorBufferSize,
382 		unsigned int CursorWidth,
383 		unsigned int CursorBPP,
384 		double VRatio,
385 		double VRatioC,
386 		double BytePerPixelInDETY,
387 		double BytePerPixelInDETC,
388 		double DETBufferSizeY,
389 		double DETBufferSizeC,
390 		double *UrgentBurstFactorCursor,
391 		double *UrgentBurstFactorLuma,
392 		double *UrgentBurstFactorChroma,
393 		bool *NotEnoughUrgentLatencyHiding);
394 
395 static void UseMinimumDCFCLK(
396 		struct display_mode_lib *mode_lib,
397 		struct vba_vars_st *v,
398 		int MaxPrefetchMode,
399 		int ReorderingBytes);
400 
401 static void CalculatePixelDeliveryTimes(
402 		unsigned int NumberOfActivePlanes,
403 		double VRatio[],
404 		double VRatioChroma[],
405 		double VRatioPrefetchY[],
406 		double VRatioPrefetchC[],
407 		unsigned int swath_width_luma_ub[],
408 		unsigned int swath_width_chroma_ub[],
409 		unsigned int DPPPerPlane[],
410 		double HRatio[],
411 		double HRatioChroma[],
412 		double PixelClock[],
413 		double PSCL_THROUGHPUT[],
414 		double PSCL_THROUGHPUT_CHROMA[],
415 		double DPPCLK[],
416 		int BytePerPixelC[],
417 		enum scan_direction_class SourceScan[],
418 		unsigned int NumberOfCursors[],
419 		unsigned int CursorWidth[][2],
420 		unsigned int CursorBPP[][2],
421 		unsigned int BlockWidth256BytesY[],
422 		unsigned int BlockHeight256BytesY[],
423 		unsigned int BlockWidth256BytesC[],
424 		unsigned int BlockHeight256BytesC[],
425 		double DisplayPipeLineDeliveryTimeLuma[],
426 		double DisplayPipeLineDeliveryTimeChroma[],
427 		double DisplayPipeLineDeliveryTimeLumaPrefetch[],
428 		double DisplayPipeLineDeliveryTimeChromaPrefetch[],
429 		double DisplayPipeRequestDeliveryTimeLuma[],
430 		double DisplayPipeRequestDeliveryTimeChroma[],
431 		double DisplayPipeRequestDeliveryTimeLumaPrefetch[],
432 		double DisplayPipeRequestDeliveryTimeChromaPrefetch[],
433 		double CursorRequestDeliveryTime[],
434 		double CursorRequestDeliveryTimePrefetch[]);
435 
436 static void CalculateMetaAndPTETimes(
437 		int NumberOfActivePlanes,
438 		bool GPUVMEnable,
439 		int MetaChunkSize,
440 		int MinMetaChunkSizeBytes,
441 		int HTotal[],
442 		double VRatio[],
443 		double VRatioChroma[],
444 		double DestinationLinesToRequestRowInVBlank[],
445 		double DestinationLinesToRequestRowInImmediateFlip[],
446 		bool DCCEnable[],
447 		double PixelClock[],
448 		int BytePerPixelY[],
449 		int BytePerPixelC[],
450 		enum scan_direction_class SourceScan[],
451 		int dpte_row_height[],
452 		int dpte_row_height_chroma[],
453 		int meta_row_width[],
454 		int meta_row_width_chroma[],
455 		int meta_row_height[],
456 		int meta_row_height_chroma[],
457 		int meta_req_width[],
458 		int meta_req_width_chroma[],
459 		int meta_req_height[],
460 		int meta_req_height_chroma[],
461 		int dpte_group_bytes[],
462 		int PTERequestSizeY[],
463 		int PTERequestSizeC[],
464 		int PixelPTEReqWidthY[],
465 		int PixelPTEReqHeightY[],
466 		int PixelPTEReqWidthC[],
467 		int PixelPTEReqHeightC[],
468 		int dpte_row_width_luma_ub[],
469 		int dpte_row_width_chroma_ub[],
470 		double DST_Y_PER_PTE_ROW_NOM_L[],
471 		double DST_Y_PER_PTE_ROW_NOM_C[],
472 		double DST_Y_PER_META_ROW_NOM_L[],
473 		double DST_Y_PER_META_ROW_NOM_C[],
474 		double TimePerMetaChunkNominal[],
475 		double TimePerChromaMetaChunkNominal[],
476 		double TimePerMetaChunkVBlank[],
477 		double TimePerChromaMetaChunkVBlank[],
478 		double TimePerMetaChunkFlip[],
479 		double TimePerChromaMetaChunkFlip[],
480 		double time_per_pte_group_nom_luma[],
481 		double time_per_pte_group_vblank_luma[],
482 		double time_per_pte_group_flip_luma[],
483 		double time_per_pte_group_nom_chroma[],
484 		double time_per_pte_group_vblank_chroma[],
485 		double time_per_pte_group_flip_chroma[]);
486 
487 static void CalculateVMGroupAndRequestTimes(
488 		unsigned int NumberOfActivePlanes,
489 		bool GPUVMEnable,
490 		unsigned int GPUVMMaxPageTableLevels,
491 		unsigned int HTotal[],
492 		int BytePerPixelC[],
493 		double DestinationLinesToRequestVMInVBlank[],
494 		double DestinationLinesToRequestVMInImmediateFlip[],
495 		bool DCCEnable[],
496 		double PixelClock[],
497 		int dpte_row_width_luma_ub[],
498 		int dpte_row_width_chroma_ub[],
499 		int vm_group_bytes[],
500 		unsigned int dpde0_bytes_per_frame_ub_l[],
501 		unsigned int dpde0_bytes_per_frame_ub_c[],
502 		int meta_pte_bytes_per_frame_ub_l[],
503 		int meta_pte_bytes_per_frame_ub_c[],
504 		double TimePerVMGroupVBlank[],
505 		double TimePerVMGroupFlip[],
506 		double TimePerVMRequestVBlank[],
507 		double TimePerVMRequestFlip[]);
508 
509 static void CalculateStutterEfficiency(
510 		int NumberOfActivePlanes,
511 		long ROBBufferSizeInKByte,
512 		double TotalDataReadBandwidth,
513 		double DCFCLK,
514 		double ReturnBW,
515 		double SRExitTime,
516 		bool SynchronizedVBlank,
517 		int DPPPerPlane[],
518 		unsigned int DETBufferSizeY[],
519 		int BytePerPixelY[],
520 		double BytePerPixelDETY[],
521 		double SwathWidthY[],
522 		int SwathHeightY[],
523 		int SwathHeightC[],
524 		double DCCRateLuma[],
525 		double DCCRateChroma[],
526 		int HTotal[],
527 		int VTotal[],
528 		double PixelClock[],
529 		double VRatio[],
530 		enum scan_direction_class SourceScan[],
531 		int BlockHeight256BytesY[],
532 		int BlockWidth256BytesY[],
533 		int BlockHeight256BytesC[],
534 		int BlockWidth256BytesC[],
535 		int DCCYMaxUncompressedBlock[],
536 		int DCCCMaxUncompressedBlock[],
537 		int VActive[],
538 		bool DCCEnable[],
539 		bool WritebackEnable[],
540 		double ReadBandwidthPlaneLuma[],
541 		double ReadBandwidthPlaneChroma[],
542 		double meta_row_bw[],
543 		double dpte_row_bw[],
544 		double *StutterEfficiencyNotIncludingVBlank,
545 		double *StutterEfficiency,
546 		double *StutterPeriodOut);
547 
548 static void CalculateSwathAndDETConfiguration(
549 		bool ForceSingleDPP,
550 		int NumberOfActivePlanes,
551 		unsigned int DETBufferSizeInKByte,
552 		double MaximumSwathWidthLuma[],
553 		double MaximumSwathWidthChroma[],
554 		enum scan_direction_class SourceScan[],
555 		enum source_format_class SourcePixelFormat[],
556 		enum dm_swizzle_mode SurfaceTiling[],
557 		int ViewportWidth[],
558 		int ViewportHeight[],
559 		int SurfaceWidthY[],
560 		int SurfaceWidthC[],
561 		int SurfaceHeightY[],
562 		int SurfaceHeightC[],
563 		int Read256BytesBlockHeightY[],
564 		int Read256BytesBlockHeightC[],
565 		int Read256BytesBlockWidthY[],
566 		int Read256BytesBlockWidthC[],
567 		enum odm_combine_mode ODMCombineEnabled[],
568 		int BlendingAndTiming[],
569 		int BytePerPixY[],
570 		int BytePerPixC[],
571 		double BytePerPixDETY[],
572 		double BytePerPixDETC[],
573 		int HActive[],
574 		double HRatio[],
575 		double HRatioChroma[],
576 		int DPPPerPlane[],
577 		int swath_width_luma_ub[],
578 		int swath_width_chroma_ub[],
579 		double SwathWidth[],
580 		double SwathWidthChroma[],
581 		int SwathHeightY[],
582 		int SwathHeightC[],
583 		unsigned int DETBufferSizeY[],
584 		unsigned int DETBufferSizeC[],
585 		bool ViewportSizeSupportPerPlane[],
586 		bool *ViewportSizeSupport);
587 static void CalculateSwathWidth(
588 		bool ForceSingleDPP,
589 		int NumberOfActivePlanes,
590 		enum source_format_class SourcePixelFormat[],
591 		enum scan_direction_class SourceScan[],
592 		unsigned int ViewportWidth[],
593 		unsigned int ViewportHeight[],
594 		unsigned int SurfaceWidthY[],
595 		unsigned int SurfaceWidthC[],
596 		unsigned int SurfaceHeightY[],
597 		unsigned int SurfaceHeightC[],
598 		enum odm_combine_mode ODMCombineEnabled[],
599 		int BytePerPixY[],
600 		int BytePerPixC[],
601 		int Read256BytesBlockHeightY[],
602 		int Read256BytesBlockHeightC[],
603 		int Read256BytesBlockWidthY[],
604 		int Read256BytesBlockWidthC[],
605 		int BlendingAndTiming[],
606 		unsigned int HActive[],
607 		double HRatio[],
608 		int DPPPerPlane[],
609 		double SwathWidthSingleDPPY[],
610 		double SwathWidthSingleDPPC[],
611 		double SwathWidthY[],
612 		double SwathWidthC[],
613 		int MaximumSwathHeightY[],
614 		int MaximumSwathHeightC[],
615 		unsigned int swath_width_luma_ub[],
616 		unsigned int swath_width_chroma_ub[]);
617 static double CalculateExtraLatency(
618 		long RoundTripPingLatencyCycles,
619 		long ReorderingBytes,
620 		double DCFCLK,
621 		int TotalNumberOfActiveDPP,
622 		int PixelChunkSizeInKByte,
623 		int TotalNumberOfDCCActiveDPP,
624 		int MetaChunkSize,
625 		double ReturnBW,
626 		bool GPUVMEnable,
627 		bool HostVMEnable,
628 		int NumberOfActivePlanes,
629 		int NumberOfDPP[],
630 		int dpte_group_bytes[],
631 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
632 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
633 		double HostVMMinPageSize,
634 		int HostVMMaxNonCachedPageTableLevels);
635 static double CalculateExtraLatencyBytes(
636 		long ReorderingBytes,
637 		int TotalNumberOfActiveDPP,
638 		int PixelChunkSizeInKByte,
639 		int TotalNumberOfDCCActiveDPP,
640 		int MetaChunkSize,
641 		bool GPUVMEnable,
642 		bool HostVMEnable,
643 		int NumberOfActivePlanes,
644 		int NumberOfDPP[],
645 		int dpte_group_bytes[],
646 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
647 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
648 		double HostVMMinPageSize,
649 		int HostVMMaxNonCachedPageTableLevels);
650 static double CalculateUrgentLatency(
651 		double UrgentLatencyPixelDataOnly,
652 		double UrgentLatencyPixelMixedWithVMData,
653 		double UrgentLatencyVMDataOnly,
654 		bool DoUrgentLatencyAdjustment,
655 		double UrgentLatencyAdjustmentFabricClockComponent,
656 		double UrgentLatencyAdjustmentFabricClockReference,
657 		double FabricClockSingle);
658 
dml30_recalculate(struct display_mode_lib * mode_lib)659 void dml30_recalculate(struct display_mode_lib *mode_lib)
660 {
661 	ModeSupportAndSystemConfiguration(mode_lib);
662 	PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
663 	DisplayPipeConfiguration(mode_lib);
664 	DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
665 }
666 
dscceComputeDelay(unsigned int bpc,double BPP,unsigned int sliceWidth,unsigned int numSlices,enum output_format_class pixelFormat,enum output_encoder_class Output)667 static unsigned int dscceComputeDelay(
668 		unsigned int bpc,
669 		double BPP,
670 		unsigned int sliceWidth,
671 		unsigned int numSlices,
672 		enum output_format_class pixelFormat,
673 		enum output_encoder_class Output)
674 {
675 	// valid bpc         = source bits per component in the set of {8, 10, 12}
676 	// valid bpp         = increments of 1/16 of a bit
677 	//                    min = 6/7/8 in N420/N422/444, respectively
678 	//                    max = such that compression is 1:1
679 	//valid sliceWidth  = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
680 	//valid numSlices   = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
681 	//valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
682 
683 	// fixed value
684 	unsigned int rcModelSize = 8192;
685 
686 	// N422/N420 operate at 2 pixels per clock
687 	unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, P, l0, a, ax, L,
688 			Delay, pixels;
689 
690 	if (pixelFormat == dm_420)
691 		pixelsPerClock = 2;
692 	// #all other modes operate at 1 pixel per clock
693 	else if (pixelFormat == dm_444)
694 		pixelsPerClock = 1;
695 	else if (pixelFormat == dm_n422)
696 		pixelsPerClock = 2;
697 	else
698 		pixelsPerClock = 1;
699 
700 	//initial transmit delay as per PPS
701 	initalXmitDelay = dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock);
702 
703 	//compute ssm delay
704 	if (bpc == 8)
705 		D = 81;
706 	else if (bpc == 10)
707 		D = 89;
708 	else
709 		D = 113;
710 
711 	//divide by pixel per cycle to compute slice width as seen by DSC
712 	w = sliceWidth / pixelsPerClock;
713 
714 	//422 mode has an additional cycle of delay
715 	if (pixelFormat == dm_420 || pixelFormat == dm_444 || pixelFormat == dm_n422)
716 		s = 0;
717 	else
718 		s = 1;
719 
720 	//main calculation for the dscce
721 	ix = initalXmitDelay + 45;
722 	wx = (w + 2) / 3;
723 	P = 3 * wx - w;
724 	l0 = ix / w;
725 	a = ix + P * l0;
726 	ax = (a + 2) / 3 + D + 6 + 1;
727 	L = (ax + wx - 1) / wx;
728 	if ((ix % w) == 0 && P != 0)
729 		lstall = 1;
730 	else
731 		lstall = 0;
732 	Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22;
733 
734 	//dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
735 	pixels = Delay * 3 * pixelsPerClock;
736 	return pixels;
737 }
738 
dscComputeDelay(enum output_format_class pixelFormat,enum output_encoder_class Output)739 static unsigned int dscComputeDelay(enum output_format_class pixelFormat, enum output_encoder_class Output)
740 {
741 	unsigned int Delay = 0;
742 
743 	if (pixelFormat == dm_420) {
744 		//   sfr
745 		Delay = Delay + 2;
746 		//   dsccif
747 		Delay = Delay + 0;
748 		//   dscc - input deserializer
749 		Delay = Delay + 3;
750 		//   dscc gets pixels every other cycle
751 		Delay = Delay + 2;
752 		//   dscc - input cdc fifo
753 		Delay = Delay + 12;
754 		//   dscc gets pixels every other cycle
755 		Delay = Delay + 13;
756 		//   dscc - cdc uncertainty
757 		Delay = Delay + 2;
758 		//   dscc - output cdc fifo
759 		Delay = Delay + 7;
760 		//   dscc gets pixels every other cycle
761 		Delay = Delay + 3;
762 		//   dscc - cdc uncertainty
763 		Delay = Delay + 2;
764 		//   dscc - output serializer
765 		Delay = Delay + 1;
766 		//   sft
767 		Delay = Delay + 1;
768 	} else if (pixelFormat == dm_n422) {
769 		//   sfr
770 		Delay = Delay + 2;
771 		//   dsccif
772 		Delay = Delay + 1;
773 		//   dscc - input deserializer
774 		Delay = Delay + 5;
775 		//  dscc - input cdc fifo
776 		Delay = Delay + 25;
777 		//   dscc - cdc uncertainty
778 		Delay = Delay + 2;
779 		//   dscc - output cdc fifo
780 		Delay = Delay + 10;
781 		//   dscc - cdc uncertainty
782 		Delay = Delay + 2;
783 		//   dscc - output serializer
784 		Delay = Delay + 1;
785 		//   sft
786 		Delay = Delay + 1;
787 	} else {
788 		//   sfr
789 		Delay = Delay + 2;
790 		//   dsccif
791 		Delay = Delay + 0;
792 		//   dscc - input deserializer
793 		Delay = Delay + 3;
794 		//   dscc - input cdc fifo
795 		Delay = Delay + 12;
796 		//   dscc - cdc uncertainty
797 		Delay = Delay + 2;
798 		//   dscc - output cdc fifo
799 		Delay = Delay + 7;
800 		//   dscc - output serializer
801 		Delay = Delay + 1;
802 		//   dscc - cdc uncertainty
803 		Delay = Delay + 2;
804 		//   sft
805 		Delay = Delay + 1;
806 	}
807 
808 	return Delay;
809 }
810 
CalculatePrefetchSchedule(struct display_mode_lib * mode_lib,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,Pipe * myPipe,unsigned int DSCDelay,double DPPCLKDelaySubtotalPlusCNVCFormater,double DPPCLKDelaySCL,double DPPCLKDelaySCLLBOnly,double DPPCLKDelayCNVCCursor,double DISPCLKDelaySubtotal,unsigned int DPP_RECOUT_WIDTH,enum output_format_class OutputFormat,unsigned int MaxInterDCNTileRepeaters,unsigned int VStartup,unsigned int MaxVStartup,unsigned int GPUVMPageTableLevels,bool GPUVMEnable,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,double HostVMMinPageSize,bool DynamicMetadataEnable,bool DynamicMetadataVMEnabled,int DynamicMetadataLinesBeforeActiveRequired,unsigned int DynamicMetadataTransmittedBytes,double UrgentLatency,double UrgentExtraLatency,double TCalc,unsigned int PDEAndMetaPTEBytesFrame,unsigned int MetaRowByte,unsigned int PixelPTEBytesPerRow,double PrefetchSourceLinesY,unsigned int SwathWidthY,int BytePerPixelY,double VInitPreFillY,unsigned int MaxNumSwathY,double PrefetchSourceLinesC,unsigned int SwathWidthC,int BytePerPixelC,double VInitPreFillC,unsigned int MaxNumSwathC,long swath_width_luma_ub,long swath_width_chroma_ub,unsigned int SwathHeightY,unsigned int SwathHeightC,double TWait,bool ProgressiveToInterlaceUnitInOPP,double * DSTXAfterScaler,double * DSTYAfterScaler,double * DestinationLinesForPrefetch,double * PrefetchBandwidth,double * DestinationLinesToRequestVMInVBlank,double * DestinationLinesToRequestRowInVBlank,double * VRatioPrefetchY,double * VRatioPrefetchC,double * RequiredPrefetchPixDataBWLuma,double * RequiredPrefetchPixDataBWChroma,bool * NotEnoughTimeForDynamicMetadata,double * Tno_bw,double * prefetch_vmrow_bw,double * Tdmdl_vm,double * Tdmdl,unsigned int * VUpdateOffsetPix,double * VUpdateWidthPix,double * VReadyOffsetPix)811 static bool CalculatePrefetchSchedule(
812 		struct display_mode_lib *mode_lib,
813 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
814 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
815 		Pipe *myPipe,
816 		unsigned int DSCDelay,
817 		double DPPCLKDelaySubtotalPlusCNVCFormater,
818 		double DPPCLKDelaySCL,
819 		double DPPCLKDelaySCLLBOnly,
820 		double DPPCLKDelayCNVCCursor,
821 		double DISPCLKDelaySubtotal,
822 		unsigned int DPP_RECOUT_WIDTH,
823 		enum output_format_class OutputFormat,
824 		unsigned int MaxInterDCNTileRepeaters,
825 		unsigned int VStartup,
826 		unsigned int MaxVStartup,
827 		unsigned int GPUVMPageTableLevels,
828 		bool GPUVMEnable,
829 		bool HostVMEnable,
830 		unsigned int HostVMMaxNonCachedPageTableLevels,
831 		double HostVMMinPageSize,
832 		bool DynamicMetadataEnable,
833 		bool DynamicMetadataVMEnabled,
834 		int DynamicMetadataLinesBeforeActiveRequired,
835 		unsigned int DynamicMetadataTransmittedBytes,
836 		double UrgentLatency,
837 		double UrgentExtraLatency,
838 		double TCalc,
839 		unsigned int PDEAndMetaPTEBytesFrame,
840 		unsigned int MetaRowByte,
841 		unsigned int PixelPTEBytesPerRow,
842 		double PrefetchSourceLinesY,
843 		unsigned int SwathWidthY,
844 		int BytePerPixelY,
845 		double VInitPreFillY,
846 		unsigned int MaxNumSwathY,
847 		double PrefetchSourceLinesC,
848 		unsigned int SwathWidthC,
849 		int BytePerPixelC,
850 		double VInitPreFillC,
851 		unsigned int MaxNumSwathC,
852 		long swath_width_luma_ub,
853 		long swath_width_chroma_ub,
854 		unsigned int SwathHeightY,
855 		unsigned int SwathHeightC,
856 		double TWait,
857 		bool ProgressiveToInterlaceUnitInOPP,
858 		double *DSTXAfterScaler,
859 		double *DSTYAfterScaler,
860 		double *DestinationLinesForPrefetch,
861 		double *PrefetchBandwidth,
862 		double *DestinationLinesToRequestVMInVBlank,
863 		double *DestinationLinesToRequestRowInVBlank,
864 		double *VRatioPrefetchY,
865 		double *VRatioPrefetchC,
866 		double *RequiredPrefetchPixDataBWLuma,
867 		double *RequiredPrefetchPixDataBWChroma,
868 		bool *NotEnoughTimeForDynamicMetadata,
869 		double *Tno_bw,
870 		double *prefetch_vmrow_bw,
871 		double *Tdmdl_vm,
872 		double *Tdmdl,
873 		unsigned int *VUpdateOffsetPix,
874 		double *VUpdateWidthPix,
875 		double *VReadyOffsetPix)
876 {
877 	bool MyError = false;
878 	unsigned int DPPCycles = 0, DISPCLKCycles = 0;
879 	double DSTTotalPixelsAfterScaler = 0;
880 	double LineTime = 0, Tsetup = 0;
881 	double dst_y_prefetch_equ = 0;
882 	double Tsw_oto = 0;
883 	double prefetch_bw_oto = 0;
884 	double Tvm_oto = 0;
885 	double Tr0_oto = 0;
886 	double Tvm_oto_lines = 0;
887 	double Tr0_oto_lines = 0;
888 	double dst_y_prefetch_oto = 0;
889 	double TimeForFetchingMetaPTE = 0;
890 	double TimeForFetchingRowInVBlank = 0;
891 	double LinesToRequestPrefetchPixelData = 0;
892 	double HostVMInefficiencyFactor = 0;
893 	unsigned int HostVMDynamicLevelsTrips = 0;
894 	double trip_to_mem = 0;
895 	double Tvm_trips = 0;
896 	double Tr0_trips = 0;
897 	double Tvm_trips_rounded = 0;
898 	double Tr0_trips_rounded = 0;
899 	double Lsw_oto = 0;
900 	double Tpre_rounded = 0;
901 	double prefetch_bw_equ = 0;
902 	double Tvm_equ = 0;
903 	double Tr0_equ = 0;
904 	double Tdmbf = 0;
905 	double Tdmec = 0;
906 	double Tdmsks = 0;
907 
908 	if (GPUVMEnable == true && HostVMEnable == true) {
909 		HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
910 		HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
911 	} else {
912 		HostVMInefficiencyFactor = 1;
913 		HostVMDynamicLevelsTrips = 0;
914 	}
915 
916 	CalculateDynamicMetadataParameters(
917 			MaxInterDCNTileRepeaters,
918 			myPipe->DPPCLK,
919 			myPipe->DISPCLK,
920 			myPipe->DCFCLKDeepSleep,
921 			myPipe->PixelClock,
922 			myPipe->HTotal,
923 			myPipe->VBlank,
924 			DynamicMetadataTransmittedBytes,
925 			DynamicMetadataLinesBeforeActiveRequired,
926 			myPipe->InterlaceEnable,
927 			ProgressiveToInterlaceUnitInOPP,
928 			&Tsetup,
929 			&Tdmbf,
930 			&Tdmec,
931 			&Tdmsks);
932 
933 	LineTime = myPipe->HTotal / myPipe->PixelClock;
934 	trip_to_mem = UrgentLatency;
935 	Tvm_trips = UrgentExtraLatency + trip_to_mem * (GPUVMPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1);
936 
937 	if (DynamicMetadataVMEnabled == true && GPUVMEnable == true) {
938 		*Tdmdl = TWait + Tvm_trips + trip_to_mem;
939 	} else {
940 		*Tdmdl = TWait + UrgentExtraLatency;
941 	}
942 
943 	if (DynamicMetadataEnable == true) {
944 		if (VStartup * LineTime < Tsetup + *Tdmdl + Tdmbf + Tdmec + Tdmsks) {
945 			*NotEnoughTimeForDynamicMetadata = true;
946 		} else {
947 			*NotEnoughTimeForDynamicMetadata = false;
948 			dml_print("DML: Not Enough Time for Dynamic Meta!\n");
949 			dml_print("DML: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", Tdmbf);
950 			dml_print("DML: Tdmec: %fus - time dio takes to transfer dmd\n", Tdmec);
951 			dml_print("DML: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", Tdmsks);
952 			dml_print("DML: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", *Tdmdl);
953 		}
954 	} else {
955 		*NotEnoughTimeForDynamicMetadata = false;
956 	}
957 
958 	*Tdmdl_vm = (DynamicMetadataEnable == true && DynamicMetadataVMEnabled == true && GPUVMEnable == true ? TWait + Tvm_trips : 0);
959 
960 	if (myPipe->ScalerEnabled)
961 		DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCL;
962 	else
963 		DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCLLBOnly;
964 
965 	DPPCycles = DPPCycles + myPipe->NumberOfCursors * DPPCLKDelayCNVCCursor;
966 
967 	DISPCLKCycles = DISPCLKDelaySubtotal;
968 
969 	if (myPipe->DPPCLK == 0.0 || myPipe->DISPCLK == 0.0)
970 		return true;
971 
972 	*DSTXAfterScaler = DPPCycles * myPipe->PixelClock / myPipe->DPPCLK + DISPCLKCycles * myPipe->PixelClock / myPipe->DISPCLK
973 			+ DSCDelay;
974 
975 	*DSTXAfterScaler = *DSTXAfterScaler + ((myPipe->ODMCombineEnabled)?18:0) + (myPipe->DPPPerPlane - 1) * DPP_RECOUT_WIDTH;
976 
977 	if (OutputFormat == dm_420 || (myPipe->InterlaceEnable && ProgressiveToInterlaceUnitInOPP))
978 		*DSTYAfterScaler = 1;
979 	else
980 		*DSTYAfterScaler = 0;
981 
982 	DSTTotalPixelsAfterScaler = *DSTYAfterScaler * myPipe->HTotal + *DSTXAfterScaler;
983 	*DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / myPipe->HTotal, 1);
984 	*DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * myPipe->HTotal));
985 
986 	MyError = false;
987 
988 
989 	Tr0_trips = trip_to_mem * (HostVMDynamicLevelsTrips + 1);
990 	Tvm_trips_rounded = dml_ceil(4.0 * Tvm_trips / LineTime, 1) / 4 * LineTime;
991 	Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1) / 4 * LineTime;
992 
993 	if (GPUVMEnable) {
994 		if (GPUVMPageTableLevels >= 3) {
995 			*Tno_bw = UrgentExtraLatency + trip_to_mem * ((GPUVMPageTableLevels - 2) - 1);
996 		} else
997 			*Tno_bw = 0;
998 	} else if (!myPipe->DCCEnable)
999 		*Tno_bw = LineTime;
1000 	else
1001 		*Tno_bw = LineTime / 4;
1002 
1003 	dst_y_prefetch_equ = VStartup - (Tsetup + dml_max(TWait + TCalc, *Tdmdl)) / LineTime
1004 			- (*DSTYAfterScaler + *DSTXAfterScaler / myPipe->HTotal);
1005 
1006 	Lsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC);
1007 	Tsw_oto = Lsw_oto * LineTime;
1008 
1009 	prefetch_bw_oto = (PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC) / Tsw_oto;
1010 
1011 	if (GPUVMEnable == true) {
1012 		Tvm_oto = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_oto,
1013 				Tvm_trips,
1014 				LineTime / 4.0);
1015 	} else
1016 		Tvm_oto = LineTime / 4.0;
1017 
1018 	if ((GPUVMEnable == true || myPipe->DCCEnable == true)) {
1019 		Tr0_oto = dml_max3(
1020 				(MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto,
1021 				LineTime - Tvm_oto, LineTime / 4);
1022 	} else
1023 		Tr0_oto = (LineTime - Tvm_oto) / 2.0;
1024 
1025 	Tvm_oto_lines = dml_ceil(4.0 * Tvm_oto / LineTime, 1) / 4.0;
1026 	Tr0_oto_lines = dml_ceil(4.0 * Tr0_oto / LineTime, 1) / 4.0;
1027 	dst_y_prefetch_oto = Tvm_oto_lines + 2 * Tr0_oto_lines + Lsw_oto;
1028 
1029 	dst_y_prefetch_equ = dml_floor(4.0 * (dst_y_prefetch_equ + 0.125), 1) / 4.0;
1030 	Tpre_rounded = dst_y_prefetch_equ * LineTime;
1031 
1032 	dml_print("DML: dst_y_prefetch_oto: %f\n", dst_y_prefetch_oto);
1033 	dml_print("DML: dst_y_prefetch_equ: %f\n", dst_y_prefetch_equ);
1034 
1035 	dml_print("DML: LineTime: %f\n", LineTime);
1036 	dml_print("DML: VStartup: %d\n", VStartup);
1037 	dml_print("DML: Tvstartup: %fus - time between vstartup and first pixel of active\n", VStartup * LineTime);
1038 	dml_print("DML: Tsetup: %fus - time from vstartup to vready\n", Tsetup);
1039 	dml_print("DML: TCalc: %fus - time for calculations in dchub starting at vready\n", TCalc);
1040 	dml_print("DML: TWait: %fus - time for fabric to become ready max(pstate exit,cstate enter/exit, urgent latency) after TCalc\n", TWait);
1041 	dml_print("DML: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", Tdmbf);
1042 	dml_print("DML: Tdmec: %fus - time dio takes to transfer dmd\n", Tdmec);
1043 	dml_print("DML: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", Tdmsks);
1044 	dml_print("DML: Tdmdl_vm: %fus - time for vm stages of dmd \n", *Tdmdl_vm);
1045 	dml_print("DML: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", *Tdmdl);
1046 	dml_print("DML: dst_x_after_scl: %f pixels - number of pixel clocks pipeline and buffer delay after scaler \n", *DSTXAfterScaler);
1047 	dml_print("DML: dst_y_after_scl: %d lines - number of lines of pipeline and buffer delay after scaler \n", (int)*DSTYAfterScaler);
1048 
1049 	*PrefetchBandwidth = 0;
1050 	*DestinationLinesToRequestVMInVBlank = 0;
1051 	*DestinationLinesToRequestRowInVBlank = 0;
1052 	*VRatioPrefetchY = 0;
1053 	*VRatioPrefetchC = 0;
1054 	*RequiredPrefetchPixDataBWLuma = 0;
1055 	if (dst_y_prefetch_equ > 1) {
1056 		double PrefetchBandwidth1 = 0;
1057 		double PrefetchBandwidth2 = 0;
1058 		double PrefetchBandwidth3 = 0;
1059 		double PrefetchBandwidth4 = 0;
1060 
1061 		if (Tpre_rounded - *Tno_bw > 0)
1062 			PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte
1063 					+ 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor
1064 					+ PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY
1065 					+ PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC)
1066 					/ (Tpre_rounded - *Tno_bw);
1067 		else
1068 			PrefetchBandwidth1 = 0;
1069 
1070 		if (VStartup == MaxVStartup && (PrefetchBandwidth1 > 4 * prefetch_bw_oto) && (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - *Tno_bw) > 0) {
1071 			PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - *Tno_bw);
1072 		}
1073 
1074 		if (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded > 0)
1075 			PrefetchBandwidth2 = (PDEAndMetaPTEBytesFrame *
1076 					HostVMInefficiencyFactor + PrefetchSourceLinesY *
1077 					swath_width_luma_ub * BytePerPixelY +
1078 					PrefetchSourceLinesC * swath_width_chroma_ub *
1079 					BytePerPixelC) /
1080 					(Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded);
1081 		else
1082 			PrefetchBandwidth2 = 0;
1083 
1084 		if (Tpre_rounded - Tvm_trips_rounded > 0)
1085 			PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow *
1086 					HostVMInefficiencyFactor + PrefetchSourceLinesY *
1087 					swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC *
1088 					swath_width_chroma_ub * BytePerPixelC) / (Tpre_rounded -
1089 					Tvm_trips_rounded);
1090 		else
1091 			PrefetchBandwidth3 = 0;
1092 
1093 		if (VStartup == MaxVStartup && (PrefetchBandwidth3 > 4 * prefetch_bw_oto) && Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - Tvm_trips_rounded > 0) {
1094 			PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - Tvm_trips_rounded);
1095 		}
1096 
1097 		if (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded > 0)
1098 			PrefetchBandwidth4 = (PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC)
1099 					/ (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded);
1100 		else
1101 			PrefetchBandwidth4 = 0;
1102 
1103 		{
1104 			bool Case1OK;
1105 			bool Case2OK;
1106 			bool Case3OK;
1107 
1108 			if (PrefetchBandwidth1 > 0) {
1109 				if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth1
1110 						>= Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth1 >= Tr0_trips_rounded) {
1111 					Case1OK = true;
1112 				} else {
1113 					Case1OK = false;
1114 				}
1115 			} else {
1116 				Case1OK = false;
1117 			}
1118 
1119 			if (PrefetchBandwidth2 > 0) {
1120 				if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth2
1121 						>= Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth2 < Tr0_trips_rounded) {
1122 					Case2OK = true;
1123 				} else {
1124 					Case2OK = false;
1125 				}
1126 			} else {
1127 				Case2OK = false;
1128 			}
1129 
1130 			if (PrefetchBandwidth3 > 0) {
1131 				if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth3
1132 						< Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth3 >= Tr0_trips_rounded) {
1133 					Case3OK = true;
1134 				} else {
1135 					Case3OK = false;
1136 				}
1137 			} else {
1138 				Case3OK = false;
1139 			}
1140 
1141 			if (Case1OK) {
1142 				prefetch_bw_equ = PrefetchBandwidth1;
1143 			} else if (Case2OK) {
1144 				prefetch_bw_equ = PrefetchBandwidth2;
1145 			} else if (Case3OK) {
1146 				prefetch_bw_equ = PrefetchBandwidth3;
1147 			} else {
1148 				prefetch_bw_equ = PrefetchBandwidth4;
1149 			}
1150 
1151 			dml_print("DML: prefetch_bw_equ: %f\n", prefetch_bw_equ);
1152 
1153 			if (prefetch_bw_equ > 0) {
1154 				if (GPUVMEnable) {
1155 					Tvm_equ = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_equ, Tvm_trips, LineTime / 4);
1156 				} else {
1157 					Tvm_equ = LineTime / 4;
1158 				}
1159 
1160 				if ((GPUVMEnable || myPipe->DCCEnable)) {
1161 					Tr0_equ = dml_max4(
1162 							(MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_equ,
1163 							Tr0_trips,
1164 							(LineTime - Tvm_equ) / 2,
1165 							LineTime / 4);
1166 				} else {
1167 					Tr0_equ = (LineTime - Tvm_equ) / 2;
1168 				}
1169 			} else {
1170 				Tvm_equ = 0;
1171 				Tr0_equ = 0;
1172 				dml_print("DML: prefetch_bw_equ equals 0! %s:%d\n", __FILE__, __LINE__);
1173 			}
1174 		}
1175 
1176 		if (dst_y_prefetch_oto < dst_y_prefetch_equ) {
1177 			*DestinationLinesForPrefetch = dst_y_prefetch_oto;
1178 			TimeForFetchingMetaPTE = Tvm_oto;
1179 			TimeForFetchingRowInVBlank = Tr0_oto;
1180 			*PrefetchBandwidth = prefetch_bw_oto;
1181 		} else {
1182 			*DestinationLinesForPrefetch = dst_y_prefetch_equ;
1183 			TimeForFetchingMetaPTE = Tvm_equ;
1184 			TimeForFetchingRowInVBlank = Tr0_equ;
1185 			*PrefetchBandwidth = prefetch_bw_equ;
1186 		}
1187 
1188 		*DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * TimeForFetchingMetaPTE / LineTime, 1.0) / 4.0;
1189 
1190 		*DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * TimeForFetchingRowInVBlank / LineTime, 1.0) / 4.0;
1191 
1192 
1193 		LinesToRequestPrefetchPixelData = *DestinationLinesForPrefetch - *DestinationLinesToRequestVMInVBlank
1194 				- 2 * *DestinationLinesToRequestRowInVBlank;
1195 
1196 		if (LinesToRequestPrefetchPixelData > 0 && prefetch_bw_equ > 0) {
1197 
1198 			*VRatioPrefetchY = (double) PrefetchSourceLinesY
1199 					/ LinesToRequestPrefetchPixelData;
1200 			*VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
1201 			if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
1202 				if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
1203 					*VRatioPrefetchY = dml_max((double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData,
1204 						(double) MaxNumSwathY * SwathHeightY / (LinesToRequestPrefetchPixelData - (VInitPreFillY - 3.0) / 2.0));
1205 					*VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
1206 				} else {
1207 					MyError = true;
1208 					dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1209 					*VRatioPrefetchY = 0;
1210 				}
1211 			}
1212 
1213 			*VRatioPrefetchC = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData;
1214 			*VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
1215 
1216 			if ((SwathHeightC > 4)) {
1217 				if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
1218 					*VRatioPrefetchC = dml_max(*VRatioPrefetchC,
1219 						(double) MaxNumSwathC * SwathHeightC / (LinesToRequestPrefetchPixelData - (VInitPreFillC - 3.0) / 2.0));
1220 					*VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
1221 				} else {
1222 					MyError = true;
1223 					dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1224 					*VRatioPrefetchC = 0;
1225 				}
1226 			}
1227 
1228 			*RequiredPrefetchPixDataBWLuma = (double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData * BytePerPixelY * swath_width_luma_ub / LineTime;
1229 			*RequiredPrefetchPixDataBWChroma = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData * BytePerPixelC * swath_width_chroma_ub / LineTime;
1230 		} else {
1231 			MyError = true;
1232 			dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1233 			dml_print("DML: LinesToRequestPrefetchPixelData: %f, should be > 0\n", LinesToRequestPrefetchPixelData);
1234 			*VRatioPrefetchY = 0;
1235 			*VRatioPrefetchC = 0;
1236 			*RequiredPrefetchPixDataBWLuma = 0;
1237 			*RequiredPrefetchPixDataBWChroma = 0;
1238 		}
1239 
1240 		dml_print("DML: Tpre: %fus - sum of tim to request meta pte, 2 x data pte + meta data, swaths\n", (double)LinesToRequestPrefetchPixelData * LineTime + 2.0*TimeForFetchingRowInVBlank + TimeForFetchingMetaPTE);
1241 		dml_print("DML:  Tvm: %fus - time to fetch page tables for meta surface\n", TimeForFetchingMetaPTE);
1242 		dml_print("DML:  Tr0: %fus - time to fetch first row of data pagetables and first row of meta data (done in parallel)\n", TimeForFetchingRowInVBlank);
1243 		dml_print("DML:  Tr1: %fus - time to fetch second row of data pagetables and second row of meta data (done in parallel)\n", TimeForFetchingRowInVBlank);
1244 		dml_print("DML:  Tsw: %fus = time to fetch enough pixel data and cursor data to feed the scalers init position and detile\n", (double)LinesToRequestPrefetchPixelData * LineTime);
1245 		dml_print("DML: To: %fus - time for propagation from scaler to optc\n", (*DSTYAfterScaler + ((*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime);
1246 		dml_print("DML: Tvstartup - Tsetup - Tcalc - Twait - Tpre - To > 0\n");
1247 		dml_print("DML: Tslack(pre): %fus - time left over in schedule\n", VStartup * LineTime - TimeForFetchingMetaPTE - 2 * TimeForFetchingRowInVBlank - (*DSTYAfterScaler + ((*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime - TWait - TCalc - Tsetup);
1248 		dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %d\n", PixelPTEBytesPerRow);
1249 
1250 	} else {
1251 		MyError = true;
1252 		dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1253 	}
1254 
1255 	{
1256 		double prefetch_vm_bw = 0;
1257 		double prefetch_row_bw = 0;
1258 
1259 		if (PDEAndMetaPTEBytesFrame == 0) {
1260 			prefetch_vm_bw = 0;
1261 		} else if (*DestinationLinesToRequestVMInVBlank > 0) {
1262 			prefetch_vm_bw = PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInVBlank * LineTime);
1263 		} else {
1264 			prefetch_vm_bw = 0;
1265 			MyError = true;
1266 			dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1267 		}
1268 		if (MetaRowByte + PixelPTEBytesPerRow == 0) {
1269 			prefetch_row_bw = 0;
1270 		} else if (*DestinationLinesToRequestRowInVBlank > 0) {
1271 			prefetch_row_bw = (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInVBlank * LineTime);
1272 		} else {
1273 			prefetch_row_bw = 0;
1274 			MyError = true;
1275 			dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1276 		}
1277 
1278 		*prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw);
1279 	}
1280 
1281 	if (MyError) {
1282 		*PrefetchBandwidth = 0;
1283 		TimeForFetchingMetaPTE = 0;
1284 		TimeForFetchingRowInVBlank = 0;
1285 		*DestinationLinesToRequestVMInVBlank = 0;
1286 		*DestinationLinesToRequestRowInVBlank = 0;
1287 		*DestinationLinesForPrefetch = 0;
1288 		LinesToRequestPrefetchPixelData = 0;
1289 		*VRatioPrefetchY = 0;
1290 		*VRatioPrefetchC = 0;
1291 		*RequiredPrefetchPixDataBWLuma = 0;
1292 		*RequiredPrefetchPixDataBWChroma = 0;
1293 	}
1294 
1295 	return MyError;
1296 }
1297 
RoundToDFSGranularityUp(double Clock,double VCOSpeed)1298 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed)
1299 {
1300 	return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1);
1301 }
1302 
RoundToDFSGranularityDown(double Clock,double VCOSpeed)1303 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed)
1304 {
1305 	return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4.0 / Clock, 1);
1306 }
1307 
CalculateDCCConfiguration(bool DCCEnabled,bool DCCProgrammingAssumesScanDirectionUnknown,enum source_format_class SourcePixelFormat,unsigned int SurfaceWidthLuma,unsigned int SurfaceWidthChroma,unsigned int SurfaceHeightLuma,unsigned int SurfaceHeightChroma,double DETBufferSize,unsigned int RequestHeight256ByteLuma,unsigned int RequestHeight256ByteChroma,enum dm_swizzle_mode TilingFormat,unsigned int BytePerPixelY,unsigned int BytePerPixelC,double BytePerPixelDETY,double BytePerPixelDETC,enum scan_direction_class ScanOrientation,unsigned int * MaxUncompressedBlockLuma,unsigned int * MaxUncompressedBlockChroma,unsigned int * MaxCompressedBlockLuma,unsigned int * MaxCompressedBlockChroma,unsigned int * IndependentBlockLuma,unsigned int * IndependentBlockChroma)1308 static void CalculateDCCConfiguration(
1309 		bool DCCEnabled,
1310 		bool DCCProgrammingAssumesScanDirectionUnknown,
1311 		enum source_format_class SourcePixelFormat,
1312 		unsigned int SurfaceWidthLuma,
1313 		unsigned int SurfaceWidthChroma,
1314 		unsigned int SurfaceHeightLuma,
1315 		unsigned int SurfaceHeightChroma,
1316 		double DETBufferSize,
1317 		unsigned int RequestHeight256ByteLuma,
1318 		unsigned int RequestHeight256ByteChroma,
1319 		enum dm_swizzle_mode TilingFormat,
1320 		unsigned int BytePerPixelY,
1321 		unsigned int BytePerPixelC,
1322 		double BytePerPixelDETY,
1323 		double BytePerPixelDETC,
1324 		enum scan_direction_class ScanOrientation,
1325 		unsigned int *MaxUncompressedBlockLuma,
1326 		unsigned int *MaxUncompressedBlockChroma,
1327 		unsigned int *MaxCompressedBlockLuma,
1328 		unsigned int *MaxCompressedBlockChroma,
1329 		unsigned int *IndependentBlockLuma,
1330 		unsigned int *IndependentBlockChroma)
1331 {
1332 	int yuv420 = 0;
1333 	int horz_div_l = 0;
1334 	int horz_div_c = 0;
1335 	int vert_div_l = 0;
1336 	int vert_div_c = 0;
1337 
1338 	int req128_horz_wc_l = 0;
1339 	int req128_horz_wc_c = 0;
1340 	int req128_vert_wc_l = 0;
1341 	int req128_vert_wc_c = 0;
1342 	int segment_order_horz_contiguous_luma = 0;
1343 	int segment_order_horz_contiguous_chroma = 0;
1344 	int segment_order_vert_contiguous_luma = 0;
1345 	int segment_order_vert_contiguous_chroma = 0;
1346 
1347 	long full_swath_bytes_horz_wc_l = 0;
1348 	long full_swath_bytes_horz_wc_c = 0;
1349 	long full_swath_bytes_vert_wc_l = 0;
1350 	long full_swath_bytes_vert_wc_c = 0;
1351 
1352 	long swath_buf_size = 0;
1353 	double detile_buf_vp_horz_limit = 0;
1354 	double detile_buf_vp_vert_limit = 0;
1355 
1356 	long MAS_vp_horz_limit = 0;
1357 	long MAS_vp_vert_limit = 0;
1358 	long max_vp_horz_width = 0;
1359 	long max_vp_vert_height = 0;
1360 	long eff_surf_width_l = 0;
1361 	long eff_surf_width_c = 0;
1362 	long eff_surf_height_l = 0;
1363 	long eff_surf_height_c = 0;
1364 
1365 	typedef enum {
1366 		REQ_256Bytes,
1367 		REQ_128BytesNonContiguous,
1368 		REQ_128BytesContiguous,
1369 		REQ_NA
1370 	} RequestType;
1371 
1372 	RequestType   RequestLuma;
1373 	RequestType   RequestChroma;
1374 
1375 	yuv420 = ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12) ? 1 : 0);
1376 	horz_div_l = 1;
1377 	horz_div_c = 1;
1378 	vert_div_l = 1;
1379 	vert_div_c = 1;
1380 
1381 	if (BytePerPixelY == 1)
1382 		vert_div_l = 0;
1383 	if (BytePerPixelC == 1)
1384 		vert_div_c = 0;
1385 	if (BytePerPixelY == 8
1386 			&& (TilingFormat == dm_sw_64kb_s || TilingFormat == dm_sw_64kb_s_t
1387 					|| TilingFormat == dm_sw_64kb_s_x))
1388 		horz_div_l = 0;
1389 	if (BytePerPixelC == 8
1390 			&& (TilingFormat == dm_sw_64kb_s || TilingFormat == dm_sw_64kb_s_t
1391 					|| TilingFormat == dm_sw_64kb_s_x))
1392 		horz_div_c = 0;
1393 
1394 	if (BytePerPixelC == 0) {
1395 		swath_buf_size = DETBufferSize / 2 - 2 * 256;
1396 		detile_buf_vp_horz_limit = (double) swath_buf_size
1397 				/ ((double) RequestHeight256ByteLuma * BytePerPixelY
1398 						/ (1 + horz_div_l));
1399 		detile_buf_vp_vert_limit = (double) swath_buf_size
1400 				/ (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l));
1401 	} else {
1402 		swath_buf_size = DETBufferSize / 2 - 2 * 2 * 256;
1403 		detile_buf_vp_horz_limit = (double) swath_buf_size
1404 				/ ((double) RequestHeight256ByteLuma * BytePerPixelY
1405 						/ (1 + horz_div_l)
1406 						+ (double) RequestHeight256ByteChroma
1407 								* BytePerPixelC / (1 + horz_div_c)
1408 								/ (1 + yuv420));
1409 		detile_buf_vp_vert_limit = (double) swath_buf_size
1410 				/ (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l)
1411 						+ 256.0 / RequestHeight256ByteChroma
1412 								/ (1 + vert_div_c) / (1 + yuv420));
1413 	}
1414 
1415 	if (SourcePixelFormat == dm_420_10) {
1416 		detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit;
1417 		detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit;
1418 	}
1419 
1420 	detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16);
1421 	detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16);
1422 
1423 	MAS_vp_horz_limit = 5760;
1424 	MAS_vp_vert_limit = (BytePerPixelC > 0 ? 2880 : 5760);
1425 	max_vp_horz_width = dml_min((double) MAS_vp_horz_limit, detile_buf_vp_horz_limit);
1426 	max_vp_vert_height = dml_min((double) MAS_vp_vert_limit, detile_buf_vp_vert_limit);
1427 	eff_surf_width_l =
1428 			(SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma);
1429 	eff_surf_width_c = eff_surf_width_l / (1 + yuv420);
1430 	eff_surf_height_l = (
1431 			SurfaceHeightLuma > max_vp_vert_height ?
1432 					max_vp_vert_height : SurfaceHeightLuma);
1433 	eff_surf_height_c = eff_surf_height_l / (1 + yuv420);
1434 
1435 	full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY;
1436 	full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma;
1437 	if (BytePerPixelC > 0) {
1438 		full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma
1439 				* BytePerPixelC;
1440 		full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma;
1441 	} else {
1442 		full_swath_bytes_horz_wc_c = 0;
1443 		full_swath_bytes_vert_wc_c = 0;
1444 	}
1445 
1446 	if (SourcePixelFormat == dm_420_10) {
1447 		full_swath_bytes_horz_wc_l = dml_ceil(full_swath_bytes_horz_wc_l * 2 / 3, 256);
1448 		full_swath_bytes_horz_wc_c = dml_ceil(full_swath_bytes_horz_wc_c * 2 / 3, 256);
1449 		full_swath_bytes_vert_wc_l = dml_ceil(full_swath_bytes_vert_wc_l * 2 / 3, 256);
1450 		full_swath_bytes_vert_wc_c = dml_ceil(full_swath_bytes_vert_wc_c * 2 / 3, 256);
1451 	}
1452 
1453 	if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSize) {
1454 		req128_horz_wc_l = 0;
1455 		req128_horz_wc_c = 0;
1456 	} else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c
1457 			&& 2 * full_swath_bytes_horz_wc_l + full_swath_bytes_horz_wc_c
1458 					<= DETBufferSize) {
1459 		req128_horz_wc_l = 0;
1460 		req128_horz_wc_c = 1;
1461 	} else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c
1462 			&& full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c
1463 					<= DETBufferSize) {
1464 		req128_horz_wc_l = 1;
1465 		req128_horz_wc_c = 0;
1466 	} else {
1467 		req128_horz_wc_l = 1;
1468 		req128_horz_wc_c = 1;
1469 	}
1470 
1471 	if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSize) {
1472 		req128_vert_wc_l = 0;
1473 		req128_vert_wc_c = 0;
1474 	} else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c
1475 			&& 2 * full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c
1476 					<= DETBufferSize) {
1477 		req128_vert_wc_l = 0;
1478 		req128_vert_wc_c = 1;
1479 	} else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c
1480 			&& full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c
1481 					<= DETBufferSize) {
1482 		req128_vert_wc_l = 1;
1483 		req128_vert_wc_c = 0;
1484 	} else {
1485 		req128_vert_wc_l = 1;
1486 		req128_vert_wc_c = 1;
1487 	}
1488 
1489 	if (BytePerPixelY == 2 || (BytePerPixelY == 4 && TilingFormat != dm_sw_64kb_r_x)) {
1490 		segment_order_horz_contiguous_luma = 0;
1491 	} else {
1492 		segment_order_horz_contiguous_luma = 1;
1493 	}
1494 	if ((BytePerPixelY == 8
1495 			&& (TilingFormat == dm_sw_64kb_d || TilingFormat == dm_sw_64kb_d_x
1496 					|| TilingFormat == dm_sw_64kb_d_t
1497 					|| TilingFormat == dm_sw_64kb_r_x))
1498 			|| (BytePerPixelY == 4 && TilingFormat == dm_sw_64kb_r_x)) {
1499 		segment_order_vert_contiguous_luma = 0;
1500 	} else {
1501 		segment_order_vert_contiguous_luma = 1;
1502 	}
1503 	if (BytePerPixelC == 2 || (BytePerPixelC == 4 && TilingFormat != dm_sw_64kb_r_x)) {
1504 		segment_order_horz_contiguous_chroma = 0;
1505 	} else {
1506 		segment_order_horz_contiguous_chroma = 1;
1507 	}
1508 	if ((BytePerPixelC == 8
1509 			&& (TilingFormat == dm_sw_64kb_d || TilingFormat == dm_sw_64kb_d_x
1510 					|| TilingFormat == dm_sw_64kb_d_t
1511 					|| TilingFormat == dm_sw_64kb_r_x))
1512 			|| (BytePerPixelC == 4 && TilingFormat == dm_sw_64kb_r_x)) {
1513 		segment_order_vert_contiguous_chroma = 0;
1514 	} else {
1515 		segment_order_vert_contiguous_chroma = 1;
1516 	}
1517 
1518 	if (DCCProgrammingAssumesScanDirectionUnknown == true) {
1519 		if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0) {
1520 			RequestLuma = REQ_256Bytes;
1521 		} else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0)
1522 				|| (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0)) {
1523 			RequestLuma = REQ_128BytesNonContiguous;
1524 		} else {
1525 			RequestLuma = REQ_128BytesContiguous;
1526 		}
1527 		if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0) {
1528 			RequestChroma = REQ_256Bytes;
1529 		} else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0)
1530 				|| (req128_vert_wc_c == 1
1531 						&& segment_order_vert_contiguous_chroma == 0)) {
1532 			RequestChroma = REQ_128BytesNonContiguous;
1533 		} else {
1534 			RequestChroma = REQ_128BytesContiguous;
1535 		}
1536 	} else if (ScanOrientation != dm_vert) {
1537 		if (req128_horz_wc_l == 0) {
1538 			RequestLuma = REQ_256Bytes;
1539 		} else if (segment_order_horz_contiguous_luma == 0) {
1540 			RequestLuma = REQ_128BytesNonContiguous;
1541 		} else {
1542 			RequestLuma = REQ_128BytesContiguous;
1543 		}
1544 		if (req128_horz_wc_c == 0) {
1545 			RequestChroma = REQ_256Bytes;
1546 		} else if (segment_order_horz_contiguous_chroma == 0) {
1547 			RequestChroma = REQ_128BytesNonContiguous;
1548 		} else {
1549 			RequestChroma = REQ_128BytesContiguous;
1550 		}
1551 	} else {
1552 		if (req128_vert_wc_l == 0) {
1553 			RequestLuma = REQ_256Bytes;
1554 		} else if (segment_order_vert_contiguous_luma == 0) {
1555 			RequestLuma = REQ_128BytesNonContiguous;
1556 		} else {
1557 			RequestLuma = REQ_128BytesContiguous;
1558 		}
1559 		if (req128_vert_wc_c == 0) {
1560 			RequestChroma = REQ_256Bytes;
1561 		} else if (segment_order_vert_contiguous_chroma == 0) {
1562 			RequestChroma = REQ_128BytesNonContiguous;
1563 		} else {
1564 			RequestChroma = REQ_128BytesContiguous;
1565 		}
1566 	}
1567 
1568 	if (RequestLuma == REQ_256Bytes) {
1569 		*MaxUncompressedBlockLuma = 256;
1570 		*MaxCompressedBlockLuma = 256;
1571 		*IndependentBlockLuma = 0;
1572 	} else if (RequestLuma == REQ_128BytesContiguous) {
1573 		*MaxUncompressedBlockLuma = 256;
1574 		*MaxCompressedBlockLuma = 128;
1575 		*IndependentBlockLuma = 128;
1576 	} else {
1577 		*MaxUncompressedBlockLuma = 256;
1578 		*MaxCompressedBlockLuma = 64;
1579 		*IndependentBlockLuma = 64;
1580 	}
1581 
1582 	if (RequestChroma == REQ_256Bytes) {
1583 		*MaxUncompressedBlockChroma = 256;
1584 		*MaxCompressedBlockChroma = 256;
1585 		*IndependentBlockChroma = 0;
1586 	} else if (RequestChroma == REQ_128BytesContiguous) {
1587 		*MaxUncompressedBlockChroma = 256;
1588 		*MaxCompressedBlockChroma = 128;
1589 		*IndependentBlockChroma = 128;
1590 	} else {
1591 		*MaxUncompressedBlockChroma = 256;
1592 		*MaxCompressedBlockChroma = 64;
1593 		*IndependentBlockChroma = 64;
1594 	}
1595 
1596 	if (DCCEnabled != true || BytePerPixelC == 0) {
1597 		*MaxUncompressedBlockChroma = 0;
1598 		*MaxCompressedBlockChroma = 0;
1599 		*IndependentBlockChroma = 0;
1600 	}
1601 
1602 	if (DCCEnabled != true) {
1603 		*MaxUncompressedBlockLuma = 0;
1604 		*MaxCompressedBlockLuma = 0;
1605 		*IndependentBlockLuma = 0;
1606 	}
1607 }
1608 
1609 
CalculatePrefetchSourceLines(struct display_mode_lib * mode_lib,double VRatio,double vtaps,bool Interlace,bool ProgressiveToInterlaceUnitInOPP,unsigned int SwathHeight,unsigned int ViewportYStart,double * VInitPreFill,unsigned int * MaxNumSwath)1610 static double CalculatePrefetchSourceLines(
1611 		struct display_mode_lib *mode_lib,
1612 		double VRatio,
1613 		double vtaps,
1614 		bool Interlace,
1615 		bool ProgressiveToInterlaceUnitInOPP,
1616 		unsigned int SwathHeight,
1617 		unsigned int ViewportYStart,
1618 		double *VInitPreFill,
1619 		unsigned int *MaxNumSwath)
1620 {
1621 	unsigned int MaxPartialSwath = 0;
1622 
1623 	if (ProgressiveToInterlaceUnitInOPP)
1624 		*VInitPreFill = dml_floor((VRatio + vtaps + 1) / 2.0, 1);
1625 	else
1626 		*VInitPreFill = dml_floor((VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1);
1627 
1628 	if (!mode_lib->vba.IgnoreViewportPositioning) {
1629 
1630 		*MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0;
1631 
1632 		if (*VInitPreFill > 1.0)
1633 			MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight;
1634 		else
1635 			MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2)
1636 					% SwathHeight;
1637 		MaxPartialSwath = dml_max(1U, MaxPartialSwath);
1638 
1639 	} else {
1640 
1641 		if (ViewportYStart != 0)
1642 			dml_print(
1643 					"WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n");
1644 
1645 		*MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1);
1646 
1647 		if (*VInitPreFill > 1.0)
1648 			MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight;
1649 		else
1650 			MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1)
1651 					% SwathHeight;
1652 	}
1653 
1654 	return *MaxNumSwath * SwathHeight + MaxPartialSwath;
1655 }
1656 
CalculateVMAndRowBytes(struct display_mode_lib * mode_lib,bool DCCEnable,unsigned int BlockHeight256Bytes,unsigned int BlockWidth256Bytes,enum source_format_class SourcePixelFormat,unsigned int SurfaceTiling,unsigned int BytePerPixel,enum scan_direction_class ScanDirection,unsigned int SwathWidth,unsigned int ViewportHeight,bool GPUVMEnable,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,unsigned int GPUVMMinPageSize,unsigned int HostVMMinPageSize,unsigned int PTEBufferSizeInRequests,unsigned int Pitch,unsigned int DCCMetaPitch,unsigned int * MacroTileWidth,unsigned int * MetaRowByte,unsigned int * PixelPTEBytesPerRow,bool * PTEBufferSizeNotExceeded,unsigned int * dpte_row_width_ub,unsigned int * dpte_row_height,unsigned int * MetaRequestWidth,unsigned int * MetaRequestHeight,unsigned int * meta_row_width,unsigned int * meta_row_height,unsigned int * vm_group_bytes,unsigned int * dpte_group_bytes,unsigned int * PixelPTEReqWidth,unsigned int * PixelPTEReqHeight,unsigned int * PTERequestSize,unsigned int * DPDE0BytesFrame,unsigned int * MetaPTEBytesFrame)1657 static unsigned int CalculateVMAndRowBytes(
1658 		struct display_mode_lib *mode_lib,
1659 		bool DCCEnable,
1660 		unsigned int BlockHeight256Bytes,
1661 		unsigned int BlockWidth256Bytes,
1662 		enum source_format_class SourcePixelFormat,
1663 		unsigned int SurfaceTiling,
1664 		unsigned int BytePerPixel,
1665 		enum scan_direction_class ScanDirection,
1666 		unsigned int SwathWidth,
1667 		unsigned int ViewportHeight,
1668 		bool GPUVMEnable,
1669 		bool HostVMEnable,
1670 		unsigned int HostVMMaxNonCachedPageTableLevels,
1671 		unsigned int GPUVMMinPageSize,
1672 		unsigned int HostVMMinPageSize,
1673 		unsigned int PTEBufferSizeInRequests,
1674 		unsigned int Pitch,
1675 		unsigned int DCCMetaPitch,
1676 		unsigned int *MacroTileWidth,
1677 		unsigned int *MetaRowByte,
1678 		unsigned int *PixelPTEBytesPerRow,
1679 		bool *PTEBufferSizeNotExceeded,
1680 		unsigned int *dpte_row_width_ub,
1681 		unsigned int *dpte_row_height,
1682 		unsigned int *MetaRequestWidth,
1683 		unsigned int *MetaRequestHeight,
1684 		unsigned int *meta_row_width,
1685 		unsigned int *meta_row_height,
1686 		unsigned int *vm_group_bytes,
1687 		unsigned int *dpte_group_bytes,
1688 		unsigned int *PixelPTEReqWidth,
1689 		unsigned int *PixelPTEReqHeight,
1690 		unsigned int *PTERequestSize,
1691 		unsigned int *DPDE0BytesFrame,
1692 		unsigned int *MetaPTEBytesFrame)
1693 {
1694 	unsigned int MPDEBytesFrame = 0;
1695 	unsigned int DCCMetaSurfaceBytes = 0;
1696 	unsigned int MacroTileSizeBytes = 0;
1697 	unsigned int MacroTileHeight = 0;
1698 	unsigned int ExtraDPDEBytesFrame = 0;
1699 	unsigned int PDEAndMetaPTEBytesFrame = 0;
1700 	unsigned int PixelPTEReqHeightPTEs = 0;
1701 	unsigned int HostVMDynamicLevels = 0;
1702 
1703 	double FractionOfPTEReturnDrop;
1704 
1705 	if (GPUVMEnable == true && HostVMEnable == true) {
1706 		if (HostVMMinPageSize < 2048) {
1707 			HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
1708 		} else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) {
1709 			HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
1710 		} else {
1711 			HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
1712 		}
1713 	}
1714 
1715 	*MetaRequestHeight = 8 * BlockHeight256Bytes;
1716 	*MetaRequestWidth = 8 * BlockWidth256Bytes;
1717 	if (ScanDirection != dm_vert) {
1718 		*meta_row_height = *MetaRequestHeight;
1719 		*meta_row_width = dml_ceil((double) SwathWidth - 1, *MetaRequestWidth)
1720 				+ *MetaRequestWidth;
1721 		*MetaRowByte = *meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0;
1722 	} else {
1723 		*meta_row_height = *MetaRequestWidth;
1724 		*meta_row_width = dml_ceil((double) SwathWidth - 1, *MetaRequestHeight)
1725 				+ *MetaRequestHeight;
1726 		*MetaRowByte = *meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0;
1727 	}
1728 	DCCMetaSurfaceBytes = DCCMetaPitch * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes)
1729 					+ 64 * BlockHeight256Bytes) * BytePerPixel / 256;
1730 	if (GPUVMEnable == true) {
1731 		*MetaPTEBytesFrame = (dml_ceil((double) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / (8 * 4.0 * 1024), 1) + 1) * 64;
1732 		MPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 1);
1733 	} else {
1734 		*MetaPTEBytesFrame = 0;
1735 		MPDEBytesFrame = 0;
1736 	}
1737 
1738 	if (DCCEnable != true) {
1739 		*MetaPTEBytesFrame = 0;
1740 		MPDEBytesFrame = 0;
1741 		*MetaRowByte = 0;
1742 	}
1743 
1744 	if (SurfaceTiling == dm_sw_linear) {
1745 		MacroTileSizeBytes = 256;
1746 		MacroTileHeight = BlockHeight256Bytes;
1747 	} else {
1748 		MacroTileSizeBytes = 65536;
1749 		MacroTileHeight = 16 * BlockHeight256Bytes;
1750 	}
1751 	*MacroTileWidth = MacroTileSizeBytes / BytePerPixel / MacroTileHeight;
1752 
1753 	if (GPUVMEnable == true && mode_lib->vba.GPUVMMaxPageTableLevels > 1) {
1754 		if (ScanDirection != dm_vert) {
1755 			*DPDE0BytesFrame = 64 * (dml_ceil(((Pitch * (dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), 1) + 1);
1756 		} else {
1757 			*DPDE0BytesFrame = 64 * (dml_ceil(((Pitch * (dml_ceil((double) SwathWidth - 1, MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), 1) + 1);
1758 		}
1759 		ExtraDPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 2);
1760 	} else {
1761 		*DPDE0BytesFrame = 0;
1762 		ExtraDPDEBytesFrame = 0;
1763 	}
1764 
1765 	PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame
1766 			+ ExtraDPDEBytesFrame;
1767 
1768 	if (HostVMEnable == true) {
1769 		PDEAndMetaPTEBytesFrame = PDEAndMetaPTEBytesFrame * (1 + 8 * HostVMDynamicLevels);
1770 	}
1771 
1772 	if (SurfaceTiling == dm_sw_linear) {
1773 		PixelPTEReqHeightPTEs = 1;
1774 		*PixelPTEReqHeight = 1;
1775 		*PixelPTEReqWidth = 32768.0 / BytePerPixel;
1776 		*PTERequestSize = 64;
1777 		FractionOfPTEReturnDrop = 0;
1778 	} else if (MacroTileSizeBytes == 4096) {
1779 		PixelPTEReqHeightPTEs = 1;
1780 		*PixelPTEReqHeight = MacroTileHeight;
1781 		*PixelPTEReqWidth = 8 * *MacroTileWidth;
1782 		*PTERequestSize = 64;
1783 		if (ScanDirection != dm_vert)
1784 			FractionOfPTEReturnDrop = 0;
1785 		else
1786 			FractionOfPTEReturnDrop = 7 / 8;
1787 	} else if (GPUVMMinPageSize == 4 && MacroTileSizeBytes > 4096) {
1788 		PixelPTEReqHeightPTEs = 16;
1789 		*PixelPTEReqHeight = 16 * BlockHeight256Bytes;
1790 		*PixelPTEReqWidth = 16 * BlockWidth256Bytes;
1791 		*PTERequestSize = 128;
1792 		FractionOfPTEReturnDrop = 0;
1793 	} else {
1794 		PixelPTEReqHeightPTEs = 1;
1795 		*PixelPTEReqHeight = MacroTileHeight;
1796 		*PixelPTEReqWidth = 8 * *MacroTileWidth;
1797 		*PTERequestSize = 64;
1798 		FractionOfPTEReturnDrop = 0;
1799 	}
1800 
1801 	if (SurfaceTiling == dm_sw_linear) {
1802 		if (PTEBufferSizeInRequests == 0)
1803 			*dpte_row_height = 1;
1804 		else
1805 			*dpte_row_height = dml_min(128, 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
1806 		*dpte_row_width_ub = (dml_ceil(((double) SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth;
1807 		*PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
1808 	} else if (ScanDirection != dm_vert) {
1809 		*dpte_row_height = *PixelPTEReqHeight;
1810 		*dpte_row_width_ub = (dml_ceil((double) (SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth;
1811 		*PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
1812 	} else {
1813 		*dpte_row_height = dml_min(*PixelPTEReqWidth, *MacroTileWidth);
1814 		*dpte_row_width_ub = (dml_ceil((double) (SwathWidth - 1) / *PixelPTEReqHeight, 1) + 1) * *PixelPTEReqHeight;
1815 		*PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqHeight * *PTERequestSize;
1816 	}
1817 	if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop)
1818 			<= 64 * PTEBufferSizeInRequests) {
1819 		*PTEBufferSizeNotExceeded = true;
1820 	} else {
1821 		*PTEBufferSizeNotExceeded = false;
1822 	}
1823 
1824 	if (GPUVMEnable != true) {
1825 		*PixelPTEBytesPerRow = 0;
1826 		*PTEBufferSizeNotExceeded = true;
1827 	}
1828 	dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n", *MetaPTEBytesFrame);
1829 
1830 	if (HostVMEnable == true) {
1831 		*PixelPTEBytesPerRow = *PixelPTEBytesPerRow * (1 + 8 * HostVMDynamicLevels);
1832 	}
1833 
1834 	if (HostVMEnable == true) {
1835 		*vm_group_bytes = 512;
1836 		*dpte_group_bytes = 512;
1837 	} else if (GPUVMEnable == true) {
1838 		*vm_group_bytes = 2048;
1839 		if (SurfaceTiling != dm_sw_linear && PixelPTEReqHeightPTEs == 1 && ScanDirection == dm_vert) {
1840 			*dpte_group_bytes = 512;
1841 		} else {
1842 			*dpte_group_bytes = 2048;
1843 		}
1844 	} else {
1845 		*vm_group_bytes = 0;
1846 		*dpte_group_bytes = 0;
1847 	}
1848 
1849 	return PDEAndMetaPTEBytesFrame;
1850 }
1851 
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(struct display_mode_lib * mode_lib)1852 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
1853 		struct display_mode_lib *mode_lib)
1854 {
1855 	struct vba_vars_st *v = &mode_lib->vba;
1856 	unsigned int j, k;
1857 	long ReorderBytes = 0;
1858 	unsigned int PrefetchMode = v->PrefetchModePerState[v->VoltageLevel][v->maxMpcComb];
1859 	double MaxTotalRDBandwidth = 0;
1860 	double MaxTotalRDBandwidthNoUrgentBurst = 0;
1861 	bool DestinationLineTimesForPrefetchLessThan2 = false;
1862 	bool VRatioPrefetchMoreThan4 = false;
1863 	double TWait;
1864 
1865 	v->WritebackDISPCLK = 0.0;
1866 	v->DISPCLKWithRamping = 0;
1867 	v->DISPCLKWithoutRamping = 0;
1868 	v->GlobalDPPCLK = 0.0;
1869 	/* DAL custom code: need to update ReturnBW in case min dcfclk is overriden */
1870 	v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] = dml_min3(
1871 			v->ReturnBusWidth * v->DCFCLK,
1872 			v->DRAMSpeedPerState[v->VoltageLevel] * v->NumberOfChannels * v->DRAMChannelWidth,
1873 			v->FabricClockPerState[v->VoltageLevel] * v->FabricDatapathToDCNDataReturn);
1874 	if (v->HostVMEnable != true) {
1875 		v->ReturnBW = v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
1876 	} else {
1877 		v->ReturnBW = v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / 100;
1878 	}
1879 	/* End DAL custom code */
1880 
1881 	// DISPCLK and DPPCLK Calculation
1882 	//
1883 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
1884 		if (v->WritebackEnable[k]) {
1885 			v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
1886 				dml30_CalculateWriteBackDISPCLK(
1887 						v->WritebackPixelFormat[k],
1888 						v->PixelClock[k],
1889 						v->WritebackHRatio[k],
1890 						v->WritebackVRatio[k],
1891 						v->WritebackHTaps[k],
1892 						v->WritebackVTaps[k],
1893 						v->WritebackSourceWidth[k],
1894 						v->WritebackDestinationWidth[k],
1895 						v->HTotal[k],
1896 						v->WritebackLineBufferSize));
1897 		}
1898 	}
1899 
1900 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
1901 		if (v->HRatio[k] > 1) {
1902 			v->PSCL_THROUGHPUT_LUMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
1903 				v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(v->htaps[k] / 6.0, 1));
1904 		} else {
1905 			v->PSCL_THROUGHPUT_LUMA[k] = dml_min(
1906 					v->MaxDCHUBToPSCLThroughput,
1907 					v->MaxPSCLToLBThroughput);
1908 		}
1909 
1910 		v->DPPCLKUsingSingleDPPLuma = v->PixelClock[k]
1911 			* dml_max(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]),
1912 				dml_max(v->HRatio[k] * v->VRatio[k] / v->PSCL_THROUGHPUT_LUMA[k], 1.0));
1913 
1914 		if ((v->htaps[k] > 6 || v->vtaps[k] > 6)
1915 				&& v->DPPCLKUsingSingleDPPLuma < 2 * v->PixelClock[k]) {
1916 			v->DPPCLKUsingSingleDPPLuma = 2 * v->PixelClock[k];
1917 		}
1918 
1919 		if ((v->SourcePixelFormat[k] != dm_420_8
1920 				&& v->SourcePixelFormat[k] != dm_420_10
1921 				&& v->SourcePixelFormat[k] != dm_420_12
1922 				&& v->SourcePixelFormat[k] != dm_rgbe_alpha)) {
1923 			v->PSCL_THROUGHPUT_CHROMA[k] = 0.0;
1924 			v->DPPCLKUsingSingleDPP[k] = v->DPPCLKUsingSingleDPPLuma;
1925 		} else {
1926 			if (v->HRatioChroma[k] > 1) {
1927 				v->PSCL_THROUGHPUT_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
1928 					v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(v->HTAPsChroma[k] / 6.0, 1.0));
1929 			} else {
1930 				v->PSCL_THROUGHPUT_CHROMA[k] = dml_min(
1931 						v->MaxDCHUBToPSCLThroughput,
1932 						v->MaxPSCLToLBThroughput);
1933 			}
1934 			v->DPPCLKUsingSingleDPPChroma = v->PixelClock[k]
1935 				* dml_max3(v->VTAPsChroma[k] / 6.0 * dml_min(1.0, v->HRatioChroma[k]),
1936 					v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_THROUGHPUT_CHROMA[k], 1.0);
1937 
1938 			if ((v->HTAPsChroma[k] > 6 || v->VTAPsChroma[k] > 6)
1939 					&& v->DPPCLKUsingSingleDPPChroma
1940 							< 2 * v->PixelClock[k]) {
1941 				v->DPPCLKUsingSingleDPPChroma = 2
1942 						* v->PixelClock[k];
1943 			}
1944 
1945 			v->DPPCLKUsingSingleDPP[k] = dml_max(
1946 					v->DPPCLKUsingSingleDPPLuma,
1947 					v->DPPCLKUsingSingleDPPChroma);
1948 		}
1949 	}
1950 
1951 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
1952 		if (v->BlendingAndTiming[k] != k)
1953 			continue;
1954 		if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_4to1) {
1955 			v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
1956 				v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1957 					* (1 + v->DISPCLKRampingMargin / 100));
1958 			v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
1959 				v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1960 		} else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
1961 			v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
1962 				v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1963 					* (1 + v->DISPCLKRampingMargin / 100));
1964 			v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
1965 				v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1966 		} else {
1967 			v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
1968 				v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1969 									* (1 + v->DISPCLKRampingMargin / 100));
1970 			v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
1971 				v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1972 		}
1973 	}
1974 
1975 	v->DISPCLKWithRamping = dml_max(
1976 			v->DISPCLKWithRamping,
1977 			v->WritebackDISPCLK);
1978 	v->DISPCLKWithoutRamping = dml_max(
1979 			v->DISPCLKWithoutRamping,
1980 			v->WritebackDISPCLK);
1981 
1982 	ASSERT(v->DISPCLKDPPCLKVCOSpeed != 0);
1983 	v->DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1984 			v->DISPCLKWithRamping,
1985 			v->DISPCLKDPPCLKVCOSpeed);
1986 	v->DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1987 			v->DISPCLKWithoutRamping,
1988 			v->DISPCLKDPPCLKVCOSpeed);
1989 	v->MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown(
1990 			v->soc.clock_limits[mode_lib->soc.num_states - 1].dispclk_mhz,
1991 			v->DISPCLKDPPCLKVCOSpeed);
1992 	if (v->DISPCLKWithoutRampingRoundedToDFSGranularity
1993 			> v->MaxDispclkRoundedToDFSGranularity) {
1994 		v->DISPCLK_calculated =
1995 				v->DISPCLKWithoutRampingRoundedToDFSGranularity;
1996 	} else if (v->DISPCLKWithRampingRoundedToDFSGranularity
1997 			> v->MaxDispclkRoundedToDFSGranularity) {
1998 		v->DISPCLK_calculated = v->MaxDispclkRoundedToDFSGranularity;
1999 	} else {
2000 		v->DISPCLK_calculated =
2001 				v->DISPCLKWithRampingRoundedToDFSGranularity;
2002 	}
2003 	v->DISPCLK = v->DISPCLK_calculated;
2004 	DTRACE("   dispclk_mhz (calculated) = %f", v->DISPCLK_calculated);
2005 
2006 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2007 		v->DPPCLK_calculated[k] = v->DPPCLKUsingSingleDPP[k]
2008 				/ v->DPPPerPlane[k]
2009 				* (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2010 		v->GlobalDPPCLK = dml_max(
2011 				v->GlobalDPPCLK,
2012 				v->DPPCLK_calculated[k]);
2013 	}
2014 	v->GlobalDPPCLK = RoundToDFSGranularityUp(
2015 			v->GlobalDPPCLK,
2016 			v->DISPCLKDPPCLKVCOSpeed);
2017 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2018 		v->DPPCLK_calculated[k] = v->GlobalDPPCLK / 255
2019 				* dml_ceil(
2020 						v->DPPCLK_calculated[k] * 255.0
2021 								/ v->GlobalDPPCLK,
2022 						1);
2023 		DTRACE("   dppclk_mhz[%i] (calculated) = %f", k, v->DPPCLK_calculated[k]);
2024 		v->DPPCLK[k] = v->DPPCLK_calculated[k];
2025 	}
2026 
2027 	// Urgent and B P-State/DRAM Clock Change Watermark
2028 	DTRACE("   dcfclk_mhz         = %f", v->DCFCLK);
2029 	DTRACE("   return_bus_bw      = %f", v->ReturnBW);
2030 
2031 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2032 		dml30_CalculateBytePerPixelAnd256BBlockSizes(
2033 				v->SourcePixelFormat[k],
2034 				v->SurfaceTiling[k],
2035 				&v->BytePerPixelY[k],
2036 				&v->BytePerPixelC[k],
2037 				&v->BytePerPixelDETY[k],
2038 				&v->BytePerPixelDETC[k],
2039 				&v->BlockHeight256BytesY[k],
2040 				&v->BlockHeight256BytesC[k],
2041 				&v->BlockWidth256BytesY[k],
2042 				&v->BlockWidth256BytesC[k]);
2043 	}
2044 
2045 	CalculateSwathWidth(
2046 			false,
2047 			v->NumberOfActivePlanes,
2048 			v->SourcePixelFormat,
2049 			v->SourceScan,
2050 			v->ViewportWidth,
2051 			v->ViewportHeight,
2052 			v->SurfaceWidthY,
2053 			v->SurfaceWidthC,
2054 			v->SurfaceHeightY,
2055 			v->SurfaceHeightC,
2056 			v->ODMCombineEnabled,
2057 			v->BytePerPixelY,
2058 			v->BytePerPixelC,
2059 			v->BlockHeight256BytesY,
2060 			v->BlockHeight256BytesC,
2061 			v->BlockWidth256BytesY,
2062 			v->BlockWidth256BytesC,
2063 			v->BlendingAndTiming,
2064 			v->HActive,
2065 			v->HRatio,
2066 			v->DPPPerPlane,
2067 			v->SwathWidthSingleDPPY,
2068 			v->SwathWidthSingleDPPC,
2069 			v->SwathWidthY,
2070 			v->SwathWidthC,
2071 			v->dummyinteger3,
2072 			v->dummyinteger4,
2073 			v->swath_width_luma_ub,
2074 			v->swath_width_chroma_ub);
2075 
2076 
2077 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2078 		v->ReadBandwidthPlaneLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k] / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
2079 		v->ReadBandwidthPlaneChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k] / (v->HTotal[k] / v->PixelClock[k]) * v->VRatioChroma[k];
2080 		DTRACE("read_bw[%i] = %fBps", k, v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k]);
2081 	}
2082 
2083 
2084 	// DCFCLK Deep Sleep
2085 	CalculateDCFCLKDeepSleep(
2086 			mode_lib,
2087 			v->NumberOfActivePlanes,
2088 			v->BytePerPixelY,
2089 			v->BytePerPixelC,
2090 			v->VRatio,
2091 			v->VRatioChroma,
2092 			v->SwathWidthY,
2093 			v->SwathWidthC,
2094 			v->DPPPerPlane,
2095 			v->HRatio,
2096 			v->HRatioChroma,
2097 			v->PixelClock,
2098 			v->PSCL_THROUGHPUT_LUMA,
2099 			v->PSCL_THROUGHPUT_CHROMA,
2100 			v->DPPCLK,
2101 			v->ReadBandwidthPlaneLuma,
2102 			v->ReadBandwidthPlaneChroma,
2103 			v->ReturnBusWidth,
2104 			&v->DCFCLKDeepSleep);
2105 
2106 	// DSCCLK
2107 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2108 		if ((v->BlendingAndTiming[k] != k) || !v->DSCEnabled[k]) {
2109 			v->DSCCLK_calculated[k] = 0.0;
2110 		} else {
2111 			if (v->OutputFormat[k] == dm_420)
2112 				v->DSCFormatFactor = 2;
2113 			else if (v->OutputFormat[k] == dm_444)
2114 				v->DSCFormatFactor = 1;
2115 			else if (v->OutputFormat[k] == dm_n422)
2116 				v->DSCFormatFactor = 2;
2117 			else
2118 				v->DSCFormatFactor = 1;
2119 			if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
2120 				v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 12
2121 					/ v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2122 			else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
2123 				v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 6
2124 					/ v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2125 			else
2126 				v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 3
2127 					/ v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2128 		}
2129 	}
2130 
2131 	// DSC Delay
2132 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2133 		double BPP = v->OutputBppPerState[k][v->VoltageLevel];
2134 
2135 		if (v->DSCEnabled[k] && BPP != 0) {
2136 			if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_disabled) {
2137 				v->DSCDelay[k] = dscceComputeDelay(v->DSCInputBitPerComponent[k],
2138 						BPP,
2139 						dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2140 						v->NumberOfDSCSlices[k],
2141 						v->OutputFormat[k],
2142 						v->Output[k])
2143 					+ dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2144 			} else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2145 				v->DSCDelay[k] = 2 * dscceComputeDelay(v->DSCInputBitPerComponent[k],
2146 						BPP,
2147 						dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2148 						v->NumberOfDSCSlices[k] / 2.0,
2149 						v->OutputFormat[k],
2150 						v->Output[k])
2151 					+ dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2152 			} else {
2153 				v->DSCDelay[k] = 4 * dscceComputeDelay(v->DSCInputBitPerComponent[k],
2154 						BPP,
2155 						dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2156 						v->NumberOfDSCSlices[k] / 4.0,
2157 						v->OutputFormat[k],
2158 						v->Output[k])
2159 					+ dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2160 			}
2161 			v->DSCDelay[k] = v->DSCDelay[k] * v->PixelClock[k] / v->PixelClockBackEnd[k];
2162 		} else {
2163 			v->DSCDelay[k] = 0;
2164 		}
2165 	}
2166 
2167 	for (k = 0; k < v->NumberOfActivePlanes; ++k)
2168 		for (j = 0; j < v->NumberOfActivePlanes; ++j) // NumberOfPlanes
2169 			if (j != k && v->BlendingAndTiming[k] == j
2170 					&& v->DSCEnabled[j])
2171 				v->DSCDelay[k] = v->DSCDelay[j];
2172 
2173 	// Prefetch
2174 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2175 		unsigned int PDEAndMetaPTEBytesFrameY = 0;
2176 		unsigned int PixelPTEBytesPerRowY = 0;
2177 		unsigned int MetaRowByteY = 0;
2178 		unsigned int MetaRowByteC = 0;
2179 		unsigned int PDEAndMetaPTEBytesFrameC = 0;
2180 		unsigned int PixelPTEBytesPerRowC = 0;
2181 		bool         PTEBufferSizeNotExceededY = 0;
2182 		bool         PTEBufferSizeNotExceededC = 0;
2183 
2184 
2185 		if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12 || v->SourcePixelFormat[k] == dm_rgbe_alpha) {
2186 			if ((v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) && v->SourceScan[k] != dm_vert) {
2187 				v->PTEBufferSizeInRequestsForLuma = (v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma) / 2;
2188 				v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsForLuma;
2189 			} else {
2190 				v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma;
2191 				v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsChroma;
2192 
2193 			}
2194 			PDEAndMetaPTEBytesFrameC = CalculateVMAndRowBytes(
2195 					mode_lib,
2196 					v->DCCEnable[k],
2197 					v->BlockHeight256BytesC[k],
2198 					v->BlockWidth256BytesC[k],
2199 					v->SourcePixelFormat[k],
2200 					v->SurfaceTiling[k],
2201 					v->BytePerPixelC[k],
2202 					v->SourceScan[k],
2203 					v->SwathWidthC[k],
2204 					v->ViewportHeightChroma[k],
2205 					v->GPUVMEnable,
2206 					v->HostVMEnable,
2207 					v->HostVMMaxNonCachedPageTableLevels,
2208 					v->GPUVMMinPageSize,
2209 					v->HostVMMinPageSize,
2210 					v->PTEBufferSizeInRequestsForChroma,
2211 					v->PitchC[k],
2212 					v->DCCMetaPitchC[k],
2213 					&v->MacroTileWidthC[k],
2214 					&MetaRowByteC,
2215 					&PixelPTEBytesPerRowC,
2216 					&PTEBufferSizeNotExceededC,
2217 					&v->dpte_row_width_chroma_ub[k],
2218 					&v->dpte_row_height_chroma[k],
2219 					&v->meta_req_width_chroma[k],
2220 					&v->meta_req_height_chroma[k],
2221 					&v->meta_row_width_chroma[k],
2222 					&v->meta_row_height_chroma[k],
2223 					&v->dummyinteger1,
2224 					&v->dummyinteger2,
2225 					&v->PixelPTEReqWidthC[k],
2226 					&v->PixelPTEReqHeightC[k],
2227 					&v->PTERequestSizeC[k],
2228 					&v->dpde0_bytes_per_frame_ub_c[k],
2229 					&v->meta_pte_bytes_per_frame_ub_c[k]);
2230 
2231 			v->PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(
2232 					mode_lib,
2233 					v->VRatioChroma[k],
2234 					v->VTAPsChroma[k],
2235 					v->Interlace[k],
2236 					v->ProgressiveToInterlaceUnitInOPP,
2237 					v->SwathHeightC[k],
2238 					v->ViewportYStartC[k],
2239 					&v->VInitPreFillC[k],
2240 					&v->MaxNumSwathC[k]);
2241 		} else {
2242 			v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma;
2243 			v->PTEBufferSizeInRequestsForChroma = 0;
2244 			PixelPTEBytesPerRowC = 0;
2245 			PDEAndMetaPTEBytesFrameC = 0;
2246 			MetaRowByteC = 0;
2247 			v->MaxNumSwathC[k] = 0;
2248 			v->PrefetchSourceLinesC[k] = 0;
2249 		}
2250 
2251 		PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
2252 				mode_lib,
2253 				v->DCCEnable[k],
2254 				v->BlockHeight256BytesY[k],
2255 				v->BlockWidth256BytesY[k],
2256 				v->SourcePixelFormat[k],
2257 				v->SurfaceTiling[k],
2258 				v->BytePerPixelY[k],
2259 				v->SourceScan[k],
2260 				v->SwathWidthY[k],
2261 				v->ViewportHeight[k],
2262 				v->GPUVMEnable,
2263 				v->HostVMEnable,
2264 				v->HostVMMaxNonCachedPageTableLevels,
2265 				v->GPUVMMinPageSize,
2266 				v->HostVMMinPageSize,
2267 				v->PTEBufferSizeInRequestsForLuma,
2268 				v->PitchY[k],
2269 				v->DCCMetaPitchY[k],
2270 				&v->MacroTileWidthY[k],
2271 				&MetaRowByteY,
2272 				&PixelPTEBytesPerRowY,
2273 				&PTEBufferSizeNotExceededY,
2274 				&v->dpte_row_width_luma_ub[k],
2275 				&v->dpte_row_height[k],
2276 				&v->meta_req_width[k],
2277 				&v->meta_req_height[k],
2278 				&v->meta_row_width[k],
2279 				&v->meta_row_height[k],
2280 				&v->vm_group_bytes[k],
2281 				&v->dpte_group_bytes[k],
2282 				&v->PixelPTEReqWidthY[k],
2283 				&v->PixelPTEReqHeightY[k],
2284 				&v->PTERequestSizeY[k],
2285 				&v->dpde0_bytes_per_frame_ub_l[k],
2286 				&v->meta_pte_bytes_per_frame_ub_l[k]);
2287 
2288 		v->PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
2289 				mode_lib,
2290 				v->VRatio[k],
2291 				v->vtaps[k],
2292 				v->Interlace[k],
2293 				v->ProgressiveToInterlaceUnitInOPP,
2294 				v->SwathHeightY[k],
2295 				v->ViewportYStartY[k],
2296 				&v->VInitPreFillY[k],
2297 				&v->MaxNumSwathY[k]);
2298 		v->PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC;
2299 		v->PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY
2300 				+ PDEAndMetaPTEBytesFrameC;
2301 		v->MetaRowByte[k] = MetaRowByteY + MetaRowByteC;
2302 
2303 		CalculateRowBandwidth(
2304 				v->GPUVMEnable,
2305 				v->SourcePixelFormat[k],
2306 				v->VRatio[k],
2307 				v->VRatioChroma[k],
2308 				v->DCCEnable[k],
2309 				v->HTotal[k] / v->PixelClock[k],
2310 				MetaRowByteY,
2311 				MetaRowByteC,
2312 				v->meta_row_height[k],
2313 				v->meta_row_height_chroma[k],
2314 				PixelPTEBytesPerRowY,
2315 				PixelPTEBytesPerRowC,
2316 				v->dpte_row_height[k],
2317 				v->dpte_row_height_chroma[k],
2318 				&v->meta_row_bw[k],
2319 				&v->dpte_row_bw[k]);
2320 	}
2321 
2322 	v->TotalDCCActiveDPP = 0;
2323 	v->TotalActiveDPP = 0;
2324 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2325 		v->TotalActiveDPP = v->TotalActiveDPP
2326 				+ v->DPPPerPlane[k];
2327 		if (v->DCCEnable[k])
2328 			v->TotalDCCActiveDPP = v->TotalDCCActiveDPP
2329 					+ v->DPPPerPlane[k];
2330 	}
2331 
2332 
2333 	ReorderBytes = v->NumberOfChannels * dml_max3(
2334 		v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2335 		v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2336 		v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
2337 
2338 	v->UrgentExtraLatency = CalculateExtraLatency(
2339 		v->RoundTripPingLatencyCycles,
2340 		ReorderBytes,
2341 		v->DCFCLK,
2342 		v->TotalActiveDPP,
2343 		v->PixelChunkSizeInKByte,
2344 		v->TotalDCCActiveDPP,
2345 		v->MetaChunkSize,
2346 		v->ReturnBW,
2347 		v->GPUVMEnable,
2348 		v->HostVMEnable,
2349 		v->NumberOfActivePlanes,
2350 		v->DPPPerPlane,
2351 		v->dpte_group_bytes,
2352 		v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2353 		v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2354 		v->HostVMMinPageSize,
2355 		v->HostVMMaxNonCachedPageTableLevels);
2356 
2357 	v->TCalc = 24.0 / v->DCFCLKDeepSleep;
2358 
2359 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2360 		if (v->BlendingAndTiming[k] == k) {
2361 			if (v->WritebackEnable[k] == true) {
2362 				v->WritebackDelay[v->VoltageLevel][k] = v->WritebackLatency +
2363 						CalculateWriteBackDelay(v->WritebackPixelFormat[k],
2364 									v->WritebackHRatio[k],
2365 									v->WritebackVRatio[k],
2366 									v->WritebackVTaps[k],
2367 									v->WritebackDestinationWidth[k],
2368 									v->WritebackDestinationHeight[k],
2369 									v->WritebackSourceHeight[k],
2370 									v->HTotal[k]) / v->DISPCLK;
2371 			} else
2372 				v->WritebackDelay[v->VoltageLevel][k] = 0;
2373 			for (j = 0; j < v->NumberOfActivePlanes; ++j) {
2374 				if (v->BlendingAndTiming[j] == k
2375 						&& v->WritebackEnable[j] == true) {
2376 					v->WritebackDelay[v->VoltageLevel][k] = dml_max(v->WritebackDelay[v->VoltageLevel][k],
2377 							v->WritebackLatency + CalculateWriteBackDelay(
2378 											v->WritebackPixelFormat[j],
2379 											v->WritebackHRatio[j],
2380 											v->WritebackVRatio[j],
2381 											v->WritebackVTaps[j],
2382 											v->WritebackDestinationWidth[j],
2383 											v->WritebackDestinationHeight[j],
2384 											v->WritebackSourceHeight[j],
2385 											v->HTotal[k]) / v->DISPCLK);
2386 				}
2387 			}
2388 		}
2389 	}
2390 
2391 	for (k = 0; k < v->NumberOfActivePlanes; ++k)
2392 		for (j = 0; j < v->NumberOfActivePlanes; ++j)
2393 			if (v->BlendingAndTiming[k] == j)
2394 				v->WritebackDelay[v->VoltageLevel][k] = v->WritebackDelay[v->VoltageLevel][j];
2395 
2396 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2397 		v->MaxVStartupLines[k] = v->VTotal[k] - v->VActive[k] - dml_max(1.0, dml_ceil((double) v->WritebackDelay[v->VoltageLevel][k] / (v->HTotal[k] / v->PixelClock[k]), 1));
2398 	}
2399 
2400 	v->MaximumMaxVStartupLines = 0;
2401 	for (k = 0; k < v->NumberOfActivePlanes; ++k)
2402 		v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);
2403 
2404 	if (v->DRAMClockChangeLatencyOverride > 0.0) {
2405 		v->FinalDRAMClockChangeLatency = v->DRAMClockChangeLatencyOverride;
2406 	} else {
2407 		v->FinalDRAMClockChangeLatency = v->DRAMClockChangeLatency;
2408 	}
2409 	v->UrgentLatency = CalculateUrgentLatency(v->UrgentLatencyPixelDataOnly, v->UrgentLatencyPixelMixedWithVMData, v->UrgentLatencyVMDataOnly, v->DoUrgentLatencyAdjustment, v->UrgentLatencyAdjustmentFabricClockComponent, v->UrgentLatencyAdjustmentFabricClockReference, v->FabricClock);
2410 
2411 
2412 	v->FractionOfUrgentBandwidth = 0.0;
2413 	v->FractionOfUrgentBandwidthImmediateFlip = 0.0;
2414 
2415 	v->VStartupLines = 13;
2416 
2417 	do {
2418 		MaxTotalRDBandwidth = 0;
2419 		MaxTotalRDBandwidthNoUrgentBurst = 0;
2420 		DestinationLineTimesForPrefetchLessThan2 = false;
2421 		VRatioPrefetchMoreThan4 = false;
2422 		TWait = CalculateTWait(
2423 				PrefetchMode,
2424 				v->FinalDRAMClockChangeLatency,
2425 				v->UrgentLatency,
2426 				v->SREnterPlusExitTime);
2427 
2428 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2429 			Pipe myPipe = { 0 };
2430 
2431 			myPipe.DPPCLK = v->DPPCLK[k];
2432 			myPipe.DISPCLK = v->DISPCLK;
2433 			myPipe.PixelClock = v->PixelClock[k];
2434 			myPipe.DCFCLKDeepSleep = v->DCFCLKDeepSleep;
2435 			myPipe.DPPPerPlane = v->DPPPerPlane[k];
2436 			myPipe.ScalerEnabled = v->ScalerEnabled[k];
2437 			myPipe.SourceScan = v->SourceScan[k];
2438 			myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
2439 			myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
2440 			myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
2441 			myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
2442 			myPipe.InterlaceEnable = v->Interlace[k];
2443 			myPipe.NumberOfCursors = v->NumberOfCursors[k];
2444 			myPipe.VBlank = v->VTotal[k] - v->VActive[k];
2445 			myPipe.HTotal = v->HTotal[k];
2446 			myPipe.DCCEnable = v->DCCEnable[k];
2447 			myPipe.ODMCombineEnabled = !!v->ODMCombineEnabled[k];
2448 
2449 			v->ErrorResult[k] = CalculatePrefetchSchedule(
2450 					mode_lib,
2451 					v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2452 					v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2453 					&myPipe,
2454 					v->DSCDelay[k],
2455 					v->DPPCLKDelaySubtotal
2456 							+ v->DPPCLKDelayCNVCFormater,
2457 					v->DPPCLKDelaySCL,
2458 					v->DPPCLKDelaySCLLBOnly,
2459 					v->DPPCLKDelayCNVCCursor,
2460 					v->DISPCLKDelaySubtotal,
2461 					(unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
2462 					v->OutputFormat[k],
2463 					v->MaxInterDCNTileRepeaters,
2464 					dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
2465 					v->MaxVStartupLines[k],
2466 					v->GPUVMMaxPageTableLevels,
2467 					v->GPUVMEnable,
2468 					v->HostVMEnable,
2469 					v->HostVMMaxNonCachedPageTableLevels,
2470 					v->HostVMMinPageSize,
2471 					v->DynamicMetadataEnable[k],
2472 					v->DynamicMetadataVMEnabled,
2473 					v->DynamicMetadataLinesBeforeActiveRequired[k],
2474 					v->DynamicMetadataTransmittedBytes[k],
2475 					v->UrgentLatency,
2476 					v->UrgentExtraLatency,
2477 					v->TCalc,
2478 					v->PDEAndMetaPTEBytesFrame[k],
2479 					v->MetaRowByte[k],
2480 					v->PixelPTEBytesPerRow[k],
2481 					v->PrefetchSourceLinesY[k],
2482 					v->SwathWidthY[k],
2483 					v->BytePerPixelY[k],
2484 					v->VInitPreFillY[k],
2485 					v->MaxNumSwathY[k],
2486 					v->PrefetchSourceLinesC[k],
2487 					v->SwathWidthC[k],
2488 					v->BytePerPixelC[k],
2489 					v->VInitPreFillC[k],
2490 					v->MaxNumSwathC[k],
2491 					v->swath_width_luma_ub[k],
2492 					v->swath_width_chroma_ub[k],
2493 					v->SwathHeightY[k],
2494 					v->SwathHeightC[k],
2495 					TWait,
2496 					v->ProgressiveToInterlaceUnitInOPP,
2497 					&v->DSTXAfterScaler[k],
2498 					&v->DSTYAfterScaler[k],
2499 					&v->DestinationLinesForPrefetch[k],
2500 					&v->PrefetchBandwidth[k],
2501 					&v->DestinationLinesToRequestVMInVBlank[k],
2502 					&v->DestinationLinesToRequestRowInVBlank[k],
2503 					&v->VRatioPrefetchY[k],
2504 					&v->VRatioPrefetchC[k],
2505 					&v->RequiredPrefetchPixDataBWLuma[k],
2506 					&v->RequiredPrefetchPixDataBWChroma[k],
2507 					&v->NotEnoughTimeForDynamicMetadata[k],
2508 					&v->Tno_bw[k],
2509 					&v->prefetch_vmrow_bw[k],
2510 					&v->Tdmdl_vm[k],
2511 					&v->Tdmdl[k],
2512 					&v->VUpdateOffsetPix[k],
2513 					&v->VUpdateWidthPix[k],
2514 					&v->VReadyOffsetPix[k]);
2515 			if (v->BlendingAndTiming[k] == k) {
2516 				double TotalRepeaterDelayTime = v->MaxInterDCNTileRepeaters * (2 / v->DPPCLK[k] + 3 / v->DISPCLK);
2517 				v->VUpdateWidthPix[k] = (14 / v->DCFCLKDeepSleep + 12 / v->DPPCLK[k] + TotalRepeaterDelayTime) * v->PixelClock[k];
2518 				v->VReadyOffsetPix[k] = dml_max(150.0 / v->DPPCLK[k], TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[k];
2519 				v->VUpdateOffsetPix[k] = dml_ceil(v->HTotal[k] / 4.0, 1);
2520 				v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
2521 			} else {
2522 				int x = v->BlendingAndTiming[k];
2523 				double TotalRepeaterDelayTime = v->MaxInterDCNTileRepeaters * (2 / v->DPPCLK[k] + 3 / v->DISPCLK);
2524 				v->VUpdateWidthPix[k] = (14 / v->DCFCLKDeepSleep + 12 / v->DPPCLK[k] + TotalRepeaterDelayTime) * v->PixelClock[x];
2525 				v->VReadyOffsetPix[k] = dml_max(150.0 / v->DPPCLK[k], TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[x];
2526 				v->VUpdateOffsetPix[k] = dml_ceil(v->HTotal[x] / 4.0, 1);
2527 				if (!v->MaxVStartupLines[x])
2528 					v->MaxVStartupLines[x] = v->MaxVStartupLines[k];
2529 				v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[x]);
2530 			}
2531 		}
2532 
2533 		v->NotEnoughUrgentLatencyHiding[0][0] = false;
2534 		v->NotEnoughUrgentLatencyHidingPre = false;
2535 
2536 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2537 			v->cursor_bw[k] = v->NumberOfCursors[k]
2538 					* v->CursorWidth[k][0] * v->CursorBPP[k][0]
2539 					/ 8.0
2540 					/ (v->HTotal[k] / v->PixelClock[k])
2541 					* v->VRatio[k];
2542 			v->cursor_bw_pre[k] = v->NumberOfCursors[k]
2543 					* v->CursorWidth[k][0] * v->CursorBPP[k][0]
2544 					/ 8.0
2545 					/ (v->HTotal[k] / v->PixelClock[k])
2546 					* v->VRatioPrefetchY[k];
2547 
2548 			CalculateUrgentBurstFactor(
2549 					v->swath_width_luma_ub[k],
2550 					v->swath_width_chroma_ub[k],
2551 					v->DETBufferSizeInKByte[0],
2552 					v->SwathHeightY[k],
2553 					v->SwathHeightC[k],
2554 					v->HTotal[k] / v->PixelClock[k],
2555 					v->UrgentLatency,
2556 					v->CursorBufferSize,
2557 					v->CursorWidth[k][0],
2558 					v->CursorBPP[k][0],
2559 					v->VRatio[k],
2560 					v->VRatioChroma[k],
2561 					v->BytePerPixelDETY[k],
2562 					v->BytePerPixelDETC[k],
2563 					v->DETBufferSizeY[k],
2564 					v->DETBufferSizeC[k],
2565 					&v->UrgentBurstFactorCursor[k],
2566 					&v->UrgentBurstFactorLuma[k],
2567 					&v->UrgentBurstFactorChroma[k],
2568 					&v->NoUrgentLatencyHiding[k]);
2569 
2570 			CalculateUrgentBurstFactor(
2571 					v->swath_width_luma_ub[k],
2572 					v->swath_width_chroma_ub[k],
2573 					v->DETBufferSizeInKByte[0],
2574 					v->SwathHeightY[k],
2575 					v->SwathHeightC[k],
2576 					v->HTotal[k] / v->PixelClock[k],
2577 					v->UrgentLatency,
2578 					v->CursorBufferSize,
2579 					v->CursorWidth[k][0],
2580 					v->CursorBPP[k][0],
2581 					v->VRatioPrefetchY[k],
2582 					v->VRatioPrefetchC[k],
2583 					v->BytePerPixelDETY[k],
2584 					v->BytePerPixelDETC[k],
2585 					v->DETBufferSizeY[k],
2586 					v->DETBufferSizeC[k],
2587 					&v->UrgentBurstFactorCursorPre[k],
2588 					&v->UrgentBurstFactorLumaPre[k],
2589 					&v->UrgentBurstFactorChromaPre[k],
2590 					&v->NoUrgentLatencyHidingPre[k]);
2591 
2592 			MaxTotalRDBandwidth = MaxTotalRDBandwidth +
2593 				dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2594 					v->ReadBandwidthPlaneLuma[k] *
2595 					v->UrgentBurstFactorLuma[k] +
2596 					v->ReadBandwidthPlaneChroma[k] *
2597 					v->UrgentBurstFactorChroma[k] +
2598 					v->cursor_bw[k] *
2599 					v->UrgentBurstFactorCursor[k] +
2600 					v->DPPPerPlane[k] * (v->meta_row_bw[k] + v->dpte_row_bw[k]),
2601 					v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2602 						v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) + v->cursor_bw_pre[k] *
2603 					v->UrgentBurstFactorCursorPre[k]);
2604 
2605 			MaxTotalRDBandwidthNoUrgentBurst = MaxTotalRDBandwidthNoUrgentBurst +
2606 				dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2607 					v->ReadBandwidthPlaneLuma[k] +
2608 					v->ReadBandwidthPlaneChroma[k] +
2609 					v->cursor_bw[k] +
2610 					v->DPPPerPlane[k] * (v->meta_row_bw[k] + v->dpte_row_bw[k]),
2611 					v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] + v->RequiredPrefetchPixDataBWChroma[k]) + v->cursor_bw_pre[k]);
2612 
2613 			if (v->DestinationLinesForPrefetch[k] < 2)
2614 				DestinationLineTimesForPrefetchLessThan2 = true;
2615 			if (v->VRatioPrefetchY[k] > 4 || v->VRatioPrefetchC[k] > 4)
2616 				VRatioPrefetchMoreThan4 = true;
2617 			if (v->NoUrgentLatencyHiding[k] == true)
2618 				v->NotEnoughUrgentLatencyHiding[0][0] = true;
2619 
2620 			if (v->NoUrgentLatencyHidingPre[k] == true)
2621 				v->NotEnoughUrgentLatencyHidingPre = true;
2622 		}
2623 		v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / v->ReturnBW;
2624 
2625 
2626 		if (MaxTotalRDBandwidth <= v->ReturnBW && v->NotEnoughUrgentLatencyHiding[0][0] == 0
2627 				&& v->NotEnoughUrgentLatencyHidingPre == 0 && !VRatioPrefetchMoreThan4
2628 				&& !DestinationLineTimesForPrefetchLessThan2)
2629 			v->PrefetchModeSupported = true;
2630 		else {
2631 			v->PrefetchModeSupported = false;
2632 			dml_print("DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n");
2633 			dml_print("DML: MaxTotalRDBandwidth:%f AvailReturnBandwidth:%f\n", MaxTotalRDBandwidth, v->ReturnBW);
2634 			dml_print("DML: VRatioPrefetch %s more than 4\n", (VRatioPrefetchMoreThan4) ? "is" : "is not");
2635 			dml_print("DML: DestinationLines for Prefetch %s less than 2\n", (DestinationLineTimesForPrefetchLessThan2) ? "is" : "is not");
2636 		}
2637 
2638 		if (v->PrefetchModeSupported == true && v->ImmediateFlipSupport == true) {
2639 			v->BandwidthAvailableForImmediateFlip = v->ReturnBW;
2640 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2641 				v->BandwidthAvailableForImmediateFlip =
2642 						v->BandwidthAvailableForImmediateFlip
2643 								- dml_max(
2644 										v->ReadBandwidthPlaneLuma[k] * v->UrgentBurstFactorLuma[k]
2645 												+ v->ReadBandwidthPlaneChroma[k] * v->UrgentBurstFactorChroma[k]
2646 												+ v->cursor_bw[k] * v->UrgentBurstFactorCursor[k],
2647 										v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2648 										v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) +
2649 										v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
2650 			}
2651 
2652 			v->TotImmediateFlipBytes = 0;
2653 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2654 				v->TotImmediateFlipBytes = v->TotImmediateFlipBytes + v->DPPPerPlane[k] * (v->PDEAndMetaPTEBytesFrame[k] + v->MetaRowByte[k] + v->PixelPTEBytesPerRow[k]);
2655 			}
2656 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2657 				CalculateFlipSchedule(
2658 						mode_lib,
2659 						v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2660 						v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2661 						v->UrgentExtraLatency,
2662 						v->UrgentLatency,
2663 						v->GPUVMMaxPageTableLevels,
2664 						v->HostVMEnable,
2665 						v->HostVMMaxNonCachedPageTableLevels,
2666 						v->GPUVMEnable,
2667 						v->HostVMMinPageSize,
2668 						v->PDEAndMetaPTEBytesFrame[k],
2669 						v->MetaRowByte[k],
2670 						v->PixelPTEBytesPerRow[k],
2671 						v->BandwidthAvailableForImmediateFlip,
2672 						v->TotImmediateFlipBytes,
2673 						v->SourcePixelFormat[k],
2674 						v->HTotal[k] / v->PixelClock[k],
2675 						v->VRatio[k],
2676 						v->VRatioChroma[k],
2677 						v->Tno_bw[k],
2678 						v->DCCEnable[k],
2679 						v->dpte_row_height[k],
2680 						v->meta_row_height[k],
2681 						v->dpte_row_height_chroma[k],
2682 						v->meta_row_height_chroma[k],
2683 						&v->DestinationLinesToRequestVMInImmediateFlip[k],
2684 						&v->DestinationLinesToRequestRowInImmediateFlip[k],
2685 						&v->final_flip_bw[k],
2686 						&v->ImmediateFlipSupportedForPipe[k]);
2687 			}
2688 			v->total_dcn_read_bw_with_flip = 0.0;
2689 			v->total_dcn_read_bw_with_flip_no_urgent_burst = 0.0;
2690 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2691 				v->total_dcn_read_bw_with_flip = v->total_dcn_read_bw_with_flip + dml_max3(
2692 					v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2693 					v->DPPPerPlane[k] * v->final_flip_bw[k] +
2694 					v->ReadBandwidthLuma[k] * v->UrgentBurstFactorLuma[k] +
2695 					v->ReadBandwidthChroma[k] * v->UrgentBurstFactorChroma[k] +
2696 					v->cursor_bw[k] * v->UrgentBurstFactorCursor[k],
2697 					v->DPPPerPlane[k] * (v->final_flip_bw[k] +
2698 					v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2699 					v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) +
2700 					v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
2701 				v->total_dcn_read_bw_with_flip_no_urgent_burst =
2702 					v->total_dcn_read_bw_with_flip_no_urgent_burst +
2703 						dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2704 							v->DPPPerPlane[k] * v->final_flip_bw[k] + v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k] + v->cursor_bw[k],
2705 							v->DPPPerPlane[k] * (v->final_flip_bw[k] + v->RequiredPrefetchPixDataBWLuma[k] + v->RequiredPrefetchPixDataBWChroma[k]) + v->cursor_bw_pre[k]);
2706 
2707 			}
2708 			v->FractionOfUrgentBandwidthImmediateFlip = v->total_dcn_read_bw_with_flip_no_urgent_burst / v->ReturnBW;
2709 
2710 			v->ImmediateFlipSupported = true;
2711 			if (v->total_dcn_read_bw_with_flip > v->ReturnBW) {
2712 				v->ImmediateFlipSupported = false;
2713 				v->total_dcn_read_bw_with_flip = MaxTotalRDBandwidth;
2714 			}
2715 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2716 				if (v->ImmediateFlipSupportedForPipe[k] == false) {
2717 					v->ImmediateFlipSupported = false;
2718 				}
2719 			}
2720 		} else {
2721 			v->ImmediateFlipSupported = false;
2722 		}
2723 
2724 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2725 			if (v->ErrorResult[k] || v->NotEnoughTimeForDynamicMetadata[k]) {
2726 				v->PrefetchModeSupported = false;
2727 				dml_print("DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n");
2728 			}
2729 		}
2730 
2731 		v->VStartupLines = v->VStartupLines + 1;
2732 		v->PrefetchModeSupported = (v->PrefetchModeSupported == true && ((!v->ImmediateFlipSupport &&
2733 				!v->HostVMEnable && v->ImmediateFlipRequirement[0] != dm_immediate_flip_required) ||
2734 				v->ImmediateFlipSupported)) ? true : false;
2735 	} while (!v->PrefetchModeSupported && v->VStartupLines <= v->MaximumMaxVStartupLines);
2736 	ASSERT(v->PrefetchModeSupported);
2737 
2738 	//Watermarks and NB P-State/DRAM Clock Change Support
2739 	{
2740 		enum clock_change_support   DRAMClockChangeSupport = 0; // dummy
2741 		CalculateWatermarksAndDRAMSpeedChangeSupport(
2742 			mode_lib,
2743 			PrefetchMode,
2744 			v->NumberOfActivePlanes,
2745 			v->MaxLineBufferLines,
2746 			v->LineBufferSize,
2747 			v->DPPOutputBufferPixels,
2748 			v->DETBufferSizeInKByte[0],
2749 			v->WritebackInterfaceBufferSize,
2750 			v->DCFCLK,
2751 			v->ReturnBW,
2752 			v->GPUVMEnable,
2753 			v->dpte_group_bytes,
2754 			v->MetaChunkSize,
2755 			v->UrgentLatency,
2756 			v->UrgentExtraLatency,
2757 			v->WritebackLatency,
2758 			v->WritebackChunkSize,
2759 			v->SOCCLK,
2760 			v->FinalDRAMClockChangeLatency,
2761 			v->SRExitTime,
2762 			v->SREnterPlusExitTime,
2763 			v->DCFCLKDeepSleep,
2764 			v->DPPPerPlane,
2765 			v->DCCEnable,
2766 			v->DPPCLK,
2767 			v->DETBufferSizeY,
2768 			v->DETBufferSizeC,
2769 			v->SwathHeightY,
2770 			v->SwathHeightC,
2771 			v->LBBitPerPixel,
2772 			v->SwathWidthY,
2773 			v->SwathWidthC,
2774 			v->HRatio,
2775 			v->HRatioChroma,
2776 			v->vtaps,
2777 			v->VTAPsChroma,
2778 			v->VRatio,
2779 			v->VRatioChroma,
2780 			v->HTotal,
2781 			v->PixelClock,
2782 			v->BlendingAndTiming,
2783 			v->BytePerPixelDETY,
2784 			v->BytePerPixelDETC,
2785 			v->DSTXAfterScaler,
2786 			v->DSTYAfterScaler,
2787 			v->WritebackEnable,
2788 			v->WritebackPixelFormat,
2789 			v->WritebackDestinationWidth,
2790 			v->WritebackDestinationHeight,
2791 			v->WritebackSourceHeight,
2792 			&DRAMClockChangeSupport,
2793 			&v->UrgentWatermark,
2794 			&v->WritebackUrgentWatermark,
2795 			&v->DRAMClockChangeWatermark,
2796 			&v->WritebackDRAMClockChangeWatermark,
2797 			&v->StutterExitWatermark,
2798 			&v->StutterEnterPlusExitWatermark,
2799 			&v->MinActiveDRAMClockChangeLatencySupported);
2800 
2801 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2802 			if (v->WritebackEnable[k] == true) {
2803 				if (v->BlendingAndTiming[k] == k) {
2804 					v->ThisVStartup = v->VStartup[k];
2805 				} else {
2806 					for (j = 0; j < v->NumberOfActivePlanes; ++j) {
2807 						if (v->BlendingAndTiming[k] == j) {
2808 							v->ThisVStartup = v->VStartup[j];
2809 						}
2810 					}
2811 				}
2812 				v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
2813 					v->ThisVStartup * v->HTotal[k] / v->PixelClock[k] - v->WritebackDRAMClockChangeWatermark);
2814 			} else {
2815 				v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
2816 			}
2817 		}
2818 
2819 	}
2820 
2821 
2822 	//Display Pipeline Delivery Time in Prefetch, Groups
2823 	CalculatePixelDeliveryTimes(
2824 			v->NumberOfActivePlanes,
2825 			v->VRatio,
2826 			v->VRatioChroma,
2827 			v->VRatioPrefetchY,
2828 			v->VRatioPrefetchC,
2829 			v->swath_width_luma_ub,
2830 			v->swath_width_chroma_ub,
2831 			v->DPPPerPlane,
2832 			v->HRatio,
2833 			v->HRatioChroma,
2834 			v->PixelClock,
2835 			v->PSCL_THROUGHPUT_LUMA,
2836 			v->PSCL_THROUGHPUT_CHROMA,
2837 			v->DPPCLK,
2838 			v->BytePerPixelC,
2839 			v->SourceScan,
2840 			v->NumberOfCursors,
2841 			v->CursorWidth,
2842 			v->CursorBPP,
2843 			v->BlockWidth256BytesY,
2844 			v->BlockHeight256BytesY,
2845 			v->BlockWidth256BytesC,
2846 			v->BlockHeight256BytesC,
2847 			v->DisplayPipeLineDeliveryTimeLuma,
2848 			v->DisplayPipeLineDeliveryTimeChroma,
2849 			v->DisplayPipeLineDeliveryTimeLumaPrefetch,
2850 			v->DisplayPipeLineDeliveryTimeChromaPrefetch,
2851 			v->DisplayPipeRequestDeliveryTimeLuma,
2852 			v->DisplayPipeRequestDeliveryTimeChroma,
2853 			v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
2854 			v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
2855 			v->CursorRequestDeliveryTime,
2856 			v->CursorRequestDeliveryTimePrefetch);
2857 
2858 	CalculateMetaAndPTETimes(
2859 			v->NumberOfActivePlanes,
2860 			v->GPUVMEnable,
2861 			v->MetaChunkSize,
2862 			v->MinMetaChunkSizeBytes,
2863 			v->HTotal,
2864 			v->VRatio,
2865 			v->VRatioChroma,
2866 			v->DestinationLinesToRequestRowInVBlank,
2867 			v->DestinationLinesToRequestRowInImmediateFlip,
2868 			v->DCCEnable,
2869 			v->PixelClock,
2870 			v->BytePerPixelY,
2871 			v->BytePerPixelC,
2872 			v->SourceScan,
2873 			v->dpte_row_height,
2874 			v->dpte_row_height_chroma,
2875 			v->meta_row_width,
2876 			v->meta_row_width_chroma,
2877 			v->meta_row_height,
2878 			v->meta_row_height_chroma,
2879 			v->meta_req_width,
2880 			v->meta_req_width_chroma,
2881 			v->meta_req_height,
2882 			v->meta_req_height_chroma,
2883 			v->dpte_group_bytes,
2884 			v->PTERequestSizeY,
2885 			v->PTERequestSizeC,
2886 			v->PixelPTEReqWidthY,
2887 			v->PixelPTEReqHeightY,
2888 			v->PixelPTEReqWidthC,
2889 			v->PixelPTEReqHeightC,
2890 			v->dpte_row_width_luma_ub,
2891 			v->dpte_row_width_chroma_ub,
2892 			v->DST_Y_PER_PTE_ROW_NOM_L,
2893 			v->DST_Y_PER_PTE_ROW_NOM_C,
2894 			v->DST_Y_PER_META_ROW_NOM_L,
2895 			v->DST_Y_PER_META_ROW_NOM_C,
2896 			v->TimePerMetaChunkNominal,
2897 			v->TimePerChromaMetaChunkNominal,
2898 			v->TimePerMetaChunkVBlank,
2899 			v->TimePerChromaMetaChunkVBlank,
2900 			v->TimePerMetaChunkFlip,
2901 			v->TimePerChromaMetaChunkFlip,
2902 			v->time_per_pte_group_nom_luma,
2903 			v->time_per_pte_group_vblank_luma,
2904 			v->time_per_pte_group_flip_luma,
2905 			v->time_per_pte_group_nom_chroma,
2906 			v->time_per_pte_group_vblank_chroma,
2907 			v->time_per_pte_group_flip_chroma);
2908 
2909 	CalculateVMGroupAndRequestTimes(
2910 			v->NumberOfActivePlanes,
2911 			v->GPUVMEnable,
2912 			v->GPUVMMaxPageTableLevels,
2913 			v->HTotal,
2914 			v->BytePerPixelC,
2915 			v->DestinationLinesToRequestVMInVBlank,
2916 			v->DestinationLinesToRequestVMInImmediateFlip,
2917 			v->DCCEnable,
2918 			v->PixelClock,
2919 			v->dpte_row_width_luma_ub,
2920 			v->dpte_row_width_chroma_ub,
2921 			v->vm_group_bytes,
2922 			v->dpde0_bytes_per_frame_ub_l,
2923 			v->dpde0_bytes_per_frame_ub_c,
2924 			v->meta_pte_bytes_per_frame_ub_l,
2925 			v->meta_pte_bytes_per_frame_ub_c,
2926 			v->TimePerVMGroupVBlank,
2927 			v->TimePerVMGroupFlip,
2928 			v->TimePerVMRequestVBlank,
2929 			v->TimePerVMRequestFlip);
2930 
2931 
2932 	// Min TTUVBlank
2933 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2934 		if (PrefetchMode == 0) {
2935 			v->AllowDRAMClockChangeDuringVBlank[k] = true;
2936 			v->AllowDRAMSelfRefreshDuringVBlank[k] = true;
2937 			v->MinTTUVBlank[k] = dml_max(
2938 					v->DRAMClockChangeWatermark,
2939 					dml_max(
2940 							v->StutterEnterPlusExitWatermark,
2941 							v->UrgentWatermark));
2942 		} else if (PrefetchMode == 1) {
2943 			v->AllowDRAMClockChangeDuringVBlank[k] = false;
2944 			v->AllowDRAMSelfRefreshDuringVBlank[k] = true;
2945 			v->MinTTUVBlank[k] = dml_max(
2946 					v->StutterEnterPlusExitWatermark,
2947 					v->UrgentWatermark);
2948 		} else {
2949 			v->AllowDRAMClockChangeDuringVBlank[k] = false;
2950 			v->AllowDRAMSelfRefreshDuringVBlank[k] = false;
2951 			v->MinTTUVBlank[k] = v->UrgentWatermark;
2952 		}
2953 		if (!v->DynamicMetadataEnable[k])
2954 			v->MinTTUVBlank[k] = v->TCalc
2955 					+ v->MinTTUVBlank[k];
2956 	}
2957 
2958 	// DCC Configuration
2959 	v->ActiveDPPs = 0;
2960 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2961 		CalculateDCCConfiguration(v->DCCEnable[k], false, // We should always know the direction DCCProgrammingAssumesScanDirectionUnknown,
2962 				v->SourcePixelFormat[k],
2963 				v->SurfaceWidthY[k],
2964 				v->SurfaceWidthC[k],
2965 				v->SurfaceHeightY[k],
2966 				v->SurfaceHeightC[k],
2967 				v->DETBufferSizeInKByte[0] * 1024,
2968 				v->BlockHeight256BytesY[k],
2969 				v->BlockHeight256BytesC[k],
2970 				v->SurfaceTiling[k],
2971 				v->BytePerPixelY[k],
2972 				v->BytePerPixelC[k],
2973 				v->BytePerPixelDETY[k],
2974 				v->BytePerPixelDETC[k],
2975 				v->SourceScan[k],
2976 				&v->DCCYMaxUncompressedBlock[k],
2977 				&v->DCCCMaxUncompressedBlock[k],
2978 				&v->DCCYMaxCompressedBlock[k],
2979 				&v->DCCCMaxCompressedBlock[k],
2980 				&v->DCCYIndependentBlock[k],
2981 				&v->DCCCIndependentBlock[k]);
2982 	}
2983 
2984 	{
2985 		//Maximum Bandwidth Used
2986 		v->TotalDataReadBandwidth = 0;
2987 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2988 			v->TotalDataReadBandwidth = v->TotalDataReadBandwidth
2989 					+ v->ReadBandwidthPlaneLuma[k]
2990 					+ v->ReadBandwidthPlaneChroma[k];
2991 		}
2992 	}
2993 
2994 	// VStartup Margin
2995 	v->VStartupMargin = 0;
2996 	v->FirstMainPlane = true;
2997 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2998 		if (v->BlendingAndTiming[k] == k) {
2999 			double margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * v->HTotal[k]
3000 					/ v->PixelClock[k];
3001 			if (v->FirstMainPlane == true) {
3002 				v->VStartupMargin = margin;
3003 				v->FirstMainPlane = false;
3004 			} else {
3005 				v->VStartupMargin = dml_min(v->VStartupMargin, margin);
3006 			}
3007 		}
3008 	}
3009 
3010 	// Stutter Efficiency
3011 	CalculateStutterEfficiency(
3012 			v->NumberOfActivePlanes,
3013 			v->ROBBufferSizeInKByte,
3014 			v->TotalDataReadBandwidth,
3015 			v->DCFCLK,
3016 			v->ReturnBW,
3017 			v->SRExitTime,
3018 			v->SynchronizedVBlank,
3019 			v->DPPPerPlane,
3020 			v->DETBufferSizeY,
3021 			v->BytePerPixelY,
3022 			v->BytePerPixelDETY,
3023 			v->SwathWidthY,
3024 			v->SwathHeightY,
3025 			v->SwathHeightC,
3026 			v->DCCRateLuma,
3027 			v->DCCRateChroma,
3028 			v->HTotal,
3029 			v->VTotal,
3030 			v->PixelClock,
3031 			v->VRatio,
3032 			v->SourceScan,
3033 			v->BlockHeight256BytesY,
3034 			v->BlockWidth256BytesY,
3035 			v->BlockHeight256BytesC,
3036 			v->BlockWidth256BytesC,
3037 			v->DCCYMaxUncompressedBlock,
3038 			v->DCCCMaxUncompressedBlock,
3039 			v->VActive,
3040 			v->DCCEnable,
3041 			v->WritebackEnable,
3042 			v->ReadBandwidthPlaneLuma,
3043 			v->ReadBandwidthPlaneChroma,
3044 			v->meta_row_bw,
3045 			v->dpte_row_bw,
3046 			&v->StutterEfficiencyNotIncludingVBlank,
3047 			&v->StutterEfficiency,
3048 			&v->StutterPeriod);
3049 }
3050 
DisplayPipeConfiguration(struct display_mode_lib * mode_lib)3051 static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib)
3052 {
3053 	// Display Pipe Configuration
3054 	double BytePerPixDETY[DC__NUM_DPP__MAX] = { 0 };
3055 	double BytePerPixDETC[DC__NUM_DPP__MAX] = { 0 };
3056 	int BytePerPixY[DC__NUM_DPP__MAX] = { 0 };
3057 	int BytePerPixC[DC__NUM_DPP__MAX] = { 0 };
3058 	int Read256BytesBlockHeightY[DC__NUM_DPP__MAX] = { 0 };
3059 	int Read256BytesBlockHeightC[DC__NUM_DPP__MAX] = { 0 };
3060 	int Read256BytesBlockWidthY[DC__NUM_DPP__MAX] = { 0 };
3061 	int Read256BytesBlockWidthC[DC__NUM_DPP__MAX] = { 0 };
3062 	double dummy1[DC__NUM_DPP__MAX] = { 0 };
3063 	double dummy2[DC__NUM_DPP__MAX] = { 0 };
3064 	double dummy3[DC__NUM_DPP__MAX] = { 0 };
3065 	double dummy4[DC__NUM_DPP__MAX] = { 0 };
3066 	int dummy5[DC__NUM_DPP__MAX] = { 0 };
3067 	int dummy6[DC__NUM_DPP__MAX] = { 0 };
3068 	bool dummy7[DC__NUM_DPP__MAX] = { 0 };
3069 	bool dummysinglestring = 0;
3070 	unsigned int k;
3071 
3072 	for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
3073 
3074 		dml30_CalculateBytePerPixelAnd256BBlockSizes(
3075 				mode_lib->vba.SourcePixelFormat[k],
3076 				mode_lib->vba.SurfaceTiling[k],
3077 				&BytePerPixY[k],
3078 				&BytePerPixC[k],
3079 				&BytePerPixDETY[k],
3080 				&BytePerPixDETC[k],
3081 				&Read256BytesBlockHeightY[k],
3082 				&Read256BytesBlockHeightC[k],
3083 				&Read256BytesBlockWidthY[k],
3084 				&Read256BytesBlockWidthC[k]);
3085 	}
3086 	CalculateSwathAndDETConfiguration(
3087 			false,
3088 			mode_lib->vba.NumberOfActivePlanes,
3089 			mode_lib->vba.DETBufferSizeInKByte[0],
3090 			dummy1,
3091 			dummy2,
3092 			mode_lib->vba.SourceScan,
3093 			mode_lib->vba.SourcePixelFormat,
3094 			mode_lib->vba.SurfaceTiling,
3095 			mode_lib->vba.ViewportWidth,
3096 			mode_lib->vba.ViewportHeight,
3097 			mode_lib->vba.SurfaceWidthY,
3098 			mode_lib->vba.SurfaceWidthC,
3099 			mode_lib->vba.SurfaceHeightY,
3100 			mode_lib->vba.SurfaceHeightC,
3101 			Read256BytesBlockHeightY,
3102 			Read256BytesBlockHeightC,
3103 			Read256BytesBlockWidthY,
3104 			Read256BytesBlockWidthC,
3105 			mode_lib->vba.ODMCombineEnabled,
3106 			mode_lib->vba.BlendingAndTiming,
3107 			BytePerPixY,
3108 			BytePerPixC,
3109 			BytePerPixDETY,
3110 			BytePerPixDETC,
3111 			mode_lib->vba.HActive,
3112 			mode_lib->vba.HRatio,
3113 			mode_lib->vba.HRatioChroma,
3114 			mode_lib->vba.DPPPerPlane,
3115 			dummy5,
3116 			dummy6,
3117 			dummy3,
3118 			dummy4,
3119 			mode_lib->vba.SwathHeightY,
3120 			mode_lib->vba.SwathHeightC,
3121 			mode_lib->vba.DETBufferSizeY,
3122 			mode_lib->vba.DETBufferSizeC,
3123 			dummy7,
3124 			&dummysinglestring);
3125 }
3126 
dml30_CalculateBytePerPixelAnd256BBlockSizes(enum source_format_class SourcePixelFormat,enum dm_swizzle_mode SurfaceTiling,unsigned int * BytePerPixelY,unsigned int * BytePerPixelC,double * BytePerPixelDETY,double * BytePerPixelDETC,unsigned int * BlockHeight256BytesY,unsigned int * BlockHeight256BytesC,unsigned int * BlockWidth256BytesY,unsigned int * BlockWidth256BytesC)3127 void dml30_CalculateBytePerPixelAnd256BBlockSizes(
3128 		enum source_format_class SourcePixelFormat,
3129 		enum dm_swizzle_mode SurfaceTiling,
3130 		unsigned int *BytePerPixelY,
3131 		unsigned int *BytePerPixelC,
3132 		double       *BytePerPixelDETY,
3133 		double       *BytePerPixelDETC,
3134 		unsigned int *BlockHeight256BytesY,
3135 		unsigned int *BlockHeight256BytesC,
3136 		unsigned int *BlockWidth256BytesY,
3137 		unsigned int *BlockWidth256BytesC)
3138 {
3139 	if (SourcePixelFormat == dm_444_64) {
3140 		*BytePerPixelDETY = 8;
3141 		*BytePerPixelDETC = 0;
3142 		*BytePerPixelY = 8;
3143 		*BytePerPixelC = 0;
3144 	} else if (SourcePixelFormat == dm_444_32 || SourcePixelFormat == dm_rgbe) {
3145 		*BytePerPixelDETY = 4;
3146 		*BytePerPixelDETC = 0;
3147 		*BytePerPixelY = 4;
3148 		*BytePerPixelC = 0;
3149 	} else if (SourcePixelFormat == dm_444_16) {
3150 		*BytePerPixelDETY = 2;
3151 		*BytePerPixelDETC = 0;
3152 		*BytePerPixelY = 2;
3153 		*BytePerPixelC = 0;
3154 	} else if (SourcePixelFormat == dm_444_8) {
3155 		*BytePerPixelDETY = 1;
3156 		*BytePerPixelDETC = 0;
3157 		*BytePerPixelY = 1;
3158 		*BytePerPixelC = 0;
3159 	} else if (SourcePixelFormat == dm_rgbe_alpha) {
3160 		*BytePerPixelDETY = 4;
3161 		*BytePerPixelDETC = 1;
3162 		*BytePerPixelY = 4;
3163 		*BytePerPixelC = 1;
3164 	} else if (SourcePixelFormat == dm_420_8) {
3165 		*BytePerPixelDETY = 1;
3166 		*BytePerPixelDETC = 2;
3167 		*BytePerPixelY = 1;
3168 		*BytePerPixelC = 2;
3169 	} else if (SourcePixelFormat == dm_420_12) {
3170 		*BytePerPixelDETY = 2;
3171 		*BytePerPixelDETC = 4;
3172 		*BytePerPixelY = 2;
3173 		*BytePerPixelC = 4;
3174 	} else {
3175 		*BytePerPixelDETY = 4.0 / 3;
3176 		*BytePerPixelDETC = 8.0 / 3;
3177 		*BytePerPixelY = 2;
3178 		*BytePerPixelC = 4;
3179 	}
3180 
3181 	if ((SourcePixelFormat == dm_444_64 || SourcePixelFormat == dm_444_32
3182 			|| SourcePixelFormat == dm_444_16 || SourcePixelFormat == dm_444_8
3183 			|| SourcePixelFormat == dm_mono_16 || SourcePixelFormat == dm_mono_8
3184 			|| SourcePixelFormat == dm_rgbe)) {
3185 		if (SurfaceTiling == dm_sw_linear) {
3186 			*BlockHeight256BytesY = 1;
3187 		} else if (SourcePixelFormat == dm_444_64) {
3188 			*BlockHeight256BytesY = 4;
3189 		} else if (SourcePixelFormat == dm_444_8) {
3190 			*BlockHeight256BytesY = 16;
3191 		} else {
3192 			*BlockHeight256BytesY = 8;
3193 		}
3194 		*BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
3195 		*BlockHeight256BytesC = 0;
3196 		*BlockWidth256BytesC = 0;
3197 	} else {
3198 		if (SurfaceTiling == dm_sw_linear) {
3199 			*BlockHeight256BytesY = 1;
3200 			*BlockHeight256BytesC = 1;
3201 		} else if (SourcePixelFormat == dm_rgbe_alpha) {
3202 			*BlockHeight256BytesY = 8;
3203 			*BlockHeight256BytesC = 16;
3204 		} else if (SourcePixelFormat == dm_420_8) {
3205 			*BlockHeight256BytesY = 16;
3206 			*BlockHeight256BytesC = 8;
3207 		} else {
3208 			*BlockHeight256BytesY = 8;
3209 			*BlockHeight256BytesC = 8;
3210 		}
3211 		*BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
3212 		*BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC;
3213 	}
3214 }
3215 
CalculateTWait(unsigned int PrefetchMode,double DRAMClockChangeLatency,double UrgentLatency,double SREnterPlusExitTime)3216 static double CalculateTWait(
3217 		unsigned int PrefetchMode,
3218 		double DRAMClockChangeLatency,
3219 		double UrgentLatency,
3220 		double SREnterPlusExitTime)
3221 {
3222 	if (PrefetchMode == 0) {
3223 		return dml_max(DRAMClockChangeLatency + UrgentLatency,
3224 				dml_max(SREnterPlusExitTime, UrgentLatency));
3225 	} else if (PrefetchMode == 1) {
3226 		return dml_max(SREnterPlusExitTime, UrgentLatency);
3227 	} else {
3228 		return UrgentLatency;
3229 	}
3230 }
3231 
dml30_CalculateWriteBackDISPCLK(enum source_format_class WritebackPixelFormat,double PixelClock,double WritebackHRatio,double WritebackVRatio,unsigned int WritebackHTaps,unsigned int WritebackVTaps,long WritebackSourceWidth,long WritebackDestinationWidth,unsigned int HTotal,unsigned int WritebackLineBufferSize)3232 double dml30_CalculateWriteBackDISPCLK(
3233 		enum source_format_class WritebackPixelFormat,
3234 		double PixelClock,
3235 		double WritebackHRatio,
3236 		double WritebackVRatio,
3237 		unsigned int WritebackHTaps,
3238 		unsigned int WritebackVTaps,
3239 		long   WritebackSourceWidth,
3240 		long   WritebackDestinationWidth,
3241 		unsigned int HTotal,
3242 		unsigned int WritebackLineBufferSize)
3243 {
3244 	double DISPCLK_H = 0, DISPCLK_V = 0, DISPCLK_HB = 0;
3245 
3246 	DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio;
3247 	DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / HTotal;
3248 	DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / WritebackSourceWidth;
3249 	return dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB);
3250 }
3251 
CalculateWriteBackDelay(enum source_format_class WritebackPixelFormat,double WritebackHRatio,double WritebackVRatio,unsigned int WritebackVTaps,long WritebackDestinationWidth,long WritebackDestinationHeight,long WritebackSourceHeight,unsigned int HTotal)3252 static double CalculateWriteBackDelay(
3253 		enum source_format_class WritebackPixelFormat,
3254 		double WritebackHRatio,
3255 		double WritebackVRatio,
3256 		unsigned int WritebackVTaps,
3257 		long         WritebackDestinationWidth,
3258 		long         WritebackDestinationHeight,
3259 		long         WritebackSourceHeight,
3260 		unsigned int HTotal)
3261 {
3262 	double CalculateWriteBackDelay = 0;
3263 	double Line_length = 0;
3264 	double Output_lines_last_notclamped = 0;
3265 	double WritebackVInit = 0;
3266 
3267 	WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2;
3268 	Line_length = dml_max((double) WritebackDestinationWidth, dml_ceil(WritebackDestinationWidth / 6.0, 1) * WritebackVTaps);
3269 	Output_lines_last_notclamped = WritebackDestinationHeight - 1 - dml_ceil((WritebackSourceHeight - WritebackVInit) / WritebackVRatio, 1);
3270 	if (Output_lines_last_notclamped < 0) {
3271 		CalculateWriteBackDelay = 0;
3272 	} else {
3273 		CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length + (HTotal - WritebackDestinationWidth) + 80;
3274 	}
3275 	return CalculateWriteBackDelay;
3276 }
3277 
3278 
CalculateDynamicMetadataParameters(int MaxInterDCNTileRepeaters,double DPPCLK,double DISPCLK,double DCFClkDeepSleep,double PixelClock,long HTotal,long VBlank,long DynamicMetadataTransmittedBytes,long DynamicMetadataLinesBeforeActiveRequired,int InterlaceEnable,bool ProgressiveToInterlaceUnitInOPP,double * Tsetup,double * Tdmbf,double * Tdmec,double * Tdmsks)3279 static void CalculateDynamicMetadataParameters(int MaxInterDCNTileRepeaters, double DPPCLK, double DISPCLK,
3280 		double DCFClkDeepSleep, double PixelClock, long HTotal, long VBlank, long DynamicMetadataTransmittedBytes,
3281 		long DynamicMetadataLinesBeforeActiveRequired, int InterlaceEnable, bool ProgressiveToInterlaceUnitInOPP,
3282 		double *Tsetup, double *Tdmbf, double *Tdmec, double *Tdmsks)
3283 {
3284 	double TotalRepeaterDelayTime = 0;
3285 	double VUpdateWidthPix = 0;
3286 	double VReadyOffsetPix = 0;
3287 	double VUpdateOffsetPix = 0;
3288 	TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / DPPCLK + 3 / DISPCLK);
3289 	VUpdateWidthPix = (14 / DCFClkDeepSleep + 12 / DPPCLK + TotalRepeaterDelayTime) * PixelClock;
3290 	VReadyOffsetPix = dml_max(150.0 / DPPCLK, TotalRepeaterDelayTime + 20 / DCFClkDeepSleep + 10 / DPPCLK) * PixelClock;
3291 	VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1);
3292 	*Tsetup = (VUpdateOffsetPix + VUpdateWidthPix + VReadyOffsetPix) / PixelClock;
3293 	*Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / DISPCLK;
3294 	*Tdmec = HTotal / PixelClock;
3295 	if (DynamicMetadataLinesBeforeActiveRequired == 0) {
3296 		*Tdmsks = VBlank * HTotal / PixelClock / 2.0;
3297 	} else {
3298 		*Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock;
3299 	}
3300 	if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false) {
3301 		*Tdmsks = *Tdmsks / 2;
3302 	}
3303 }
3304 
CalculateRowBandwidth(bool GPUVMEnable,enum source_format_class SourcePixelFormat,double VRatio,double VRatioChroma,bool DCCEnable,double LineTime,unsigned int MetaRowByteLuma,unsigned int MetaRowByteChroma,unsigned int meta_row_height_luma,unsigned int meta_row_height_chroma,unsigned int PixelPTEBytesPerRowLuma,unsigned int PixelPTEBytesPerRowChroma,unsigned int dpte_row_height_luma,unsigned int dpte_row_height_chroma,double * meta_row_bw,double * dpte_row_bw)3305 static void CalculateRowBandwidth(
3306 		bool GPUVMEnable,
3307 		enum source_format_class SourcePixelFormat,
3308 		double VRatio,
3309 		double VRatioChroma,
3310 		bool DCCEnable,
3311 		double LineTime,
3312 		unsigned int MetaRowByteLuma,
3313 		unsigned int MetaRowByteChroma,
3314 		unsigned int meta_row_height_luma,
3315 		unsigned int meta_row_height_chroma,
3316 		unsigned int PixelPTEBytesPerRowLuma,
3317 		unsigned int PixelPTEBytesPerRowChroma,
3318 		unsigned int dpte_row_height_luma,
3319 		unsigned int dpte_row_height_chroma,
3320 		double *meta_row_bw,
3321 		double *dpte_row_bw)
3322 {
3323 	if (DCCEnable != true) {
3324 		*meta_row_bw = 0;
3325 	} else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || SourcePixelFormat == dm_rgbe_alpha) {
3326 		*meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
3327 				+ VRatioChroma * MetaRowByteChroma
3328 						/ (meta_row_height_chroma * LineTime);
3329 	} else {
3330 		*meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
3331 	}
3332 
3333 	if (GPUVMEnable != true) {
3334 		*dpte_row_bw = 0;
3335 	} else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || SourcePixelFormat == dm_rgbe_alpha) {
3336 		*dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
3337 				+ VRatioChroma * PixelPTEBytesPerRowChroma
3338 						/ (dpte_row_height_chroma * LineTime);
3339 	} else {
3340 		*dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
3341 	}
3342 }
3343 
CalculateFlipSchedule(struct display_mode_lib * mode_lib,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,double UrgentExtraLatency,double UrgentLatency,unsigned int GPUVMMaxPageTableLevels,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,bool GPUVMEnable,double HostVMMinPageSize,double PDEAndMetaPTEBytesPerFrame,double MetaRowBytes,double DPTEBytesPerRow,double BandwidthAvailableForImmediateFlip,unsigned int TotImmediateFlipBytes,enum source_format_class SourcePixelFormat,double LineTime,double VRatio,double VRatioChroma,double Tno_bw,bool DCCEnable,unsigned int dpte_row_height,unsigned int meta_row_height,unsigned int dpte_row_height_chroma,unsigned int meta_row_height_chroma,double * DestinationLinesToRequestVMInImmediateFlip,double * DestinationLinesToRequestRowInImmediateFlip,double * final_flip_bw,bool * ImmediateFlipSupportedForPipe)3344 static void CalculateFlipSchedule(
3345 		struct display_mode_lib *mode_lib,
3346 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
3347 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
3348 		double UrgentExtraLatency,
3349 		double UrgentLatency,
3350 		unsigned int GPUVMMaxPageTableLevels,
3351 		bool HostVMEnable,
3352 		unsigned int HostVMMaxNonCachedPageTableLevels,
3353 		bool GPUVMEnable,
3354 		double HostVMMinPageSize,
3355 		double PDEAndMetaPTEBytesPerFrame,
3356 		double MetaRowBytes,
3357 		double DPTEBytesPerRow,
3358 		double BandwidthAvailableForImmediateFlip,
3359 		unsigned int TotImmediateFlipBytes,
3360 		enum source_format_class SourcePixelFormat,
3361 		double LineTime,
3362 		double VRatio,
3363 		double VRatioChroma,
3364 		double Tno_bw,
3365 		bool DCCEnable,
3366 		unsigned int dpte_row_height,
3367 		unsigned int meta_row_height,
3368 		unsigned int dpte_row_height_chroma,
3369 		unsigned int meta_row_height_chroma,
3370 		double *DestinationLinesToRequestVMInImmediateFlip,
3371 		double *DestinationLinesToRequestRowInImmediateFlip,
3372 		double *final_flip_bw,
3373 		bool *ImmediateFlipSupportedForPipe)
3374 {
3375 	double min_row_time = 0.0;
3376 	unsigned int HostVMDynamicLevelsTrips = 0;
3377 	double TimeForFetchingMetaPTEImmediateFlip = 0;
3378 	double TimeForFetchingRowInVBlankImmediateFlip = 0;
3379 	double ImmediateFlipBW = 0;
3380 	double HostVMInefficiencyFactor = 0;
3381 
3382 	if (GPUVMEnable == true && HostVMEnable == true) {
3383 		HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
3384 		HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
3385 	} else {
3386 		HostVMInefficiencyFactor = 1;
3387 		HostVMDynamicLevelsTrips = 0;
3388 	}
3389 
3390 	if (GPUVMEnable == true || DCCEnable == true) {
3391 		ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes;
3392 	}
3393 
3394 	if (GPUVMEnable == true) {
3395 		TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / ImmediateFlipBW,
3396 				UrgentExtraLatency + UrgentLatency * (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1), LineTime / 4.0);
3397 	} else {
3398 		TimeForFetchingMetaPTEImmediateFlip = 0;
3399 	}
3400 
3401 	*DestinationLinesToRequestVMInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1) / 4.0;
3402 	if ((GPUVMEnable == true || DCCEnable == true)) {
3403 		TimeForFetchingRowInVBlankImmediateFlip = dml_max3((MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW,
3404 				UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4);
3405 	} else {
3406 		TimeForFetchingRowInVBlankImmediateFlip = 0;
3407 	}
3408 
3409 	*DestinationLinesToRequestRowInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1) / 4.0;
3410 
3411 	if (GPUVMEnable == true) {
3412 		*final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
3413 				(MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime));
3414 	} else if ((GPUVMEnable == true || DCCEnable == true)) {
3415 		*final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime);
3416 	} else {
3417 		*final_flip_bw = 0;
3418 	}
3419 
3420 
3421 	if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_rgbe_alpha) {
3422 		if (GPUVMEnable == true && DCCEnable != true) {
3423 			min_row_time = dml_min(dpte_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma);
3424 		} else if (GPUVMEnable != true && DCCEnable == true) {
3425 			min_row_time = dml_min(meta_row_height * LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma);
3426 		} else {
3427 			min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio,
3428 					dpte_row_height_chroma * LineTime / VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma);
3429 		}
3430 	} else {
3431 		if (GPUVMEnable == true && DCCEnable != true) {
3432 			min_row_time = dpte_row_height * LineTime / VRatio;
3433 		} else if (GPUVMEnable != true && DCCEnable == true) {
3434 			min_row_time = meta_row_height * LineTime / VRatio;
3435 		} else {
3436 			min_row_time = dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio);
3437 		}
3438 	}
3439 
3440 	if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16
3441 			|| TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip > min_row_time) {
3442 		*ImmediateFlipSupportedForPipe = false;
3443 	} else {
3444 		*ImmediateFlipSupportedForPipe = true;
3445 	}
3446 }
3447 
TruncToValidBPP(double LinkBitRate,int Lanes,long HTotal,long HActive,double PixelClock,double DesiredBPP,bool DSCEnable,enum output_encoder_class Output,enum output_format_class Format,unsigned int DSCInputBitPerComponent,int DSCSlices,int AudioRate,int AudioLayout,enum odm_combine_mode ODMCombine)3448 static double TruncToValidBPP(
3449 		double LinkBitRate,
3450 		int Lanes,
3451 		long HTotal,
3452 		long HActive,
3453 		double PixelClock,
3454 		double DesiredBPP,
3455 		bool DSCEnable,
3456 		enum output_encoder_class Output,
3457 		enum output_format_class Format,
3458 		unsigned int DSCInputBitPerComponent,
3459 		int DSCSlices,
3460 		int AudioRate,
3461 		int AudioLayout,
3462 		enum odm_combine_mode ODMCombine)
3463 {
3464 	double MaxLinkBPP = 0;
3465 	int MinDSCBPP = 0;
3466 	double MaxDSCBPP = 0;
3467 	int NonDSCBPP0 = 0;
3468 	int NonDSCBPP1 = 0;
3469 	int NonDSCBPP2 = 0;
3470 
3471 	if (Format == dm_420) {
3472 		NonDSCBPP0 = 12;
3473 		NonDSCBPP1 = 15;
3474 		NonDSCBPP2 = 18;
3475 		MinDSCBPP = 6;
3476 		MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1.0 / 16;
3477 	} else if (Format == dm_444) {
3478 		NonDSCBPP0 = 24;
3479 		NonDSCBPP1 = 30;
3480 		NonDSCBPP2 = 36;
3481 		MinDSCBPP = 8;
3482 		MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16;
3483 	} else {
3484 		NonDSCBPP0 = 16;
3485 		NonDSCBPP1 = 20;
3486 		NonDSCBPP2 = 24;
3487 
3488 		if (Format == dm_n422) {
3489 			MinDSCBPP = 7;
3490 			MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0;
3491 		} else {
3492 			MinDSCBPP = 8;
3493 			MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0;
3494 		}
3495 	}
3496 
3497 	if (DSCEnable && Output == dm_dp) {
3498 		MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock * (1 - 2.4 / 100);
3499 	} else {
3500 		MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock;
3501 	}
3502 
3503 	if (ODMCombine == dm_odm_combine_mode_4to1 && MaxLinkBPP > 16) {
3504 		MaxLinkBPP = 16;
3505 	} else if (ODMCombine == dm_odm_combine_mode_2to1 && MaxLinkBPP > 32) {
3506 		MaxLinkBPP = 32;
3507 	}
3508 
3509 
3510 	if (DesiredBPP == 0) {
3511 		if (DSCEnable) {
3512 			if (MaxLinkBPP < MinDSCBPP) {
3513 				return BPP_INVALID;
3514 			} else if (MaxLinkBPP >= MaxDSCBPP) {
3515 				return MaxDSCBPP;
3516 			} else {
3517 				return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0;
3518 			}
3519 		} else {
3520 			if (MaxLinkBPP >= NonDSCBPP2) {
3521 				return NonDSCBPP2;
3522 			} else if (MaxLinkBPP >= NonDSCBPP1) {
3523 				return NonDSCBPP1;
3524 			} else if (MaxLinkBPP >= NonDSCBPP0) {
3525 				return NonDSCBPP0;
3526 			} else {
3527 				return BPP_INVALID;
3528 			}
3529 		}
3530 	} else {
3531 		if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 || DesiredBPP == NonDSCBPP0 || DesiredBPP == 18)) ||
3532 				(DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP))) {
3533 			return BPP_INVALID;
3534 		} else {
3535 			return DesiredBPP;
3536 		}
3537 	}
3538 	return BPP_INVALID;
3539 }
3540 
dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib * mode_lib)3541 void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
3542 {
3543 	struct vba_vars_st *v = &mode_lib->vba;
3544 	int MinPrefetchMode, MaxPrefetchMode;
3545 	int i, start_state;
3546 	unsigned int j, k, m;
3547 	bool   EnoughWritebackUnits = true;
3548 	bool   WritebackModeSupport = true;
3549 	bool   ViewportExceedsSurface = false;
3550 	double MaxTotalVActiveRDBandwidth = 0;
3551 	long ReorderingBytes = 0;
3552 	bool NotUrgentLatencyHiding[DC__NUM_DPP__MAX] = { 0 };
3553 
3554 	/*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
3555 
3556 	if (mode_lib->validate_max_state)
3557 		start_state = v->soc.num_states - 1;
3558 	else
3559 		start_state = 0;
3560 
3561 	CalculateMinAndMaxPrefetchMode(
3562 		mode_lib->vba.AllowDRAMSelfRefreshOrDRAMClockChangeInVblank,
3563 		&MinPrefetchMode, &MaxPrefetchMode);
3564 
3565 	/*Scale Ratio, taps Support Check*/
3566 
3567 	v->ScaleRatioAndTapsSupport = true;
3568 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3569 		if (v->ScalerEnabled[k] == false
3570 				&& ((v->SourcePixelFormat[k] != dm_444_64
3571 						&& v->SourcePixelFormat[k] != dm_444_32
3572 						&& v->SourcePixelFormat[k] != dm_444_16
3573 						&& v->SourcePixelFormat[k] != dm_mono_16
3574 						&& v->SourcePixelFormat[k] != dm_mono_8
3575 						&& v->SourcePixelFormat[k] != dm_rgbe
3576 						&& v->SourcePixelFormat[k] != dm_rgbe_alpha)
3577 						|| v->HRatio[k] != 1.0
3578 						|| v->htaps[k] != 1.0
3579 						|| v->VRatio[k] != 1.0
3580 						|| v->vtaps[k] != 1.0)) {
3581 			v->ScaleRatioAndTapsSupport = false;
3582 		} else if (v->vtaps[k] < 1.0 || v->vtaps[k] > 8.0
3583 				|| v->htaps[k] < 1.0 || v->htaps[k] > 8.0
3584 				|| (v->htaps[k] > 1.0
3585 						&& (v->htaps[k] % 2) == 1)
3586 				|| v->HRatio[k] > v->MaxHSCLRatio
3587 				|| v->VRatio[k] > v->MaxVSCLRatio
3588 				|| v->HRatio[k] > v->htaps[k]
3589 				|| v->VRatio[k] > v->vtaps[k]
3590 				|| (v->SourcePixelFormat[k] != dm_444_64
3591 						&& v->SourcePixelFormat[k] != dm_444_32
3592 						&& v->SourcePixelFormat[k] != dm_444_16
3593 						&& v->SourcePixelFormat[k] != dm_mono_16
3594 						&& v->SourcePixelFormat[k] != dm_mono_8
3595 						&& v->SourcePixelFormat[k] != dm_rgbe
3596 						&& (v->VTAPsChroma[k] < 1
3597 							|| v->VTAPsChroma[k] > 8
3598 							|| v->HTAPsChroma[k] < 1
3599 							|| v->HTAPsChroma[k] > 8
3600 							|| (v->HTAPsChroma[k] > 1 && v->HTAPsChroma[k] % 2 == 1)
3601 							|| v->HRatioChroma[k] > v->MaxHSCLRatio
3602 							|| v->VRatioChroma[k] > v->MaxVSCLRatio
3603 							|| v->HRatioChroma[k] > v->HTAPsChroma[k]
3604 							|| v->VRatioChroma[k] > v->VTAPsChroma[k]))) {
3605 			v->ScaleRatioAndTapsSupport = false;
3606 		}
3607 	}
3608 	/*Source Format, Pixel Format and Scan Support Check*/
3609 
3610 	v->SourceFormatPixelAndScanSupport = true;
3611 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3612 		if ((v->SurfaceTiling[k] == dm_sw_linear && (!(v->SourceScan[k] != dm_vert) || v->DCCEnable[k] == true))
3613 				|| ((v->SurfaceTiling[k] == dm_sw_64kb_d || v->SurfaceTiling[k] == dm_sw_64kb_d_t || v->SurfaceTiling[k] == dm_sw_64kb_d_x)
3614 						&& !(v->SourcePixelFormat[k] == dm_444_64))) {
3615 			v->SourceFormatPixelAndScanSupport = false;
3616 		}
3617 	}
3618 	/*Bandwidth Support Check*/
3619 
3620 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3621 		dml30_CalculateBytePerPixelAnd256BBlockSizes(
3622 				v->SourcePixelFormat[k],
3623 				v->SurfaceTiling[k],
3624 				&v->BytePerPixelY[k],
3625 				&v->BytePerPixelC[k],
3626 				&v->BytePerPixelInDETY[k],
3627 				&v->BytePerPixelInDETC[k],
3628 				&v->Read256BlockHeightY[k],
3629 				&v->Read256BlockHeightC[k],
3630 				&v->Read256BlockWidthY[k],
3631 				&v->Read256BlockWidthC[k]);
3632 	}
3633 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3634 		if (v->SourceScan[k] != dm_vert) {
3635 			v->SwathWidthYSingleDPP[k] = v->ViewportWidth[k];
3636 			v->SwathWidthCSingleDPP[k] = v->ViewportWidthChroma[k];
3637 		} else {
3638 			v->SwathWidthYSingleDPP[k] = v->ViewportHeight[k];
3639 			v->SwathWidthCSingleDPP[k] = v->ViewportHeightChroma[k];
3640 		}
3641 	}
3642 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3643 		v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
3644 		v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k] / 2.0;
3645 	}
3646 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3647 		if (v->WritebackEnable[k] == true
3648 				&& v->WritebackPixelFormat[k] == dm_444_64) {
3649 			v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
3650 					* v->WritebackDestinationHeight[k]
3651 					/ (v->WritebackSourceHeight[k]
3652 							* v->HTotal[k]
3653 							/ v->PixelClock[k]) * 8.0;
3654 		} else if (v->WritebackEnable[k] == true) {
3655 			v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
3656 					* v->WritebackDestinationHeight[k]
3657 					/ (v->WritebackSourceHeight[k]
3658 							* v->HTotal[k]
3659 							/ v->PixelClock[k]) * 4.0;
3660 		} else {
3661 			v->WriteBandwidth[k] = 0.0;
3662 		}
3663 	}
3664 
3665 	/*Writeback Latency support check*/
3666 
3667 	v->WritebackLatencySupport = true;
3668 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3669 		if (v->WritebackEnable[k] == true) {
3670 			if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave ||
3671 			    v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave) {
3672 				if (v->WriteBandwidth[k]
3673 						> 2.0 * v->WritebackInterfaceBufferSize * 1024
3674 								/ v->WritebackLatency) {
3675 					v->WritebackLatencySupport = false;
3676 				}
3677 			} else {
3678 				if (v->WriteBandwidth[k]
3679 						> v->WritebackInterfaceBufferSize * 1024
3680 								/ v->WritebackLatency) {
3681 					v->WritebackLatencySupport = false;
3682 				}
3683 			}
3684 		}
3685 	}
3686 
3687 	/*Writeback Mode Support Check*/
3688 
3689 	v->TotalNumberOfActiveWriteback = 0;
3690 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3691 		if (v->WritebackEnable[k] == true) {
3692 			v->TotalNumberOfActiveWriteback =
3693 					v->TotalNumberOfActiveWriteback + 1;
3694 		}
3695 	}
3696 
3697 	if (v->TotalNumberOfActiveWriteback > v->MaxNumWriteback) {
3698 		EnoughWritebackUnits = false;
3699 	}
3700 	if (!v->WritebackSupportInterleaveAndUsingWholeBufferForASingleStream
3701 			&& (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave
3702 					|| v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave)) {
3703 
3704 		WritebackModeSupport = false;
3705 	}
3706 	if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave && v->TotalNumberOfActiveWriteback > 1) {
3707 		WritebackModeSupport = false;
3708 	}
3709 
3710 	/*Writeback Scale Ratio and Taps Support Check*/
3711 
3712 	v->WritebackScaleRatioAndTapsSupport = true;
3713 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3714 		if (v->WritebackEnable[k] == true) {
3715 			if (v->WritebackHRatio[k] > v->WritebackMaxHSCLRatio
3716 					|| v->WritebackVRatio[k]
3717 							> v->WritebackMaxVSCLRatio
3718 					|| v->WritebackHRatio[k]
3719 							< v->WritebackMinHSCLRatio
3720 					|| v->WritebackVRatio[k]
3721 							< v->WritebackMinVSCLRatio
3722 					|| v->WritebackHTaps[k]
3723 							> v->WritebackMaxHSCLTaps
3724 					|| v->WritebackVTaps[k]
3725 							> v->WritebackMaxVSCLTaps
3726 					|| v->WritebackHRatio[k]
3727 							> v->WritebackHTaps[k]
3728 					|| v->WritebackVRatio[k]
3729 							> v->WritebackVTaps[k]
3730 					|| (v->WritebackHTaps[k] > 2.0
3731 							&& ((v->WritebackHTaps[k] % 2)
3732 									== 1))) {
3733 				v->WritebackScaleRatioAndTapsSupport = false;
3734 			}
3735 			if (2.0 * v->WritebackDestinationWidth[k] * (v->WritebackVTaps[k] - 1) * 57 > v->WritebackLineBufferSize) {
3736 				v->WritebackScaleRatioAndTapsSupport = false;
3737 			}
3738 		}
3739 	}
3740 	/*Maximum DISPCLK/DPPCLK Support check*/
3741 
3742 	v->WritebackRequiredDISPCLK = 0.0;
3743 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3744 		if (v->WritebackEnable[k] == true) {
3745 			v->WritebackRequiredDISPCLK = dml_max(v->WritebackRequiredDISPCLK,
3746 					dml30_CalculateWriteBackDISPCLK(
3747 							v->WritebackPixelFormat[k],
3748 							v->PixelClock[k],
3749 							v->WritebackHRatio[k],
3750 							v->WritebackVRatio[k],
3751 							v->WritebackHTaps[k],
3752 							v->WritebackVTaps[k],
3753 							v->WritebackSourceWidth[k],
3754 							v->WritebackDestinationWidth[k],
3755 							v->HTotal[k],
3756 							v->WritebackLineBufferSize));
3757 		}
3758 	}
3759 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3760 		if (v->HRatio[k] > 1.0) {
3761 			v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(v->htaps[k] / 6.0, 1.0));
3762 		} else {
3763 			v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
3764 		}
3765 		if (v->BytePerPixelC[k] == 0.0) {
3766 			v->PSCL_FACTOR_CHROMA[k] = 0.0;
3767 			v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k]
3768 					* dml_max3(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]), v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k], 1.0);
3769 			if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0) && v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
3770 				v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
3771 			}
3772 		} else {
3773 			if (v->HRatioChroma[k] > 1.0) {
3774 				v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
3775 						v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(v->HTAPsChroma[k] / 6.0, 1.0));
3776 			} else {
3777 				v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
3778 			}
3779 			v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k] * dml_max5(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]),
3780 							v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k],
3781 							v->VTAPsChroma[k] / 6.0 * dml_min(1.0, v->HRatioChroma[k]),
3782 							v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_FACTOR_CHROMA[k],
3783 							1.0);
3784 			if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0 || v->HTAPsChroma[k] > 6.0 || v->VTAPsChroma[k] > 6.0)
3785 					&& v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
3786 				v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
3787 			}
3788 		}
3789 	}
3790 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3791 		int MaximumSwathWidthSupportLuma = 0;
3792 		int MaximumSwathWidthSupportChroma = 0;
3793 
3794 		if (v->SurfaceTiling[k] == dm_sw_linear) {
3795 			MaximumSwathWidthSupportLuma = 8192.0;
3796 		} else if (v->SourceScan[k] == dm_vert && v->BytePerPixelC[k] > 0) {
3797 			MaximumSwathWidthSupportLuma = 2880.0;
3798 		} else {
3799 			MaximumSwathWidthSupportLuma = 5760.0;
3800 		}
3801 
3802 		if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) {
3803 			MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma / 2.0;
3804 		} else {
3805 			MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma;
3806 		}
3807 		v->MaximumSwathWidthInLineBufferLuma = v->LineBufferSize * dml_max(v->HRatio[k], 1.0) / v->LBBitPerPixel[k]
3808 				/ (v->vtaps[k] + dml_max(dml_ceil(v->VRatio[k], 1.0) - 2, 0.0));
3809 		if (v->BytePerPixelC[k] == 0.0) {
3810 			v->MaximumSwathWidthInLineBufferChroma = 0;
3811 		} else {
3812 			v->MaximumSwathWidthInLineBufferChroma = v->LineBufferSize * dml_max(v->HRatioChroma[k], 1.0) / v->LBBitPerPixel[k]
3813 					/ (v->VTAPsChroma[k] + dml_max(dml_ceil(v->VRatioChroma[k], 1.0) - 2, 0.0));
3814 		}
3815 		v->MaximumSwathWidthLuma[k] = dml_min(MaximumSwathWidthSupportLuma, v->MaximumSwathWidthInLineBufferLuma);
3816 		v->MaximumSwathWidthChroma[k] = dml_min(MaximumSwathWidthSupportChroma, v->MaximumSwathWidthInLineBufferChroma);
3817 	}
3818 
3819 	CalculateSwathAndDETConfiguration(
3820 			true,
3821 			v->NumberOfActivePlanes,
3822 			v->DETBufferSizeInKByte[0],
3823 			v->MaximumSwathWidthLuma,
3824 			v->MaximumSwathWidthChroma,
3825 			v->SourceScan,
3826 			v->SourcePixelFormat,
3827 			v->SurfaceTiling,
3828 			v->ViewportWidth,
3829 			v->ViewportHeight,
3830 			v->SurfaceWidthY,
3831 			v->SurfaceWidthC,
3832 			v->SurfaceHeightY,
3833 			v->SurfaceHeightC,
3834 			v->Read256BlockHeightY,
3835 			v->Read256BlockHeightC,
3836 			v->Read256BlockWidthY,
3837 			v->Read256BlockWidthC,
3838 			v->odm_combine_dummy,
3839 			v->BlendingAndTiming,
3840 			v->BytePerPixelY,
3841 			v->BytePerPixelC,
3842 			v->BytePerPixelInDETY,
3843 			v->BytePerPixelInDETC,
3844 			v->HActive,
3845 			v->HRatio,
3846 			v->HRatioChroma,
3847 			v->DPPPerPlane,
3848 			v->swath_width_luma_ub,
3849 			v->swath_width_chroma_ub,
3850 			v->SwathWidthY,
3851 			v->SwathWidthC,
3852 			v->SwathHeightY,
3853 			v->SwathHeightC,
3854 			v->DETBufferSizeY,
3855 			v->DETBufferSizeC,
3856 			v->SingleDPPViewportSizeSupportPerPlane,
3857 			&v->ViewportSizeSupport[0][0]);
3858 
3859 	for (i = start_state; i < v->soc.num_states; i++) {
3860 		for (j = 0; j < 2; j++) {
3861 			v->MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDispclk[i], v->DISPCLKDPPCLKVCOSpeed);
3862 			v->MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDppclk[i], v->DISPCLKDPPCLKVCOSpeed);
3863 			v->RequiredDISPCLK[i][j] = 0.0;
3864 			v->DISPCLK_DPPCLK_Support[i][j] = true;
3865 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3866 				v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3867 						* (1.0 + v->DISPCLKRampingMargin / 100.0);
3868 				if ((v->PlaneRequiredDISPCLKWithoutODMCombine >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
3869 						&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
3870 					v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3871 				}
3872 				v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3873 						* (1 + v->DISPCLKRampingMargin / 100.0);
3874 				if ((v->PlaneRequiredDISPCLKWithODMCombine2To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
3875 						&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
3876 					v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3877 				}
3878 				v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3879 						* (1 + v->DISPCLKRampingMargin / 100.0);
3880 				if ((v->PlaneRequiredDISPCLKWithODMCombine4To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
3881 						&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
3882 					v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3883 				}
3884 
3885 				if (v->ODMCombinePolicy == dm_odm_combine_policy_none) {
3886 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
3887 					v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
3888 				} else if (v->ODMCombinePolicy == dm_odm_combine_policy_2to1) {
3889 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3890 					v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3891 				} else if (v->ODMCombinePolicy == dm_odm_combine_policy_4to1
3892 						|| v->PlaneRequiredDISPCLKWithODMCombine2To1 > v->MaxDispclkRoundedDownToDFSGranularity) {
3893 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
3894 					v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
3895 				} else if (v->PlaneRequiredDISPCLKWithoutODMCombine > v->MaxDispclkRoundedDownToDFSGranularity) {
3896 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3897 					v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3898 				} else {
3899 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
3900 					v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
3901 				}
3902 				if (v->DSCEnabled[k] && v->HActive[k] > DCN30_MAX_DSC_IMAGE_WIDTH
3903 						&& v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) {
3904 					if (v->HActive[k] / 2 > DCN30_MAX_DSC_IMAGE_WIDTH) {
3905 						v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
3906 						v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
3907 					} else {
3908 						v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3909 						v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3910 					}
3911 				}
3912 				if (v->OutputFormat[k] == dm_420 && v->HActive[k] > DCN30_MAX_FMT_420_BUFFER_WIDTH
3913 						&& v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) {
3914 					if (v->HActive[k] / 2 > DCN30_MAX_FMT_420_BUFFER_WIDTH) {
3915 						v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
3916 						v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
3917 					} else {
3918 						v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3919 						v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3920 					}
3921 				}
3922 				if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
3923 					v->MPCCombine[i][j][k] = false;
3924 					v->NoOfDPP[i][j][k] = 4;
3925 					v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 4;
3926 				} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
3927 					v->MPCCombine[i][j][k] = false;
3928 					v->NoOfDPP[i][j][k] = 2;
3929 					v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2;
3930 				} else if ((v->WhenToDoMPCCombine == dm_mpc_never
3931 						|| (v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= v->MaxDppclkRoundedDownToDFSGranularity
3932 								&& v->SingleDPPViewportSizeSupportPerPlane[k] == true))) {
3933 					v->MPCCombine[i][j][k] = false;
3934 					v->NoOfDPP[i][j][k] = 1;
3935 					v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3936 				} else {
3937 					v->MPCCombine[i][j][k] = true;
3938 					v->NoOfDPP[i][j][k] = 2;
3939 					v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3940 				}
3941 				v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
3942 				if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3943 						> v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
3944 					v->DISPCLK_DPPCLK_Support[i][j] = false;
3945 				}
3946 			}
3947 			v->TotalNumberOfActiveDPP[i][j] = 0;
3948 			v->TotalNumberOfSingleDPPPlanes[i][j] = 0;
3949 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3950 				v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
3951 				if (v->NoOfDPP[i][j][k] == 1)
3952 					v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] + 1;
3953 			}
3954 			if (j == 1 && v->WhenToDoMPCCombine != dm_mpc_never) {
3955 				while (!(v->TotalNumberOfActiveDPP[i][j] >= v->MaxNumDPP || v->TotalNumberOfSingleDPPPlanes[i][j] == 0)) {
3956 					double BWOfNonSplitPlaneOfMaximumBandwidth = 0;
3957 					unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
3958 					BWOfNonSplitPlaneOfMaximumBandwidth = 0;
3959 					NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
3960 					for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3961 						if (v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k] > BWOfNonSplitPlaneOfMaximumBandwidth
3962 								&& v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled && v->MPCCombine[i][j][k] == false) {
3963 							BWOfNonSplitPlaneOfMaximumBandwidth = v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
3964 							NumberOfNonSplitPlaneOfMaximumBandwidth = k;
3965 						}
3966 					}
3967 					v->MPCCombine[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = true;
3968 					v->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
3969 					v->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = v->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
3970 							* (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
3971 					v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + 1;
3972 					v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] - 1;
3973 				}
3974 			}
3975 			if (v->TotalNumberOfActiveDPP[i][j] > v->MaxNumDPP) {
3976 				v->RequiredDISPCLK[i][j] = 0.0;
3977 				v->DISPCLK_DPPCLK_Support[i][j] = true;
3978 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3979 					v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
3980 					if (v->SingleDPPViewportSizeSupportPerPlane[k] == false && v->WhenToDoMPCCombine != dm_mpc_never) {
3981 						v->MPCCombine[i][j][k] = true;
3982 						v->NoOfDPP[i][j][k] = 2;
3983 						v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3984 					} else {
3985 						v->MPCCombine[i][j][k] = false;
3986 						v->NoOfDPP[i][j][k] = 1;
3987 						v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3988 					}
3989 					if (!(v->MaxDispclk[i] == v->MaxDispclk[v->soc.num_states - 1] && v->MaxDppclk[i] == v->MaxDppclk[v->soc.num_states - 1])) {
3990 						v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3991 								* (1.0 + v->DISPCLKRampingMargin / 100.0);
3992 					} else {
3993 						v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3994 					}
3995 					v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
3996 					if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3997 							> v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
3998 						v->DISPCLK_DPPCLK_Support[i][j] = false;
3999 					}
4000 				}
4001 				v->TotalNumberOfActiveDPP[i][j] = 0.0;
4002 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4003 					v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
4004 				}
4005 			}
4006 			v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->WritebackRequiredDISPCLK);
4007 			if (v->MaxDispclkRoundedDownToDFSGranularity < v->WritebackRequiredDISPCLK) {
4008 				v->DISPCLK_DPPCLK_Support[i][j] = false;
4009 			}
4010 		}
4011 	}
4012 
4013 	/*Total Available Pipes Support Check*/
4014 
4015 	for (i = start_state; i < v->soc.num_states; i++) {
4016 		for (j = 0; j < 2; j++) {
4017 			if (v->TotalNumberOfActiveDPP[i][j] <= v->MaxNumDPP) {
4018 				v->TotalAvailablePipesSupport[i][j] = true;
4019 			} else {
4020 				v->TotalAvailablePipesSupport[i][j] = false;
4021 			}
4022 		}
4023 	}
4024 	/*Display IO and DSC Support Check*/
4025 
4026 	v->NonsupportedDSCInputBPC = false;
4027 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4028 		if (!(v->DSCInputBitPerComponent[k] == 12.0
4029 				|| v->DSCInputBitPerComponent[k] == 10.0
4030 				|| v->DSCInputBitPerComponent[k] == 8.0)) {
4031 			v->NonsupportedDSCInputBPC = true;
4032 		}
4033 	}
4034 
4035 	/*Number Of DSC Slices*/
4036 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4037 		if (v->BlendingAndTiming[k] == k) {
4038 			if (v->PixelClockBackEnd[k] > 3200) {
4039 				v->NumberOfDSCSlices[k] = dml_ceil(v->PixelClockBackEnd[k] / 400.0, 4.0);
4040 			} else if (v->PixelClockBackEnd[k] > 1360) {
4041 				v->NumberOfDSCSlices[k] = 8;
4042 			} else if (v->PixelClockBackEnd[k] > 680) {
4043 				v->NumberOfDSCSlices[k] = 4;
4044 			} else if (v->PixelClockBackEnd[k] > 340) {
4045 				v->NumberOfDSCSlices[k] = 2;
4046 			} else {
4047 				v->NumberOfDSCSlices[k] = 1;
4048 			}
4049 		} else {
4050 			v->NumberOfDSCSlices[k] = 0;
4051 		}
4052 	}
4053 
4054 	for (i = start_state; i < v->soc.num_states; i++) {
4055 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4056 			v->RequiresDSC[i][k] = false;
4057 			v->RequiresFEC[i][k] = false;
4058 			if (v->BlendingAndTiming[k] == k) {
4059 				if (v->Output[k] == dm_hdmi) {
4060 					v->RequiresDSC[i][k] = false;
4061 					v->RequiresFEC[i][k] = false;
4062 					v->OutputBppPerState[i][k] = TruncToValidBPP(
4063 							dml_min(600.0, v->PHYCLKPerState[i]) * 10,
4064 							3,
4065 							v->HTotal[k],
4066 							v->HActive[k],
4067 							v->PixelClockBackEnd[k],
4068 							v->ForcedOutputLinkBPP[k],
4069 							false,
4070 							v->Output[k],
4071 							v->OutputFormat[k],
4072 							v->DSCInputBitPerComponent[k],
4073 							v->NumberOfDSCSlices[k],
4074 							v->AudioSampleRate[k],
4075 							v->AudioSampleLayout[k],
4076 							v->ODMCombineEnablePerState[i][k]);
4077 				} else if (v->Output[k] == dm_dp || v->Output[k] == dm_edp) {
4078 					if (v->DSCEnable[k] == true) {
4079 						v->RequiresDSC[i][k] = true;
4080 						v->LinkDSCEnable = true;
4081 						if (v->Output[k] == dm_dp) {
4082 							v->RequiresFEC[i][k] = true;
4083 						} else {
4084 							v->RequiresFEC[i][k] = false;
4085 						}
4086 					} else {
4087 						v->RequiresDSC[i][k] = false;
4088 						v->LinkDSCEnable = false;
4089 						v->RequiresFEC[i][k] = false;
4090 					}
4091 
4092 					v->Outbpp = BPP_INVALID;
4093 					if (v->PHYCLKPerState[i] >= 270.0) {
4094 						v->Outbpp = TruncToValidBPP(
4095 								(1.0 - v->Downspreading / 100.0) * 2700,
4096 								v->OutputLinkDPLanes[k],
4097 								v->HTotal[k],
4098 								v->HActive[k],
4099 								v->PixelClockBackEnd[k],
4100 								v->ForcedOutputLinkBPP[k],
4101 								v->LinkDSCEnable,
4102 								v->Output[k],
4103 								v->OutputFormat[k],
4104 								v->DSCInputBitPerComponent[k],
4105 								v->NumberOfDSCSlices[k],
4106 								v->AudioSampleRate[k],
4107 								v->AudioSampleLayout[k],
4108 								v->ODMCombineEnablePerState[i][k]);
4109 						v->OutputBppPerState[i][k] = v->Outbpp;
4110 						// TODO: Need some other way to handle this nonsense
4111 						// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
4112 					}
4113 					if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 540.0) {
4114 						v->Outbpp = TruncToValidBPP(
4115 								(1.0 - v->Downspreading / 100.0) * 5400,
4116 								v->OutputLinkDPLanes[k],
4117 								v->HTotal[k],
4118 								v->HActive[k],
4119 								v->PixelClockBackEnd[k],
4120 								v->ForcedOutputLinkBPP[k],
4121 								v->LinkDSCEnable,
4122 								v->Output[k],
4123 								v->OutputFormat[k],
4124 								v->DSCInputBitPerComponent[k],
4125 								v->NumberOfDSCSlices[k],
4126 								v->AudioSampleRate[k],
4127 								v->AudioSampleLayout[k],
4128 								v->ODMCombineEnablePerState[i][k]);
4129 						v->OutputBppPerState[i][k] = v->Outbpp;
4130 						// TODO: Need some other way to handle this nonsense
4131 						// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
4132 					}
4133 					if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 810.0) {
4134 						v->Outbpp = TruncToValidBPP(
4135 								(1.0 - v->Downspreading / 100.0) * 8100,
4136 								v->OutputLinkDPLanes[k],
4137 								v->HTotal[k],
4138 								v->HActive[k],
4139 								v->PixelClockBackEnd[k],
4140 								v->ForcedOutputLinkBPP[k],
4141 								v->LinkDSCEnable,
4142 								v->Output[k],
4143 								v->OutputFormat[k],
4144 								v->DSCInputBitPerComponent[k],
4145 								v->NumberOfDSCSlices[k],
4146 								v->AudioSampleRate[k],
4147 								v->AudioSampleLayout[k],
4148 								v->ODMCombineEnablePerState[i][k]);
4149 						if (v->Outbpp == BPP_INVALID && v->ForcedOutputLinkBPP[k] == 0) {
4150 							//if (v->Outbpp == BPP_INVALID && v->DSCEnabled[k] == dm_dsc_enable_only_if_necessary && v->ForcedOutputLinkBPP[k] == 0) {
4151 							v->RequiresDSC[i][k] = true;
4152 							v->LinkDSCEnable = true;
4153 							if (v->Output[k] == dm_dp) {
4154 								v->RequiresFEC[i][k] = true;
4155 							}
4156 							v->Outbpp = TruncToValidBPP(
4157 									(1.0 - v->Downspreading / 100.0) * 8100,
4158 									v->OutputLinkDPLanes[k],
4159 									v->HTotal[k],
4160 									v->HActive[k],
4161 									v->PixelClockBackEnd[k],
4162 									v->ForcedOutputLinkBPP[k],
4163 									v->LinkDSCEnable,
4164 									v->Output[k],
4165 									v->OutputFormat[k],
4166 									v->DSCInputBitPerComponent[k],
4167 									v->NumberOfDSCSlices[k],
4168 									v->AudioSampleRate[k],
4169 									v->AudioSampleLayout[k],
4170 									v->ODMCombineEnablePerState[i][k]);
4171 						}
4172 						v->OutputBppPerState[i][k] = v->Outbpp;
4173 						// TODO: Need some other way to handle this nonsense
4174 						// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
4175 					}
4176 				}
4177 			} else {
4178 				v->OutputBppPerState[i][k] = 0;
4179 			}
4180 		}
4181 	}
4182 	for (i = start_state; i < v->soc.num_states; i++) {
4183 		v->DIOSupport[i] = true;
4184 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4185 			if (!v->skip_dio_check[k] && v->BlendingAndTiming[k] == k && (v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)
4186 					&& (v->OutputBppPerState[i][k] == 0
4187 							|| (v->OutputFormat[k] == dm_420 && v->Interlace[k] == true && v->ProgressiveToInterlaceUnitInOPP == true))) {
4188 				v->DIOSupport[i] = false;
4189 			}
4190 		}
4191 	}
4192 
4193 	for (i = start_state; i < v->soc.num_states; ++i) {
4194 		v->ODMCombine4To1SupportCheckOK[i] = true;
4195 		for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4196 			if (v->BlendingAndTiming[k] == k && v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
4197 					&& (v->ODMCombine4To1Supported == false || v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)) {
4198 				v->ODMCombine4To1SupportCheckOK[i] = false;
4199 			}
4200 		}
4201 	}
4202 
4203 	/* Skip dscclk validation: as long as dispclk is supported, dscclk is also implicitly supported */
4204 
4205 	for (i = start_state; i < v->soc.num_states; i++) {
4206 		v->NotEnoughDSCUnits[i] = false;
4207 		v->TotalDSCUnitsRequired = 0.0;
4208 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4209 			if (v->RequiresDSC[i][k] == true) {
4210 				if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
4211 					v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 4.0;
4212 				} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4213 					v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 2.0;
4214 				} else {
4215 					v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 1.0;
4216 				}
4217 			}
4218 		}
4219 		if (v->TotalDSCUnitsRequired > v->NumberOfDSC) {
4220 			v->NotEnoughDSCUnits[i] = true;
4221 		}
4222 	}
4223 	/*DSC Delay per state*/
4224 
4225 	for (i = start_state; i < v->soc.num_states; i++) {
4226 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4227 			if (v->OutputBppPerState[i][k] == BPP_INVALID) {
4228 				v->BPP = 0.0;
4229 			} else {
4230 				v->BPP = v->OutputBppPerState[i][k];
4231 			}
4232 			if (v->RequiresDSC[i][k] == true && v->BPP != 0.0) {
4233 				if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
4234 					v->DSCDelayPerState[i][k] = dscceComputeDelay(
4235 							v->DSCInputBitPerComponent[k],
4236 							v->BPP,
4237 							dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4238 							v->NumberOfDSCSlices[k],
4239 							v->OutputFormat[k],
4240 							v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
4241 				} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4242 					v->DSCDelayPerState[i][k] = 2.0
4243 							* dscceComputeDelay(
4244 									v->DSCInputBitPerComponent[k],
4245 									v->BPP,
4246 									dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4247 									v->NumberOfDSCSlices[k] / 2,
4248 									v->OutputFormat[k],
4249 									v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
4250 				} else {
4251 					v->DSCDelayPerState[i][k] = 4.0
4252 							* (dscceComputeDelay(
4253 									v->DSCInputBitPerComponent[k],
4254 									v->BPP,
4255 									dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4256 									v->NumberOfDSCSlices[k] / 4,
4257 									v->OutputFormat[k],
4258 									v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]));
4259 				}
4260 				v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][k] * v->PixelClock[k] / v->PixelClockBackEnd[k];
4261 			} else {
4262 				v->DSCDelayPerState[i][k] = 0.0;
4263 			}
4264 		}
4265 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4266 			for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4267 				if (v->BlendingAndTiming[k] == m && v->RequiresDSC[i][m] == true) {
4268 					v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][m];
4269 				}
4270 			}
4271 		}
4272 	}
4273 
4274 	//Calculate Swath, DET Configuration, DCFCLKDeepSleep
4275 	//
4276 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4277 		for (j = 0; j <= 1; ++j) {
4278 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4279 				v->RequiredDPPCLKThisState[k] = v->RequiredDPPCLK[i][j][k];
4280 				v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
4281 				v->ODMCombineEnableThisState[k] = v->ODMCombineEnablePerState[i][k];
4282 			}
4283 
4284 			CalculateSwathAndDETConfiguration(
4285 					false,
4286 					v->NumberOfActivePlanes,
4287 					v->DETBufferSizeInKByte[0],
4288 					v->MaximumSwathWidthLuma,
4289 					v->MaximumSwathWidthChroma,
4290 					v->SourceScan,
4291 					v->SourcePixelFormat,
4292 					v->SurfaceTiling,
4293 					v->ViewportWidth,
4294 					v->ViewportHeight,
4295 					v->SurfaceWidthY,
4296 					v->SurfaceWidthC,
4297 					v->SurfaceHeightY,
4298 					v->SurfaceHeightC,
4299 					v->Read256BlockHeightY,
4300 					v->Read256BlockHeightC,
4301 					v->Read256BlockWidthY,
4302 					v->Read256BlockWidthC,
4303 					v->ODMCombineEnableThisState,
4304 					v->BlendingAndTiming,
4305 					v->BytePerPixelY,
4306 					v->BytePerPixelC,
4307 					v->BytePerPixelInDETY,
4308 					v->BytePerPixelInDETC,
4309 					v->HActive,
4310 					v->HRatio,
4311 					v->HRatioChroma,
4312 					v->NoOfDPPThisState,
4313 					v->swath_width_luma_ub_this_state,
4314 					v->swath_width_chroma_ub_this_state,
4315 					v->SwathWidthYThisState,
4316 					v->SwathWidthCThisState,
4317 					v->SwathHeightYThisState,
4318 					v->SwathHeightCThisState,
4319 					v->DETBufferSizeYThisState,
4320 					v->DETBufferSizeCThisState,
4321 					v->dummystring,
4322 					&v->ViewportSizeSupport[i][j]);
4323 
4324 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4325 				v->swath_width_luma_ub_all_states[i][j][k] = v->swath_width_luma_ub_this_state[k];
4326 				v->swath_width_chroma_ub_all_states[i][j][k] = v->swath_width_chroma_ub_this_state[k];
4327 				v->SwathWidthYAllStates[i][j][k] = v->SwathWidthYThisState[k];
4328 				v->SwathWidthCAllStates[i][j][k] = v->SwathWidthCThisState[k];
4329 				v->SwathHeightYAllStates[i][j][k] = v->SwathHeightYThisState[k];
4330 				v->SwathHeightCAllStates[i][j][k] = v->SwathHeightCThisState[k];
4331 				v->DETBufferSizeYAllStates[i][j][k] = v->DETBufferSizeYThisState[k];
4332 				v->DETBufferSizeCAllStates[i][j][k] = v->DETBufferSizeCThisState[k];
4333 			}
4334 
4335 		}
4336 	}
4337 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4338 		v->cursor_bw[k] = v->NumberOfCursors[k] * v->CursorWidth[k][0] * v->CursorBPP[k][0] / 8.0 / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
4339 	}
4340 
4341 	for (i = start_state; i < v->soc.num_states; i++) {
4342 		for (j = 0; j < 2; j++) {
4343 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4344 				v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
4345 				v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
4346 				v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
4347 				v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
4348 				v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
4349 				v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
4350 				v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
4351 				v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
4352 			}
4353 
4354 			v->TotalNumberOfDCCActiveDPP[i][j] = 0;
4355 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4356 				if (v->DCCEnable[k] == true) {
4357 					v->TotalNumberOfDCCActiveDPP[i][j] = v->TotalNumberOfDCCActiveDPP[i][j] + v->NoOfDPP[i][j][k];
4358 				}
4359 			}
4360 
4361 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4362 				if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12
4363 						|| v->SourcePixelFormat[k] == dm_rgbe_alpha) {
4364 
4365 					if ((v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) && v->SourceScan[k] != dm_vert) {
4366 						v->PTEBufferSizeInRequestsForLuma = (v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma) / 2;
4367 						v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsForLuma;
4368 					} else {
4369 						v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma;
4370 						v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsChroma;
4371 					}
4372 
4373 					v->PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
4374 							mode_lib,
4375 							v->DCCEnable[k],
4376 							v->Read256BlockHeightC[k],
4377 							v->Read256BlockWidthY[k],
4378 							v->SourcePixelFormat[k],
4379 							v->SurfaceTiling[k],
4380 							v->BytePerPixelC[k],
4381 							v->SourceScan[k],
4382 							v->SwathWidthCThisState[k],
4383 							v->ViewportHeightChroma[k],
4384 							v->GPUVMEnable,
4385 							v->HostVMEnable,
4386 							v->HostVMMaxNonCachedPageTableLevels,
4387 							v->GPUVMMinPageSize,
4388 							v->HostVMMinPageSize,
4389 							v->PTEBufferSizeInRequestsForChroma,
4390 							v->PitchC[k],
4391 							0.0,
4392 							&v->MacroTileWidthC[k],
4393 							&v->MetaRowBytesC,
4394 							&v->DPTEBytesPerRowC,
4395 							&v->PTEBufferSizeNotExceededC[i][j][k],
4396 							&v->dummyinteger7,
4397 							&v->dpte_row_height_chroma[k],
4398 							&v->dummyinteger28,
4399 							&v->dummyinteger26,
4400 							&v->dummyinteger23,
4401 							&v->meta_row_height_chroma[k],
4402 							&v->dummyinteger8,
4403 							&v->dummyinteger9,
4404 							&v->dummyinteger19,
4405 							&v->dummyinteger20,
4406 							&v->dummyinteger17,
4407 							&v->dummyinteger10,
4408 							&v->dummyinteger11);
4409 
4410 					v->PrefetchLinesC[i][j][k] = CalculatePrefetchSourceLines(
4411 							mode_lib,
4412 							v->VRatioChroma[k],
4413 							v->VTAPsChroma[k],
4414 							v->Interlace[k],
4415 							v->ProgressiveToInterlaceUnitInOPP,
4416 							v->SwathHeightCThisState[k],
4417 							v->ViewportYStartC[k],
4418 							&v->PrefillC[k],
4419 							&v->MaxNumSwC[k]);
4420 				} else {
4421 					v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma;
4422 					v->PTEBufferSizeInRequestsForChroma = 0;
4423 					v->PDEAndMetaPTEBytesPerFrameC = 0.0;
4424 					v->MetaRowBytesC = 0.0;
4425 					v->DPTEBytesPerRowC = 0.0;
4426 					v->PrefetchLinesC[i][j][k] = 0.0;
4427 					v->PTEBufferSizeNotExceededC[i][j][k] = true;
4428 				}
4429 				v->PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
4430 						mode_lib,
4431 						v->DCCEnable[k],
4432 						v->Read256BlockHeightY[k],
4433 						v->Read256BlockWidthY[k],
4434 						v->SourcePixelFormat[k],
4435 						v->SurfaceTiling[k],
4436 						v->BytePerPixelY[k],
4437 						v->SourceScan[k],
4438 						v->SwathWidthYThisState[k],
4439 						v->ViewportHeight[k],
4440 						v->GPUVMEnable,
4441 						v->HostVMEnable,
4442 						v->HostVMMaxNonCachedPageTableLevels,
4443 						v->GPUVMMinPageSize,
4444 						v->HostVMMinPageSize,
4445 						v->PTEBufferSizeInRequestsForLuma,
4446 						v->PitchY[k],
4447 						v->DCCMetaPitchY[k],
4448 						&v->MacroTileWidthY[k],
4449 						&v->MetaRowBytesY,
4450 						&v->DPTEBytesPerRowY,
4451 						&v->PTEBufferSizeNotExceededY[i][j][k],
4452 						v->dummyinteger4,
4453 						&v->dpte_row_height[k],
4454 						&v->dummyinteger29,
4455 						&v->dummyinteger27,
4456 						&v->dummyinteger24,
4457 						&v->meta_row_height[k],
4458 						&v->dummyinteger25,
4459 						&v->dpte_group_bytes[k],
4460 						&v->dummyinteger21,
4461 						&v->dummyinteger22,
4462 						&v->dummyinteger18,
4463 						&v->dummyinteger5,
4464 						&v->dummyinteger6);
4465 				v->PrefetchLinesY[i][j][k] = CalculatePrefetchSourceLines(
4466 						mode_lib,
4467 						v->VRatio[k],
4468 						v->vtaps[k],
4469 						v->Interlace[k],
4470 						v->ProgressiveToInterlaceUnitInOPP,
4471 						v->SwathHeightYThisState[k],
4472 						v->ViewportYStartY[k],
4473 						&v->PrefillY[k],
4474 						&v->MaxNumSwY[k]);
4475 				v->PDEAndMetaPTEBytesPerFrame[i][j][k] = v->PDEAndMetaPTEBytesPerFrameY + v->PDEAndMetaPTEBytesPerFrameC;
4476 				v->MetaRowBytes[i][j][k] = v->MetaRowBytesY + v->MetaRowBytesC;
4477 				v->DPTEBytesPerRow[i][j][k] = v->DPTEBytesPerRowY + v->DPTEBytesPerRowC;
4478 
4479 				CalculateRowBandwidth(
4480 						v->GPUVMEnable,
4481 						v->SourcePixelFormat[k],
4482 						v->VRatio[k],
4483 						v->VRatioChroma[k],
4484 						v->DCCEnable[k],
4485 						v->HTotal[k] / v->PixelClock[k],
4486 						v->MetaRowBytesY,
4487 						v->MetaRowBytesC,
4488 						v->meta_row_height[k],
4489 						v->meta_row_height_chroma[k],
4490 						v->DPTEBytesPerRowY,
4491 						v->DPTEBytesPerRowC,
4492 						v->dpte_row_height[k],
4493 						v->dpte_row_height_chroma[k],
4494 						&v->meta_row_bandwidth[i][j][k],
4495 						&v->dpte_row_bandwidth[i][j][k]);
4496 			}
4497 			v->UrgLatency[i] = CalculateUrgentLatency(
4498 					v->UrgentLatencyPixelDataOnly,
4499 					v->UrgentLatencyPixelMixedWithVMData,
4500 					v->UrgentLatencyVMDataOnly,
4501 					v->DoUrgentLatencyAdjustment,
4502 					v->UrgentLatencyAdjustmentFabricClockComponent,
4503 					v->UrgentLatencyAdjustmentFabricClockReference,
4504 					v->FabricClockPerState[i]);
4505 
4506 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4507 				CalculateUrgentBurstFactor(
4508 						v->swath_width_luma_ub_this_state[k],
4509 						v->swath_width_chroma_ub_this_state[k],
4510 						v->DETBufferSizeInKByte[0],
4511 						v->SwathHeightYThisState[k],
4512 						v->SwathHeightCThisState[k],
4513 						v->HTotal[k] / v->PixelClock[k],
4514 						v->UrgLatency[i],
4515 						v->CursorBufferSize,
4516 						v->CursorWidth[k][0],
4517 						v->CursorBPP[k][0],
4518 						v->VRatio[k],
4519 						v->VRatioChroma[k],
4520 						v->BytePerPixelInDETY[k],
4521 						v->BytePerPixelInDETC[k],
4522 						v->DETBufferSizeYThisState[k],
4523 						v->DETBufferSizeCThisState[k],
4524 						&v->UrgentBurstFactorCursor[k],
4525 						&v->UrgentBurstFactorLuma[k],
4526 						&v->UrgentBurstFactorChroma[k],
4527 						&NotUrgentLatencyHiding[k]);
4528 			}
4529 
4530 			v->NotUrgentLatencyHiding[i][j] = false;
4531 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4532 				if (NotUrgentLatencyHiding[k]) {
4533 					v->NotUrgentLatencyHiding[i][j] = true;
4534 				}
4535 			}
4536 
4537 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4538 				v->VActivePixelBandwidth[i][j][k] = v->ReadBandwidthLuma[k] * v->UrgentBurstFactorLuma[k]
4539 						+ v->ReadBandwidthChroma[k] * v->UrgentBurstFactorChroma[k];
4540 				v->VActiveCursorBandwidth[i][j][k] = v->cursor_bw[k] * v->UrgentBurstFactorCursor[k];
4541 			}
4542 
4543 			v->TotalVActivePixelBandwidth[i][j] = 0;
4544 			v->TotalVActiveCursorBandwidth[i][j] = 0;
4545 			v->TotalMetaRowBandwidth[i][j] = 0;
4546 			v->TotalDPTERowBandwidth[i][j] = 0;
4547 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4548 				v->TotalVActivePixelBandwidth[i][j] = v->TotalVActivePixelBandwidth[i][j] + v->VActivePixelBandwidth[i][j][k];
4549 				v->TotalVActiveCursorBandwidth[i][j] = v->TotalVActiveCursorBandwidth[i][j] + v->VActiveCursorBandwidth[i][j][k];
4550 				v->TotalMetaRowBandwidth[i][j] = v->TotalMetaRowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->meta_row_bandwidth[i][j][k];
4551 				v->TotalDPTERowBandwidth[i][j] = v->TotalDPTERowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->dpte_row_bandwidth[i][j][k];
4552 			}
4553 
4554 			CalculateDCFCLKDeepSleep(
4555 					mode_lib,
4556 					v->NumberOfActivePlanes,
4557 					v->BytePerPixelY,
4558 					v->BytePerPixelC,
4559 					v->VRatio,
4560 					v->VRatioChroma,
4561 					v->SwathWidthYThisState,
4562 					v->SwathWidthCThisState,
4563 					v->NoOfDPPThisState,
4564 					v->HRatio,
4565 					v->HRatioChroma,
4566 					v->PixelClock,
4567 					v->PSCL_FACTOR,
4568 					v->PSCL_FACTOR_CHROMA,
4569 					v->RequiredDPPCLKThisState,
4570 					v->ReadBandwidthLuma,
4571 					v->ReadBandwidthChroma,
4572 					v->ReturnBusWidth,
4573 					&v->ProjectedDCFCLKDeepSleep[i][j]);
4574 		}
4575 	}
4576 
4577 	//Calculate Return BW
4578 
4579 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4580 		for (j = 0; j <= 1; ++j) {
4581 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4582 				if (v->BlendingAndTiming[k] == k) {
4583 					if (v->WritebackEnable[k] == true) {
4584 						v->WritebackDelayTime[k] = v->WritebackLatency
4585 								+ CalculateWriteBackDelay(
4586 										v->WritebackPixelFormat[k],
4587 										v->WritebackHRatio[k],
4588 										v->WritebackVRatio[k],
4589 										v->WritebackVTaps[k],
4590 										v->WritebackDestinationWidth[k],
4591 										v->WritebackDestinationHeight[k],
4592 										v->WritebackSourceHeight[k],
4593 										v->HTotal[k]) / v->RequiredDISPCLK[i][j];
4594 					} else {
4595 						v->WritebackDelayTime[k] = 0.0;
4596 					}
4597 					for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4598 						if (v->BlendingAndTiming[m] == k && v->WritebackEnable[m] == true) {
4599 							v->WritebackDelayTime[k] = dml_max(
4600 									v->WritebackDelayTime[k],
4601 									v->WritebackLatency
4602 											+ CalculateWriteBackDelay(
4603 													v->WritebackPixelFormat[m],
4604 													v->WritebackHRatio[m],
4605 													v->WritebackVRatio[m],
4606 													v->WritebackVTaps[m],
4607 													v->WritebackDestinationWidth[m],
4608 													v->WritebackDestinationHeight[m],
4609 													v->WritebackSourceHeight[m],
4610 													v->HTotal[m]) / v->RequiredDISPCLK[i][j]);
4611 						}
4612 					}
4613 				}
4614 			}
4615 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4616 				for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4617 					if (v->BlendingAndTiming[k] == m) {
4618 						v->WritebackDelayTime[k] = v->WritebackDelayTime[m];
4619 					}
4620 				}
4621 			}
4622 			v->MaxMaxVStartup[i][j] = 0;
4623 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4624 				v->MaximumVStartup[i][j][k] = v->VTotal[k] - v->VActive[k]
4625 						- dml_max(1.0, dml_ceil(1.0 * v->WritebackDelayTime[k] / (v->HTotal[k] / v->PixelClock[k]), 1.0));
4626 				v->MaxMaxVStartup[i][j] = dml_max(v->MaxMaxVStartup[i][j], v->MaximumVStartup[i][j][k]);
4627 			}
4628 		}
4629 	}
4630 
4631 	ReorderingBytes = v->NumberOfChannels
4632 			* dml_max3(
4633 					v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
4634 					v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
4635 					v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
4636 	v->FinalDRAMClockChangeLatency = (v->DRAMClockChangeLatencyOverride > 0 ? v->DRAMClockChangeLatencyOverride : v->DRAMClockChangeLatency);
4637 
4638 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4639 		for (j = 0; j <= 1; ++j) {
4640 			v->DCFCLKState[i][j] = v->DCFCLKPerState[i];
4641 		}
4642 	}
4643 
4644 	if (v->UseMinimumRequiredDCFCLK == true) {
4645 		UseMinimumDCFCLK(mode_lib, v, MaxPrefetchMode, ReorderingBytes);
4646 
4647 		if (v->ClampMinDCFCLK) {
4648 			/* Clamp calculated values to actual minimum */
4649 			for (i = 0; i < mode_lib->soc.num_states; ++i) {
4650 				for (j = 0; j <= 1; ++j) {
4651 					if (v->DCFCLKState[i][j] < mode_lib->soc.min_dcfclk) {
4652 						v->DCFCLKState[i][j] = mode_lib->soc.min_dcfclk;
4653 					}
4654 				}
4655 			}
4656 		}
4657 	}
4658 
4659 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4660 		for (j = 0; j <= 1; ++j) {
4661 			v->IdealSDPPortBandwidthPerState[i][j] = dml_min3(
4662 					v->ReturnBusWidth * v->DCFCLKState[i][j],
4663 					v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth,
4664 					v->FabricClockPerState[i] * v->FabricDatapathToDCNDataReturn);
4665 			if (v->HostVMEnable != true) {
4666 				v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly
4667 						/ 100;
4668 			} else {
4669 				v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j]
4670 						* v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / 100;
4671 			}
4672 		}
4673 	}
4674 
4675 	//Re-ordering Buffer Support Check
4676 
4677 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4678 		for (j = 0; j <= 1; ++j) {
4679 			if ((v->ROBBufferSizeInKByte - v->PixelChunkSizeInKByte) * 1024 / v->ReturnBWPerState[i][j]
4680 					> (v->RoundTripPingLatencyCycles + 32) / v->DCFCLKState[i][j] + ReorderingBytes / v->ReturnBWPerState[i][j]) {
4681 				v->ROBSupport[i][j] = true;
4682 			} else {
4683 				v->ROBSupport[i][j] = false;
4684 			}
4685 		}
4686 	}
4687 
4688 	//Vertical Active BW support check
4689 
4690 	MaxTotalVActiveRDBandwidth = 0;
4691 	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4692 		MaxTotalVActiveRDBandwidth = MaxTotalVActiveRDBandwidth + v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
4693 	}
4694 
4695 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4696 		for (j = 0; j <= 1; ++j) {
4697 			v->MaxTotalVerticalActiveAvailableBandwidth[i][j] = dml_min(
4698 					v->IdealSDPPortBandwidthPerState[i][j] * v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
4699 					v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth * v->MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation
4700 							/ 100);
4701 			if (MaxTotalVActiveRDBandwidth <= v->MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
4702 				v->TotalVerticalActiveBandwidthSupport[i][j] = true;
4703 			} else {
4704 				v->TotalVerticalActiveBandwidthSupport[i][j] = false;
4705 			}
4706 		}
4707 	}
4708 
4709 	//Prefetch Check
4710 
4711 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
4712 		for (j = 0; j <= 1; ++j) {
4713 			int NextPrefetchModeState = MinPrefetchMode;
4714 
4715 			v->TimeCalc = 24 / v->ProjectedDCFCLKDeepSleep[i][j];
4716 
4717 			v->BandwidthWithoutPrefetchSupported[i][j] = true;
4718 			if (v->TotalVActivePixelBandwidth[i][j] + v->TotalVActiveCursorBandwidth[i][j] + v->TotalMetaRowBandwidth[i][j] + v->TotalDPTERowBandwidth[i][j]
4719 					> v->ReturnBWPerState[i][j] || v->NotUrgentLatencyHiding[i][j]) {
4720 				v->BandwidthWithoutPrefetchSupported[i][j] = false;
4721 			}
4722 
4723 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4724 				v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
4725 				v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
4726 				v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
4727 				v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
4728 				v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
4729 				v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
4730 				v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
4731 				v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
4732 				v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
4733 				v->ODMCombineEnabled[k] = v->ODMCombineEnablePerState[i][k];
4734 			}
4735 
4736 			v->ExtraLatency = CalculateExtraLatency(
4737 					v->RoundTripPingLatencyCycles,
4738 					ReorderingBytes,
4739 					v->DCFCLKState[i][j],
4740 					v->TotalNumberOfActiveDPP[i][j],
4741 					v->PixelChunkSizeInKByte,
4742 					v->TotalNumberOfDCCActiveDPP[i][j],
4743 					v->MetaChunkSize,
4744 					v->ReturnBWPerState[i][j],
4745 					v->GPUVMEnable,
4746 					v->HostVMEnable,
4747 					v->NumberOfActivePlanes,
4748 					v->NoOfDPPThisState,
4749 					v->dpte_group_bytes,
4750 					v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4751 					v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4752 					v->HostVMMinPageSize,
4753 					v->HostVMMaxNonCachedPageTableLevels);
4754 
4755 			v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
4756 			do {
4757 				v->PrefetchModePerState[i][j] = NextPrefetchModeState;
4758 				v->MaxVStartup = v->NextMaxVStartup;
4759 
4760 				v->TWait = CalculateTWait(v->PrefetchModePerState[i][j], v->FinalDRAMClockChangeLatency, v->UrgLatency[i], v->SREnterPlusExitTime);
4761 
4762 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4763 					Pipe myPipe = { 0 };
4764 
4765 					myPipe.DPPCLK = v->RequiredDPPCLK[i][j][k];
4766 					myPipe.DISPCLK = v->RequiredDISPCLK[i][j];
4767 					myPipe.PixelClock = v->PixelClock[k];
4768 					myPipe.DCFCLKDeepSleep = v->ProjectedDCFCLKDeepSleep[i][j];
4769 					myPipe.DPPPerPlane = v->NoOfDPP[i][j][k];
4770 					myPipe.ScalerEnabled = v->ScalerEnabled[k];
4771 					myPipe.SourceScan = v->SourceScan[k];
4772 					myPipe.BlockWidth256BytesY = v->Read256BlockWidthY[k];
4773 					myPipe.BlockHeight256BytesY = v->Read256BlockHeightY[k];
4774 					myPipe.BlockWidth256BytesC = v->Read256BlockWidthC[k];
4775 					myPipe.BlockHeight256BytesC = v->Read256BlockHeightC[k];
4776 					myPipe.InterlaceEnable = v->Interlace[k];
4777 					myPipe.NumberOfCursors = v->NumberOfCursors[k];
4778 					myPipe.VBlank = v->VTotal[k] - v->VActive[k];
4779 					myPipe.HTotal = v->HTotal[k];
4780 					myPipe.DCCEnable = v->DCCEnable[k];
4781 					myPipe.ODMCombineEnabled = !!v->ODMCombineEnabled[k];
4782 
4783 					v->NoTimeForPrefetch[i][j][k] = CalculatePrefetchSchedule(
4784 							mode_lib,
4785 							v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4786 							v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4787 							&myPipe,
4788 							v->DSCDelayPerState[i][k],
4789 							v->DPPCLKDelaySubtotal + v->DPPCLKDelayCNVCFormater,
4790 							v->DPPCLKDelaySCL,
4791 							v->DPPCLKDelaySCLLBOnly,
4792 							v->DPPCLKDelayCNVCCursor,
4793 							v->DISPCLKDelaySubtotal,
4794 							v->SwathWidthYThisState[k] / v->HRatio[k],
4795 							v->OutputFormat[k],
4796 							v->MaxInterDCNTileRepeaters,
4797 							dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
4798 							v->MaximumVStartup[i][j][k],
4799 							v->GPUVMMaxPageTableLevels,
4800 							v->GPUVMEnable,
4801 							v->HostVMEnable,
4802 							v->HostVMMaxNonCachedPageTableLevels,
4803 							v->HostVMMinPageSize,
4804 							v->DynamicMetadataEnable[k],
4805 							v->DynamicMetadataVMEnabled,
4806 							v->DynamicMetadataLinesBeforeActiveRequired[k],
4807 							v->DynamicMetadataTransmittedBytes[k],
4808 							v->UrgLatency[i],
4809 							v->ExtraLatency,
4810 							v->TimeCalc,
4811 							v->PDEAndMetaPTEBytesPerFrame[i][j][k],
4812 							v->MetaRowBytes[i][j][k],
4813 							v->DPTEBytesPerRow[i][j][k],
4814 							v->PrefetchLinesY[i][j][k],
4815 							v->SwathWidthYThisState[k],
4816 							v->BytePerPixelY[k],
4817 							v->PrefillY[k],
4818 							v->MaxNumSwY[k],
4819 							v->PrefetchLinesC[i][j][k],
4820 							v->SwathWidthCThisState[k],
4821 							v->BytePerPixelC[k],
4822 							v->PrefillC[k],
4823 							v->MaxNumSwC[k],
4824 							v->swath_width_luma_ub_this_state[k],
4825 							v->swath_width_chroma_ub_this_state[k],
4826 							v->SwathHeightYThisState[k],
4827 							v->SwathHeightCThisState[k],
4828 							v->TWait,
4829 							v->ProgressiveToInterlaceUnitInOPP,
4830 							&v->DSTXAfterScaler[k],
4831 							&v->DSTYAfterScaler[k],
4832 							&v->LineTimesForPrefetch[k],
4833 							&v->PrefetchBW[k],
4834 							&v->LinesForMetaPTE[k],
4835 							&v->LinesForMetaAndDPTERow[k],
4836 							&v->VRatioPreY[i][j][k],
4837 							&v->VRatioPreC[i][j][k],
4838 							&v->RequiredPrefetchPixelDataBWLuma[i][j][k],
4839 							&v->RequiredPrefetchPixelDataBWChroma[i][j][k],
4840 							&v->NoTimeForDynamicMetadata[i][j][k],
4841 							&v->Tno_bw[k],
4842 							&v->prefetch_vmrow_bw[k],
4843 							&v->Tdmdl_vm[k],
4844 							&v->Tdmdl[k],
4845 							&v->VUpdateOffsetPix[k],
4846 							&v->VUpdateWidthPix[k],
4847 							&v->VReadyOffsetPix[k]);
4848 				}
4849 
4850 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4851 					CalculateUrgentBurstFactor(
4852 							v->swath_width_luma_ub_this_state[k],
4853 							v->swath_width_chroma_ub_this_state[k],
4854 							v->DETBufferSizeInKByte[0],
4855 							v->SwathHeightYThisState[k],
4856 							v->SwathHeightCThisState[k],
4857 							v->HTotal[k] / v->PixelClock[k],
4858 							v->UrgLatency[i],
4859 							v->CursorBufferSize,
4860 							v->CursorWidth[k][0],
4861 							v->CursorBPP[k][0],
4862 							v->VRatioPreY[i][j][k],
4863 							v->VRatioPreC[i][j][k],
4864 							v->BytePerPixelInDETY[k],
4865 							v->BytePerPixelInDETC[k],
4866 							v->DETBufferSizeYThisState[k],
4867 							v->DETBufferSizeCThisState[k],
4868 							&v->UrgentBurstFactorCursorPre[k],
4869 							&v->UrgentBurstFactorLumaPre[k],
4870 							&v->UrgentBurstFactorChromaPre[k],
4871 							&v->NoUrgentLatencyHidingPre[k]);
4872 				}
4873 
4874 				v->MaximumReadBandwidthWithPrefetch = 0.0;
4875 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4876 					v->cursor_bw_pre[k] = v->NumberOfCursors[k] * v->CursorWidth[k][0] * v->CursorBPP[k][0] / 8.0 / (v->HTotal[k] / v->PixelClock[k])
4877 							* v->VRatioPreY[i][j][k];
4878 
4879 					v->MaximumReadBandwidthWithPrefetch = v->MaximumReadBandwidthWithPrefetch
4880 							+ dml_max4(
4881 									v->VActivePixelBandwidth[i][j][k],
4882 									v->VActiveCursorBandwidth[i][j][k]
4883 											+ v->NoOfDPP[i][j][k] * (v->meta_row_bandwidth[i][j][k] + v->dpte_row_bandwidth[i][j][k]),
4884 									v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
4885 									v->NoOfDPP[i][j][k]
4886 											* (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
4887 													+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
4888 															* v->UrgentBurstFactorChromaPre[k])
4889 											+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
4890 				}
4891 
4892 				v->NotEnoughUrgentLatencyHidingPre = false;
4893 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4894 					if (v->NoUrgentLatencyHidingPre[k] == true) {
4895 						v->NotEnoughUrgentLatencyHidingPre = true;
4896 					}
4897 				}
4898 
4899 				v->PrefetchSupported[i][j] = true;
4900 				if (v->BandwidthWithoutPrefetchSupported[i][j] == false || v->MaximumReadBandwidthWithPrefetch > v->ReturnBWPerState[i][j]
4901 						|| v->NotEnoughUrgentLatencyHidingPre == 1) {
4902 					v->PrefetchSupported[i][j] = false;
4903 				}
4904 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4905 					if (v->LineTimesForPrefetch[k] < 2.0 || v->LinesForMetaPTE[k] >= 32.0 || v->LinesForMetaAndDPTERow[k] >= 16.0
4906 							|| v->NoTimeForPrefetch[i][j][k] == true) {
4907 						v->PrefetchSupported[i][j] = false;
4908 					}
4909 				}
4910 
4911 				v->DynamicMetadataSupported[i][j] = true;
4912 				for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4913 					if (v->NoTimeForDynamicMetadata[i][j][k] == true) {
4914 						v->DynamicMetadataSupported[i][j] = false;
4915 					}
4916 				}
4917 
4918 				v->VRatioInPrefetchSupported[i][j] = true;
4919 				for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4920 					if (v->VRatioPreY[i][j][k] > 4.0 || v->VRatioPreC[i][j][k] > 4.0 || v->NoTimeForPrefetch[i][j][k] == true) {
4921 						v->VRatioInPrefetchSupported[i][j] = false;
4922 					}
4923 				}
4924 				v->AnyLinesForVMOrRowTooLarge = false;
4925 				for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4926 					if (v->LinesForMetaAndDPTERow[k] >= 16 || v->LinesForMetaPTE[k] >= 32) {
4927 						v->AnyLinesForVMOrRowTooLarge = true;
4928 					}
4929 				}
4930 
4931 				if (v->PrefetchSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true) {
4932 					v->BandwidthAvailableForImmediateFlip = v->ReturnBWPerState[i][j];
4933 					for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4934 						v->BandwidthAvailableForImmediateFlip = v->BandwidthAvailableForImmediateFlip
4935 								- dml_max(
4936 										v->VActivePixelBandwidth[i][j][k] + v->VActiveCursorBandwidth[i][j][k],
4937 										v->NoOfDPP[i][j][k]
4938 												* (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
4939 														+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
4940 																* v->UrgentBurstFactorChromaPre[k])
4941 												+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
4942 					}
4943 					v->TotImmediateFlipBytes = 0.0;
4944 					for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4945 						v->TotImmediateFlipBytes = v->TotImmediateFlipBytes + v->NoOfDPP[i][j][k] * (v->PDEAndMetaPTEBytesPerFrame[i][j][k]
4946 								+ v->MetaRowBytes[i][j][k] + v->DPTEBytesPerRow[i][j][k]);
4947 					}
4948 
4949 					for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4950 						CalculateFlipSchedule(
4951 								mode_lib,
4952 								v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4953 								v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4954 								v->ExtraLatency,
4955 								v->UrgLatency[i],
4956 								v->GPUVMMaxPageTableLevels,
4957 								v->HostVMEnable,
4958 								v->HostVMMaxNonCachedPageTableLevels,
4959 								v->GPUVMEnable,
4960 								v->HostVMMinPageSize,
4961 								v->PDEAndMetaPTEBytesPerFrame[i][j][k],
4962 								v->MetaRowBytes[i][j][k],
4963 								v->DPTEBytesPerRow[i][j][k],
4964 								v->BandwidthAvailableForImmediateFlip,
4965 								v->TotImmediateFlipBytes,
4966 								v->SourcePixelFormat[k],
4967 								v->HTotal[k] / v->PixelClock[k],
4968 								v->VRatio[k],
4969 								v->VRatioChroma[k],
4970 								v->Tno_bw[k],
4971 								v->DCCEnable[k],
4972 								v->dpte_row_height[k],
4973 								v->meta_row_height[k],
4974 								v->dpte_row_height_chroma[k],
4975 								v->meta_row_height_chroma[k],
4976 								&v->DestinationLinesToRequestVMInImmediateFlip[k],
4977 								&v->DestinationLinesToRequestRowInImmediateFlip[k],
4978 								&v->final_flip_bw[k],
4979 								&v->ImmediateFlipSupportedForPipe[k]);
4980 					}
4981 					v->total_dcn_read_bw_with_flip = 0.0;
4982 					for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4983 						v->total_dcn_read_bw_with_flip = v->total_dcn_read_bw_with_flip
4984 								+ dml_max3(
4985 										v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
4986 										v->NoOfDPP[i][j][k] * v->final_flip_bw[k] + v->VActivePixelBandwidth[i][j][k]
4987 												+ v->VActiveCursorBandwidth[i][j][k],
4988 										v->NoOfDPP[i][j][k]
4989 												* (v->final_flip_bw[k]
4990 														+ v->RequiredPrefetchPixelDataBWLuma[i][j][k]
4991 																* v->UrgentBurstFactorLumaPre[k]
4992 														+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
4993 																* v->UrgentBurstFactorChromaPre[k])
4994 												+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
4995 					}
4996 					v->ImmediateFlipSupportedForState[i][j] = true;
4997 					if (v->total_dcn_read_bw_with_flip > v->ReturnBWPerState[i][j]) {
4998 						v->ImmediateFlipSupportedForState[i][j] = false;
4999 					}
5000 					for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5001 						if (v->ImmediateFlipSupportedForPipe[k] == false) {
5002 							v->ImmediateFlipSupportedForState[i][j] = false;
5003 						}
5004 					}
5005 				} else {
5006 					v->ImmediateFlipSupportedForState[i][j] = false;
5007 				}
5008 				if (v->MaxVStartup <= 13 || v->AnyLinesForVMOrRowTooLarge == false) {
5009 					v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
5010 					NextPrefetchModeState = NextPrefetchModeState + 1;
5011 				} else {
5012 					v->NextMaxVStartup = v->NextMaxVStartup - 1;
5013 				}
5014 			} while (!((v->PrefetchSupported[i][j] == true && v->DynamicMetadataSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true
5015 					&& ((v->HostVMEnable == false && v->ImmediateFlipRequirement[0] != dm_immediate_flip_required)
5016 							|| v->ImmediateFlipSupportedForState[i][j] == true))
5017 					|| (v->NextMaxVStartup == v->MaxMaxVStartup[i][j] && NextPrefetchModeState > MaxPrefetchMode)));
5018 
5019 			CalculateWatermarksAndDRAMSpeedChangeSupport(
5020 					mode_lib,
5021 					v->PrefetchModePerState[i][j],
5022 					v->NumberOfActivePlanes,
5023 					v->MaxLineBufferLines,
5024 					v->LineBufferSize,
5025 					v->DPPOutputBufferPixels,
5026 					v->DETBufferSizeInKByte[0],
5027 					v->WritebackInterfaceBufferSize,
5028 					v->DCFCLKState[i][j],
5029 					v->ReturnBWPerState[i][j],
5030 					v->GPUVMEnable,
5031 					v->dpte_group_bytes,
5032 					v->MetaChunkSize,
5033 					v->UrgLatency[i],
5034 					v->ExtraLatency,
5035 					v->WritebackLatency,
5036 					v->WritebackChunkSize,
5037 					v->SOCCLKPerState[i],
5038 					v->FinalDRAMClockChangeLatency,
5039 					v->SRExitTime,
5040 					v->SREnterPlusExitTime,
5041 					v->ProjectedDCFCLKDeepSleep[i][j],
5042 					v->NoOfDPPThisState,
5043 					v->DCCEnable,
5044 					v->RequiredDPPCLKThisState,
5045 					v->DETBufferSizeYThisState,
5046 					v->DETBufferSizeCThisState,
5047 					v->SwathHeightYThisState,
5048 					v->SwathHeightCThisState,
5049 					v->LBBitPerPixel,
5050 					v->SwathWidthYThisState,
5051 					v->SwathWidthCThisState,
5052 					v->HRatio,
5053 					v->HRatioChroma,
5054 					v->vtaps,
5055 					v->VTAPsChroma,
5056 					v->VRatio,
5057 					v->VRatioChroma,
5058 					v->HTotal,
5059 					v->PixelClock,
5060 					v->BlendingAndTiming,
5061 					v->BytePerPixelInDETY,
5062 					v->BytePerPixelInDETC,
5063 					v->DSTXAfterScaler,
5064 					v->DSTYAfterScaler,
5065 					v->WritebackEnable,
5066 					v->WritebackPixelFormat,
5067 					v->WritebackDestinationWidth,
5068 					v->WritebackDestinationHeight,
5069 					v->WritebackSourceHeight,
5070 					&v->DRAMClockChangeSupport[i][j],
5071 					&v->UrgentWatermark,
5072 					&v->WritebackUrgentWatermark,
5073 					&v->DRAMClockChangeWatermark,
5074 					&v->WritebackDRAMClockChangeWatermark,
5075 					&v->StutterExitWatermark,
5076 					&v->StutterEnterPlusExitWatermark,
5077 					&v->MinActiveDRAMClockChangeLatencySupported);
5078 		}
5079 	}
5080 
5081 	/*PTE Buffer Size Check*/
5082 
5083 	for (i = start_state; i < v->soc.num_states; i++) {
5084 		for (j = 0; j < 2; j++) {
5085 			v->PTEBufferSizeNotExceeded[i][j] = true;
5086 			for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5087 				if (v->PTEBufferSizeNotExceededY[i][j][k] == false || v->PTEBufferSizeNotExceededC[i][j][k] == false) {
5088 					v->PTEBufferSizeNotExceeded[i][j] = false;
5089 				}
5090 			}
5091 		}
5092 	}
5093 	/*Cursor Support Check*/
5094 
5095 	v->CursorSupport = true;
5096 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5097 		if (v->CursorWidth[k][0] > 0.0) {
5098 			if (v->CursorBPP[k][0] == 64 && v->Cursor64BppSupport == false) {
5099 				v->CursorSupport = false;
5100 			}
5101 		}
5102 	}
5103 	/*Valid Pitch Check*/
5104 
5105 	v->PitchSupport = true;
5106 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5107 		v->AlignedYPitch[k] = dml_ceil(dml_max(v->PitchY[k], v->SurfaceWidthY[k]), v->MacroTileWidthY[k]);
5108 		if (v->DCCEnable[k] == true) {
5109 			v->AlignedDCCMetaPitchY[k] = dml_ceil(dml_max(v->DCCMetaPitchY[k], v->SurfaceWidthY[k]), 64.0 * v->Read256BlockWidthY[k]);
5110 		} else {
5111 			v->AlignedDCCMetaPitchY[k] = v->DCCMetaPitchY[k];
5112 		}
5113 		if (v->SourcePixelFormat[k] != dm_444_64 && v->SourcePixelFormat[k] != dm_444_32 && v->SourcePixelFormat[k] != dm_444_16 && v->SourcePixelFormat[k] != dm_mono_16
5114 				&& v->SourcePixelFormat[k] != dm_rgbe && v->SourcePixelFormat[k] != dm_mono_8) {
5115 			v->AlignedCPitch[k] = dml_ceil(dml_max(v->PitchC[k], v->SurfaceWidthC[k]), v->MacroTileWidthC[k]);
5116 			if (v->DCCEnable[k] == true) {
5117 				v->AlignedDCCMetaPitchC[k] = dml_ceil(dml_max(v->DCCMetaPitchC[k], v->SurfaceWidthC[k]), 64.0 * v->Read256BlockWidthC[k]);
5118 			} else {
5119 				v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
5120 			}
5121 		} else {
5122 			v->AlignedCPitch[k] = v->PitchC[k];
5123 			v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
5124 		}
5125 		if (v->AlignedYPitch[k] > v->PitchY[k] || v->AlignedCPitch[k] > v->PitchC[k] || v->AlignedDCCMetaPitchY[k] > v->DCCMetaPitchY[k]
5126 				|| v->AlignedDCCMetaPitchC[k] > v->DCCMetaPitchC[k]) {
5127 			v->PitchSupport = false;
5128 		}
5129 	}
5130 
5131 	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5132 		if (v->ViewportWidth[k] > v->SurfaceWidthY[k] || v->ViewportHeight[k] > v->SurfaceHeightY[k])
5133 			ViewportExceedsSurface = true;
5134 
5135 		if (v->SourcePixelFormat[k] != dm_444_64 && v->SourcePixelFormat[k] != dm_444_32 && v->SourcePixelFormat[k] != dm_444_16
5136 				&& v->SourcePixelFormat[k] != dm_444_8 && v->SourcePixelFormat[k] != dm_rgbe) {
5137 			if (v->ViewportWidthChroma[k] > v->SurfaceWidthC[k] || v->ViewportHeightChroma[k] > v->SurfaceHeightC[k]) {
5138 				ViewportExceedsSurface = true;
5139 			}
5140 		}
5141 	}
5142 	/*Mode Support, Voltage State and SOC Configuration*/
5143 
5144 	for (i = v->soc.num_states - 1; i >= start_state; i--) {
5145 		for (j = 0; j < 2; j++) {
5146 			if (v->ScaleRatioAndTapsSupport == 1 && v->SourceFormatPixelAndScanSupport == 1 && v->ViewportSizeSupport[i][j] == 1
5147 					&& v->DIOSupport[i] == 1 && v->ODMCombine4To1SupportCheckOK[i] == 1
5148 					&& v->NotEnoughDSCUnits[i] == 0
5149 					&& v->DTBCLKRequiredMoreThanSupported[i] == 0
5150 					&& v->ROBSupport[i][j] == 1 && v->DISPCLK_DPPCLK_Support[i][j] == 1 && v->TotalAvailablePipesSupport[i][j] == 1
5151 					&& EnoughWritebackUnits == 1 && WritebackModeSupport == 1
5152 					&& v->WritebackLatencySupport == 1 && v->WritebackScaleRatioAndTapsSupport == 1 && v->CursorSupport == 1 && v->PitchSupport == 1
5153 					&& ViewportExceedsSurface == 0 && v->PrefetchSupported[i][j] == 1 && v->DynamicMetadataSupported[i][j] == 1
5154 					&& v->TotalVerticalActiveBandwidthSupport[i][j] == 1 && v->VRatioInPrefetchSupported[i][j] == 1
5155 					&& v->PTEBufferSizeNotExceeded[i][j] == 1 && v->NonsupportedDSCInputBPC == 0
5156 					&& ((v->HostVMEnable == 0 && v->ImmediateFlipRequirement[0] != dm_immediate_flip_required)
5157 							|| v->ImmediateFlipSupportedForState[i][j] == true)) {
5158 				v->ModeSupport[i][j] = true;
5159 			} else {
5160 				v->ModeSupport[i][j] = false;
5161 			}
5162 		}
5163 	}
5164 	{
5165 		unsigned int MaximumMPCCombine = 0;
5166 		for (i = v->soc.num_states; i >= start_state; i--) {
5167 			if (i == v->soc.num_states || v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true) {
5168 				v->VoltageLevel = i;
5169 				v->ModeIsSupported = v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true;
5170 				if (v->ModeSupport[i][1] == true) {
5171 					MaximumMPCCombine = 1;
5172 				} else {
5173 					MaximumMPCCombine = 0;
5174 				}
5175 			}
5176 		}
5177 		v->ImmediateFlipSupport = v->ImmediateFlipSupportedForState[v->VoltageLevel][MaximumMPCCombine];
5178 		for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5179 			v->MPCCombineEnable[k] = v->MPCCombine[v->VoltageLevel][MaximumMPCCombine][k];
5180 			v->DPPPerPlane[k] = v->NoOfDPP[v->VoltageLevel][MaximumMPCCombine][k];
5181 		}
5182 		v->DCFCLK = v->DCFCLKState[v->VoltageLevel][MaximumMPCCombine];
5183 		v->DRAMSpeed = v->DRAMSpeedPerState[v->VoltageLevel];
5184 		v->FabricClock = v->FabricClockPerState[v->VoltageLevel];
5185 		v->SOCCLK = v->SOCCLKPerState[v->VoltageLevel];
5186 		v->ReturnBW = v->ReturnBWPerState[v->VoltageLevel][MaximumMPCCombine];
5187 		v->maxMpcComb = MaximumMPCCombine;
5188 	}
5189 }
5190 
CalculateWatermarksAndDRAMSpeedChangeSupport(struct display_mode_lib * mode_lib,unsigned int PrefetchMode,unsigned int NumberOfActivePlanes,unsigned int MaxLineBufferLines,unsigned int LineBufferSize,unsigned int DPPOutputBufferPixels,unsigned int DETBufferSizeInKByte,unsigned int WritebackInterfaceBufferSize,double DCFCLK,double ReturnBW,bool GPUVMEnable,unsigned int dpte_group_bytes[],unsigned int MetaChunkSize,double UrgentLatency,double ExtraLatency,double WritebackLatency,double WritebackChunkSize,double SOCCLK,double DRAMClockChangeLatency,double SRExitTime,double SREnterPlusExitTime,double DCFCLKDeepSleep,unsigned int DPPPerPlane[],bool DCCEnable[],double DPPCLK[],unsigned int DETBufferSizeY[],unsigned int DETBufferSizeC[],unsigned int SwathHeightY[],unsigned int SwathHeightC[],unsigned int LBBitPerPixel[],double SwathWidthY[],double SwathWidthC[],double HRatio[],double HRatioChroma[],unsigned int vtaps[],unsigned int VTAPsChroma[],double VRatio[],double VRatioChroma[],unsigned int HTotal[],double PixelClock[],unsigned int BlendingAndTiming[],double BytePerPixelDETY[],double BytePerPixelDETC[],double DSTXAfterScaler[],double DSTYAfterScaler[],bool WritebackEnable[],enum source_format_class WritebackPixelFormat[],double WritebackDestinationWidth[],double WritebackDestinationHeight[],double WritebackSourceHeight[],enum clock_change_support * DRAMClockChangeSupport,double * UrgentWatermark,double * WritebackUrgentWatermark,double * DRAMClockChangeWatermark,double * WritebackDRAMClockChangeWatermark,double * StutterExitWatermark,double * StutterEnterPlusExitWatermark,double * MinActiveDRAMClockChangeLatencySupported)5191 static void CalculateWatermarksAndDRAMSpeedChangeSupport(
5192 		struct display_mode_lib *mode_lib,
5193 		unsigned int PrefetchMode,
5194 		unsigned int NumberOfActivePlanes,
5195 		unsigned int MaxLineBufferLines,
5196 		unsigned int LineBufferSize,
5197 		unsigned int DPPOutputBufferPixels,
5198 		unsigned int DETBufferSizeInKByte,
5199 		unsigned int WritebackInterfaceBufferSize,
5200 		double DCFCLK,
5201 		double ReturnBW,
5202 		bool GPUVMEnable,
5203 		unsigned int dpte_group_bytes[],
5204 		unsigned int MetaChunkSize,
5205 		double UrgentLatency,
5206 		double ExtraLatency,
5207 		double WritebackLatency,
5208 		double WritebackChunkSize,
5209 		double SOCCLK,
5210 		double DRAMClockChangeLatency,
5211 		double SRExitTime,
5212 		double SREnterPlusExitTime,
5213 		double DCFCLKDeepSleep,
5214 		unsigned int DPPPerPlane[],
5215 		bool DCCEnable[],
5216 		double DPPCLK[],
5217 		unsigned int DETBufferSizeY[],
5218 		unsigned int DETBufferSizeC[],
5219 		unsigned int SwathHeightY[],
5220 		unsigned int SwathHeightC[],
5221 		unsigned int LBBitPerPixel[],
5222 		double SwathWidthY[],
5223 		double SwathWidthC[],
5224 		double HRatio[],
5225 		double HRatioChroma[],
5226 		unsigned int vtaps[],
5227 		unsigned int VTAPsChroma[],
5228 		double VRatio[],
5229 		double VRatioChroma[],
5230 		unsigned int HTotal[],
5231 		double PixelClock[],
5232 		unsigned int BlendingAndTiming[],
5233 		double BytePerPixelDETY[],
5234 		double BytePerPixelDETC[],
5235 		double DSTXAfterScaler[],
5236 		double DSTYAfterScaler[],
5237 		bool WritebackEnable[],
5238 		enum source_format_class WritebackPixelFormat[],
5239 		double WritebackDestinationWidth[],
5240 		double WritebackDestinationHeight[],
5241 		double WritebackSourceHeight[],
5242 		enum clock_change_support *DRAMClockChangeSupport,
5243 		double *UrgentWatermark,
5244 		double *WritebackUrgentWatermark,
5245 		double *DRAMClockChangeWatermark,
5246 		double *WritebackDRAMClockChangeWatermark,
5247 		double *StutterExitWatermark,
5248 		double *StutterEnterPlusExitWatermark,
5249 		double *MinActiveDRAMClockChangeLatencySupported)
5250 {
5251 	double EffectiveLBLatencyHidingY = 0;
5252 	double EffectiveLBLatencyHidingC = 0;
5253 	double LinesInDETY[DC__NUM_DPP__MAX] = { 0 };
5254 	double LinesInDETC = 0;
5255 	unsigned int LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX] = { 0 };
5256 	unsigned int LinesInDETCRoundedDownToSwath = 0;
5257 	double FullDETBufferingTimeY[DC__NUM_DPP__MAX] = { 0 };
5258 	double FullDETBufferingTimeC = 0;
5259 	double ActiveDRAMClockChangeLatencyMarginY = 0;
5260 	double ActiveDRAMClockChangeLatencyMarginC = 0;
5261 	double WritebackDRAMClockChangeLatencyMargin = 0;
5262 	double PlaneWithMinActiveDRAMClockChangeMargin = 0;
5263 	double SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = 0;
5264 	double FullDETBufferingTimeYStutterCriticalPlane = 0;
5265 	double TimeToFinishSwathTransferStutterCriticalPlane = 0;
5266 	double WritebackDRAMClockChangeLatencyHiding = 0;
5267 	unsigned int k, j;
5268 
5269 	mode_lib->vba.TotalActiveDPP = 0;
5270 	mode_lib->vba.TotalDCCActiveDPP = 0;
5271 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5272 		mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + DPPPerPlane[k];
5273 		if (DCCEnable[k] == true) {
5274 			mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP + DPPPerPlane[k];
5275 		}
5276 	}
5277 
5278 	*UrgentWatermark = UrgentLatency + ExtraLatency;
5279 
5280 	*DRAMClockChangeWatermark = DRAMClockChangeLatency + *UrgentWatermark;
5281 
5282 	mode_lib->vba.TotalActiveWriteback = 0;
5283 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5284 		if (WritebackEnable[k] == true) {
5285 			mode_lib->vba.TotalActiveWriteback = mode_lib->vba.TotalActiveWriteback + 1;
5286 		}
5287 	}
5288 
5289 	if (mode_lib->vba.TotalActiveWriteback <= 1) {
5290 		*WritebackUrgentWatermark = WritebackLatency;
5291 	} else {
5292 		*WritebackUrgentWatermark = WritebackLatency + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
5293 	}
5294 
5295 	if (mode_lib->vba.TotalActiveWriteback <= 1) {
5296 		*WritebackDRAMClockChangeWatermark = DRAMClockChangeLatency + WritebackLatency;
5297 	} else {
5298 		*WritebackDRAMClockChangeWatermark = DRAMClockChangeLatency + WritebackLatency + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
5299 	}
5300 
5301 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5302 
5303 		mode_lib->vba.LBLatencyHidingSourceLinesY = dml_min((double) MaxLineBufferLines, dml_floor(LineBufferSize / LBBitPerPixel[k] / (SwathWidthY[k] / dml_max(HRatio[k], 1.0)), 1)) - (vtaps[k] - 1);
5304 
5305 		mode_lib->vba.LBLatencyHidingSourceLinesC = dml_min((double) MaxLineBufferLines, dml_floor(LineBufferSize / LBBitPerPixel[k] / (SwathWidthC[k] / dml_max(HRatioChroma[k], 1.0)), 1)) - (VTAPsChroma[k] - 1);
5306 
5307 		EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY / VRatio[k] * (HTotal[k] / PixelClock[k]);
5308 
5309 		EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC / VRatioChroma[k] * (HTotal[k] / PixelClock[k]);
5310 
5311 		LinesInDETY[k] = (double) DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k];
5312 		LinesInDETYRoundedDownToSwath[k] = dml_floor(LinesInDETY[k], SwathHeightY[k]);
5313 		FullDETBufferingTimeY[k] = LinesInDETYRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) / VRatio[k];
5314 		if (BytePerPixelDETC[k] > 0) {
5315 			LinesInDETC = mode_lib->vba.DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k];
5316 			LinesInDETCRoundedDownToSwath = dml_floor(LinesInDETC, SwathHeightC[k]);
5317 			FullDETBufferingTimeC = LinesInDETCRoundedDownToSwath * (HTotal[k] / PixelClock[k]) / VRatioChroma[k];
5318 		} else {
5319 			LinesInDETC = 0;
5320 			FullDETBufferingTimeC = 999999;
5321 		}
5322 
5323 		ActiveDRAMClockChangeLatencyMarginY = EffectiveLBLatencyHidingY + FullDETBufferingTimeY[k] - *UrgentWatermark - (HTotal[k] / PixelClock[k]) * (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) - *DRAMClockChangeWatermark;
5324 
5325 		if (NumberOfActivePlanes > 1) {
5326 			ActiveDRAMClockChangeLatencyMarginY = ActiveDRAMClockChangeLatencyMarginY - (1 - 1.0 / NumberOfActivePlanes) * SwathHeightY[k] * HTotal[k] / PixelClock[k] / VRatio[k];
5327 		}
5328 
5329 		if (BytePerPixelDETC[k] > 0) {
5330 			ActiveDRAMClockChangeLatencyMarginC = EffectiveLBLatencyHidingC + FullDETBufferingTimeC - *UrgentWatermark - (HTotal[k] / PixelClock[k]) * (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) - *DRAMClockChangeWatermark;
5331 
5332 			if (NumberOfActivePlanes > 1) {
5333 				ActiveDRAMClockChangeLatencyMarginC = ActiveDRAMClockChangeLatencyMarginC - (1 - 1.0 / NumberOfActivePlanes) * SwathHeightC[k] * HTotal[k] / PixelClock[k] / VRatioChroma[k];
5334 			}
5335 			mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(ActiveDRAMClockChangeLatencyMarginY, ActiveDRAMClockChangeLatencyMarginC);
5336 		} else {
5337 			mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = ActiveDRAMClockChangeLatencyMarginY;
5338 		}
5339 
5340 		if (WritebackEnable[k] == true) {
5341 
5342 			WritebackDRAMClockChangeLatencyHiding = WritebackInterfaceBufferSize * 1024 / (WritebackDestinationWidth[k] * WritebackDestinationHeight[k] / (WritebackSourceHeight[k] * HTotal[k] / PixelClock[k]) * 4);
5343 			if (WritebackPixelFormat[k] == dm_444_64) {
5344 				WritebackDRAMClockChangeLatencyHiding = WritebackDRAMClockChangeLatencyHiding / 2;
5345 			}
5346 			if (mode_lib->vba.WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave) {
5347 				WritebackDRAMClockChangeLatencyHiding = WritebackDRAMClockChangeLatencyHiding * 2;
5348 			}
5349 			WritebackDRAMClockChangeLatencyMargin = WritebackDRAMClockChangeLatencyHiding - mode_lib->vba.WritebackDRAMClockChangeWatermark;
5350 			mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], WritebackDRAMClockChangeLatencyMargin);
5351 		}
5352 	}
5353 
5354 	mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999;
5355 	PlaneWithMinActiveDRAMClockChangeMargin = 0;
5356 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5357 		if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] < mode_lib->vba.MinActiveDRAMClockChangeMargin) {
5358 			mode_lib->vba.MinActiveDRAMClockChangeMargin = mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
5359 			if (BlendingAndTiming[k] == k) {
5360 				PlaneWithMinActiveDRAMClockChangeMargin = k;
5361 			} else {
5362 				for (j = 0; j < NumberOfActivePlanes; ++j) {
5363 					if (BlendingAndTiming[k] == j) {
5364 						PlaneWithMinActiveDRAMClockChangeMargin = j;
5365 					}
5366 				}
5367 			}
5368 		}
5369 	}
5370 
5371 	*MinActiveDRAMClockChangeLatencySupported = mode_lib->vba.MinActiveDRAMClockChangeMargin + DRAMClockChangeLatency;
5372 
5373 	SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = 999999;
5374 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5375 		if (!((k == PlaneWithMinActiveDRAMClockChangeMargin) && (BlendingAndTiming[k] == k)) && !(BlendingAndTiming[k] == PlaneWithMinActiveDRAMClockChangeMargin) && mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] < SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank) {
5376 			SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
5377 		}
5378 	}
5379 
5380 	mode_lib->vba.TotalNumberOfActiveOTG = 0;
5381 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5382 		if (BlendingAndTiming[k] == k) {
5383 			mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG + 1;
5384 		}
5385 	}
5386 
5387 	if (mode_lib->vba.MinActiveDRAMClockChangeMargin > 0) {
5388 		*DRAMClockChangeSupport = dm_dram_clock_change_vactive;
5389 	} else if (((mode_lib->vba.SynchronizedVBlank == true || mode_lib->vba.TotalNumberOfActiveOTG == 1 || SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank > 0) && PrefetchMode == 0)) {
5390 		*DRAMClockChangeSupport = dm_dram_clock_change_vblank;
5391 	} else {
5392 		*DRAMClockChangeSupport = dm_dram_clock_change_unsupported;
5393 	}
5394 
5395 	FullDETBufferingTimeYStutterCriticalPlane = FullDETBufferingTimeY[0];
5396 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5397 		if (FullDETBufferingTimeY[k] <= FullDETBufferingTimeYStutterCriticalPlane) {
5398 			FullDETBufferingTimeYStutterCriticalPlane = FullDETBufferingTimeY[k];
5399 			TimeToFinishSwathTransferStutterCriticalPlane = (SwathHeightY[k] - (LinesInDETY[k] - LinesInDETYRoundedDownToSwath[k])) * (HTotal[k] / PixelClock[k]) / VRatio[k];
5400 		}
5401 	}
5402 
5403 	*StutterExitWatermark = SRExitTime +  ExtraLatency + 10 / DCFCLKDeepSleep;
5404 	*StutterEnterPlusExitWatermark = dml_max(SREnterPlusExitTime + ExtraLatency + 10 / DCFCLKDeepSleep, TimeToFinishSwathTransferStutterCriticalPlane);
5405 
5406 }
5407 
CalculateDCFCLKDeepSleep(struct display_mode_lib * mode_lib,unsigned int NumberOfActivePlanes,int BytePerPixelY[],int BytePerPixelC[],double VRatio[],double VRatioChroma[],double SwathWidthY[],double SwathWidthC[],unsigned int DPPPerPlane[],double HRatio[],double HRatioChroma[],double PixelClock[],double PSCL_THROUGHPUT[],double PSCL_THROUGHPUT_CHROMA[],double DPPCLK[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],int ReturnBusWidth,double * DCFCLKDeepSleep)5408 static void CalculateDCFCLKDeepSleep(
5409 		struct display_mode_lib *mode_lib,
5410 		unsigned int NumberOfActivePlanes,
5411 		int BytePerPixelY[],
5412 		int BytePerPixelC[],
5413 		double VRatio[],
5414 		double VRatioChroma[],
5415 		double SwathWidthY[],
5416 		double SwathWidthC[],
5417 		unsigned int DPPPerPlane[],
5418 		double HRatio[],
5419 		double HRatioChroma[],
5420 		double PixelClock[],
5421 		double PSCL_THROUGHPUT[],
5422 		double PSCL_THROUGHPUT_CHROMA[],
5423 		double DPPCLK[],
5424 		double ReadBandwidthLuma[],
5425 		double ReadBandwidthChroma[],
5426 		int ReturnBusWidth,
5427 		double *DCFCLKDeepSleep)
5428 {
5429 	double DisplayPipeLineDeliveryTimeLuma = 0;
5430 	double DisplayPipeLineDeliveryTimeChroma = 0;
5431 	unsigned int k;
5432 	double ReadBandwidth = 0.0;
5433 
5434 	//double   DCFCLKDeepSleepPerPlane[DC__NUM_DPP__MAX];
5435 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5436 
5437 		if (VRatio[k] <= 1) {
5438 			DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5439 		} else {
5440 			DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5441 		}
5442 		if (BytePerPixelC[k] == 0) {
5443 			DisplayPipeLineDeliveryTimeChroma = 0;
5444 		} else {
5445 			if (VRatioChroma[k] <= 1) {
5446 				DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5447 			} else {
5448 				DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5449 			}
5450 		}
5451 
5452 		if (BytePerPixelC[k] > 0) {
5453 			mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max(1.1 * SwathWidthY[k] * BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma, 1.1 * SwathWidthC[k] * BytePerPixelC[k] / 32.0 / DisplayPipeLineDeliveryTimeChroma);
5454 		} else {
5455 			mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1.1 * SwathWidthY[k] * BytePerPixelY[k] / 64.0 / DisplayPipeLineDeliveryTimeLuma;
5456 		}
5457 		mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max(mode_lib->vba.DCFCLKDeepSleepPerPlane[k], PixelClock[k] / 16);
5458 
5459 	}
5460 
5461 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5462 		ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
5463 	}
5464 
5465 	*DCFCLKDeepSleep = dml_max(8.0, ReadBandwidth / ReturnBusWidth);
5466 
5467 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5468 		*DCFCLKDeepSleep = dml_max(*DCFCLKDeepSleep, mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
5469 	}
5470 }
5471 
CalculateUrgentBurstFactor(long swath_width_luma_ub,long swath_width_chroma_ub,unsigned int DETBufferSizeInKByte,unsigned int SwathHeightY,unsigned int SwathHeightC,double LineTime,double UrgentLatency,double CursorBufferSize,unsigned int CursorWidth,unsigned int CursorBPP,double VRatio,double VRatioC,double BytePerPixelInDETY,double BytePerPixelInDETC,double DETBufferSizeY,double DETBufferSizeC,double * UrgentBurstFactorCursor,double * UrgentBurstFactorLuma,double * UrgentBurstFactorChroma,bool * NotEnoughUrgentLatencyHiding)5472 static void CalculateUrgentBurstFactor(
5473 		long swath_width_luma_ub,
5474 		long swath_width_chroma_ub,
5475 		unsigned int DETBufferSizeInKByte,
5476 		unsigned int SwathHeightY,
5477 		unsigned int SwathHeightC,
5478 		double LineTime,
5479 		double UrgentLatency,
5480 		double CursorBufferSize,
5481 		unsigned int CursorWidth,
5482 		unsigned int CursorBPP,
5483 		double VRatio,
5484 		double VRatioC,
5485 		double BytePerPixelInDETY,
5486 		double BytePerPixelInDETC,
5487 		double DETBufferSizeY,
5488 		double DETBufferSizeC,
5489 		double *UrgentBurstFactorCursor,
5490 		double *UrgentBurstFactorLuma,
5491 		double *UrgentBurstFactorChroma,
5492 		bool *NotEnoughUrgentLatencyHiding)
5493 {
5494 	double LinesInDETLuma = 0;
5495 	double LinesInDETChroma = 0;
5496 	unsigned int LinesInCursorBuffer = 0;
5497 	double CursorBufferSizeInTime = 0;
5498 	double DETBufferSizeInTimeLuma = 0;
5499 	double DETBufferSizeInTimeChroma = 0;
5500 
5501 	*NotEnoughUrgentLatencyHiding = 0;
5502 
5503 	if (CursorWidth > 0) {
5504 		LinesInCursorBuffer = 1 << (unsigned int) dml_floor(dml_log2(CursorBufferSize * 1024.0 / (CursorWidth * CursorBPP / 8.0)), 1.0);
5505 		if (VRatio > 0) {
5506 			CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio;
5507 			if (CursorBufferSizeInTime - UrgentLatency <= 0) {
5508 				*NotEnoughUrgentLatencyHiding = 1;
5509 				*UrgentBurstFactorCursor = 0;
5510 			} else {
5511 				*UrgentBurstFactorCursor = CursorBufferSizeInTime / (CursorBufferSizeInTime - UrgentLatency);
5512 			}
5513 		} else {
5514 			*UrgentBurstFactorCursor = 1;
5515 		}
5516 	}
5517 
5518 	LinesInDETLuma = DETBufferSizeY / BytePerPixelInDETY / swath_width_luma_ub;
5519 	if (VRatio > 0) {
5520 		DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio;
5521 		if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) {
5522 			*NotEnoughUrgentLatencyHiding = 1;
5523 			*UrgentBurstFactorLuma = 0;
5524 		} else {
5525 			*UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency);
5526 		}
5527 	} else {
5528 		*UrgentBurstFactorLuma = 1;
5529 	}
5530 
5531 	if (BytePerPixelInDETC > 0) {
5532 		LinesInDETChroma = DETBufferSizeC / BytePerPixelInDETC / swath_width_chroma_ub;
5533 		if (VRatio > 0) {
5534 			DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatio;
5535 			if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) {
5536 				*NotEnoughUrgentLatencyHiding = 1;
5537 				*UrgentBurstFactorChroma = 0;
5538 			} else {
5539 				*UrgentBurstFactorChroma = DETBufferSizeInTimeChroma / (DETBufferSizeInTimeChroma - UrgentLatency);
5540 			}
5541 		} else {
5542 			*UrgentBurstFactorChroma = 1;
5543 		}
5544 	}
5545 }
5546 
CalculatePixelDeliveryTimes(unsigned int NumberOfActivePlanes,double VRatio[],double VRatioChroma[],double VRatioPrefetchY[],double VRatioPrefetchC[],unsigned int swath_width_luma_ub[],unsigned int swath_width_chroma_ub[],unsigned int DPPPerPlane[],double HRatio[],double HRatioChroma[],double PixelClock[],double PSCL_THROUGHPUT[],double PSCL_THROUGHPUT_CHROMA[],double DPPCLK[],int BytePerPixelC[],enum scan_direction_class SourceScan[],unsigned int NumberOfCursors[],unsigned int CursorWidth[][2],unsigned int CursorBPP[][2],unsigned int BlockWidth256BytesY[],unsigned int BlockHeight256BytesY[],unsigned int BlockWidth256BytesC[],unsigned int BlockHeight256BytesC[],double DisplayPipeLineDeliveryTimeLuma[],double DisplayPipeLineDeliveryTimeChroma[],double DisplayPipeLineDeliveryTimeLumaPrefetch[],double DisplayPipeLineDeliveryTimeChromaPrefetch[],double DisplayPipeRequestDeliveryTimeLuma[],double DisplayPipeRequestDeliveryTimeChroma[],double DisplayPipeRequestDeliveryTimeLumaPrefetch[],double DisplayPipeRequestDeliveryTimeChromaPrefetch[],double CursorRequestDeliveryTime[],double CursorRequestDeliveryTimePrefetch[])5547 static void CalculatePixelDeliveryTimes(
5548 		unsigned int NumberOfActivePlanes,
5549 		double VRatio[],
5550 		double VRatioChroma[],
5551 		double VRatioPrefetchY[],
5552 		double VRatioPrefetchC[],
5553 		unsigned int swath_width_luma_ub[],
5554 		unsigned int swath_width_chroma_ub[],
5555 		unsigned int DPPPerPlane[],
5556 		double HRatio[],
5557 		double HRatioChroma[],
5558 		double PixelClock[],
5559 		double PSCL_THROUGHPUT[],
5560 		double PSCL_THROUGHPUT_CHROMA[],
5561 		double DPPCLK[],
5562 		int BytePerPixelC[],
5563 		enum scan_direction_class SourceScan[],
5564 		unsigned int NumberOfCursors[],
5565 		unsigned int CursorWidth[][2],
5566 		unsigned int CursorBPP[][2],
5567 		unsigned int BlockWidth256BytesY[],
5568 		unsigned int BlockHeight256BytesY[],
5569 		unsigned int BlockWidth256BytesC[],
5570 		unsigned int BlockHeight256BytesC[],
5571 		double DisplayPipeLineDeliveryTimeLuma[],
5572 		double DisplayPipeLineDeliveryTimeChroma[],
5573 		double DisplayPipeLineDeliveryTimeLumaPrefetch[],
5574 		double DisplayPipeLineDeliveryTimeChromaPrefetch[],
5575 		double DisplayPipeRequestDeliveryTimeLuma[],
5576 		double DisplayPipeRequestDeliveryTimeChroma[],
5577 		double DisplayPipeRequestDeliveryTimeLumaPrefetch[],
5578 		double DisplayPipeRequestDeliveryTimeChromaPrefetch[],
5579 		double CursorRequestDeliveryTime[],
5580 		double CursorRequestDeliveryTimePrefetch[])
5581 {
5582 	double req_per_swath_ub = 0;
5583 	unsigned int k;
5584 
5585 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5586 		if (VRatio[k] <= 1) {
5587 			DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5588 		} else {
5589 			DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5590 		}
5591 
5592 		if (BytePerPixelC[k] == 0) {
5593 			DisplayPipeLineDeliveryTimeChroma[k] = 0;
5594 		} else {
5595 			if (VRatioChroma[k] <= 1) {
5596 				DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5597 			} else {
5598 				DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5599 			}
5600 		}
5601 
5602 		if (VRatioPrefetchY[k] <= 1) {
5603 			DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5604 		} else {
5605 			DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5606 		}
5607 
5608 		if (BytePerPixelC[k] == 0) {
5609 			DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
5610 		} else {
5611 			if (VRatioPrefetchC[k] <= 1) {
5612 				DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5613 			} else {
5614 				DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5615 			}
5616 		}
5617 	}
5618 
5619 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5620 		if (SourceScan[k] != dm_vert) {
5621 			req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k];
5622 		} else {
5623 			req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k];
5624 		}
5625 		DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub;
5626 		DisplayPipeRequestDeliveryTimeLumaPrefetch[k] = DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub;
5627 		if (BytePerPixelC[k] == 0) {
5628 			DisplayPipeRequestDeliveryTimeChroma[k] = 0;
5629 			DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0;
5630 		} else {
5631 			if (SourceScan[k] != dm_vert) {
5632 				req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k];
5633 			} else {
5634 				req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k];
5635 			}
5636 			DisplayPipeRequestDeliveryTimeChroma[k] = DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub;
5637 			DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub;
5638 		}
5639 	}
5640 
5641 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5642 		int cursor_req_per_width = 0;
5643 		cursor_req_per_width = dml_ceil(CursorWidth[k][0] * CursorBPP[k][0] / 256 / 8, 1);
5644 		if (NumberOfCursors[k] > 0) {
5645 			if (VRatio[k] <= 1) {
5646 				CursorRequestDeliveryTime[k] = CursorWidth[k][0] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
5647 			} else {
5648 				CursorRequestDeliveryTime[k] = CursorWidth[k][0] / PSCL_THROUGHPUT[k] / DPPCLK[k] / cursor_req_per_width;
5649 			}
5650 			if (VRatioPrefetchY[k] <= 1) {
5651 				CursorRequestDeliveryTimePrefetch[k] = CursorWidth[k][0] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
5652 			} else {
5653 				CursorRequestDeliveryTimePrefetch[k] = CursorWidth[k][0] / PSCL_THROUGHPUT[k] / DPPCLK[k] / cursor_req_per_width;
5654 			}
5655 		} else {
5656 			CursorRequestDeliveryTime[k] = 0;
5657 			CursorRequestDeliveryTimePrefetch[k] = 0;
5658 		}
5659 	}
5660 }
5661 
CalculateMetaAndPTETimes(int NumberOfActivePlanes,bool GPUVMEnable,int MetaChunkSize,int MinMetaChunkSizeBytes,int HTotal[],double VRatio[],double VRatioChroma[],double DestinationLinesToRequestRowInVBlank[],double DestinationLinesToRequestRowInImmediateFlip[],bool DCCEnable[],double PixelClock[],int BytePerPixelY[],int BytePerPixelC[],enum scan_direction_class SourceScan[],int dpte_row_height[],int dpte_row_height_chroma[],int meta_row_width[],int meta_row_width_chroma[],int meta_row_height[],int meta_row_height_chroma[],int meta_req_width[],int meta_req_width_chroma[],int meta_req_height[],int meta_req_height_chroma[],int dpte_group_bytes[],int PTERequestSizeY[],int PTERequestSizeC[],int PixelPTEReqWidthY[],int PixelPTEReqHeightY[],int PixelPTEReqWidthC[],int PixelPTEReqHeightC[],int dpte_row_width_luma_ub[],int dpte_row_width_chroma_ub[],double DST_Y_PER_PTE_ROW_NOM_L[],double DST_Y_PER_PTE_ROW_NOM_C[],double DST_Y_PER_META_ROW_NOM_L[],double DST_Y_PER_META_ROW_NOM_C[],double TimePerMetaChunkNominal[],double TimePerChromaMetaChunkNominal[],double TimePerMetaChunkVBlank[],double TimePerChromaMetaChunkVBlank[],double TimePerMetaChunkFlip[],double TimePerChromaMetaChunkFlip[],double time_per_pte_group_nom_luma[],double time_per_pte_group_vblank_luma[],double time_per_pte_group_flip_luma[],double time_per_pte_group_nom_chroma[],double time_per_pte_group_vblank_chroma[],double time_per_pte_group_flip_chroma[])5662 static void CalculateMetaAndPTETimes(
5663 		int NumberOfActivePlanes,
5664 		bool GPUVMEnable,
5665 		int MetaChunkSize,
5666 		int MinMetaChunkSizeBytes,
5667 		int HTotal[],
5668 		double VRatio[],
5669 		double VRatioChroma[],
5670 		double DestinationLinesToRequestRowInVBlank[],
5671 		double DestinationLinesToRequestRowInImmediateFlip[],
5672 		bool DCCEnable[],
5673 		double PixelClock[],
5674 		int BytePerPixelY[],
5675 		int BytePerPixelC[],
5676 		enum scan_direction_class SourceScan[],
5677 		int dpte_row_height[],
5678 		int dpte_row_height_chroma[],
5679 		int meta_row_width[],
5680 		int meta_row_width_chroma[],
5681 		int meta_row_height[],
5682 		int meta_row_height_chroma[],
5683 		int meta_req_width[],
5684 		int meta_req_width_chroma[],
5685 		int meta_req_height[],
5686 		int meta_req_height_chroma[],
5687 		int dpte_group_bytes[],
5688 		int PTERequestSizeY[],
5689 		int PTERequestSizeC[],
5690 		int PixelPTEReqWidthY[],
5691 		int PixelPTEReqHeightY[],
5692 		int PixelPTEReqWidthC[],
5693 		int PixelPTEReqHeightC[],
5694 		int dpte_row_width_luma_ub[],
5695 		int dpte_row_width_chroma_ub[],
5696 		double DST_Y_PER_PTE_ROW_NOM_L[],
5697 		double DST_Y_PER_PTE_ROW_NOM_C[],
5698 		double DST_Y_PER_META_ROW_NOM_L[],
5699 		double DST_Y_PER_META_ROW_NOM_C[],
5700 		double TimePerMetaChunkNominal[],
5701 		double TimePerChromaMetaChunkNominal[],
5702 		double TimePerMetaChunkVBlank[],
5703 		double TimePerChromaMetaChunkVBlank[],
5704 		double TimePerMetaChunkFlip[],
5705 		double TimePerChromaMetaChunkFlip[],
5706 		double time_per_pte_group_nom_luma[],
5707 		double time_per_pte_group_vblank_luma[],
5708 		double time_per_pte_group_flip_luma[],
5709 		double time_per_pte_group_nom_chroma[],
5710 		double time_per_pte_group_vblank_chroma[],
5711 		double time_per_pte_group_flip_chroma[])
5712 {
5713 	unsigned int meta_chunk_width = 0;
5714 	unsigned int min_meta_chunk_width = 0;
5715 	unsigned int meta_chunk_per_row_int = 0;
5716 	unsigned int meta_row_remainder = 0;
5717 	unsigned int meta_chunk_threshold = 0;
5718 	unsigned int meta_chunks_per_row_ub = 0;
5719 	unsigned int meta_chunk_width_chroma = 0;
5720 	unsigned int min_meta_chunk_width_chroma = 0;
5721 	unsigned int meta_chunk_per_row_int_chroma = 0;
5722 	unsigned int meta_row_remainder_chroma = 0;
5723 	unsigned int meta_chunk_threshold_chroma = 0;
5724 	unsigned int meta_chunks_per_row_ub_chroma = 0;
5725 	unsigned int dpte_group_width_luma = 0;
5726 	unsigned int dpte_groups_per_row_luma_ub = 0;
5727 	unsigned int dpte_group_width_chroma = 0;
5728 	unsigned int dpte_groups_per_row_chroma_ub = 0;
5729 	unsigned int k;
5730 
5731 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5732 		DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k];
5733 		if (BytePerPixelC[k] == 0) {
5734 			DST_Y_PER_PTE_ROW_NOM_C[k] = 0;
5735 		} else {
5736 			DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k];
5737 		}
5738 		DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k];
5739 		if (BytePerPixelC[k] == 0) {
5740 			DST_Y_PER_META_ROW_NOM_C[k] = 0;
5741 		} else {
5742 			DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k];
5743 		}
5744 	}
5745 
5746 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5747 		if (DCCEnable[k] == true) {
5748 			meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k];
5749 			min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k];
5750 			meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width;
5751 			meta_row_remainder = meta_row_width[k] % meta_chunk_width;
5752 			if (SourceScan[k] != dm_vert) {
5753 				meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k];
5754 			} else {
5755 				meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k];
5756 			}
5757 			if (meta_row_remainder <= meta_chunk_threshold) {
5758 				meta_chunks_per_row_ub = meta_chunk_per_row_int + 1;
5759 			} else {
5760 				meta_chunks_per_row_ub = meta_chunk_per_row_int + 2;
5761 			}
5762 			TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5763 			TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5764 			TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5765 			if (BytePerPixelC[k] == 0) {
5766 				TimePerChromaMetaChunkNominal[k] = 0;
5767 				TimePerChromaMetaChunkVBlank[k] = 0;
5768 				TimePerChromaMetaChunkFlip[k] = 0;
5769 			} else {
5770 				meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
5771 				min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
5772 				meta_chunk_per_row_int_chroma = (double) meta_row_width_chroma[k] / meta_chunk_width_chroma;
5773 				meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma;
5774 				if (SourceScan[k] != dm_vert) {
5775 					meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_width_chroma[k];
5776 				} else {
5777 					meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_height_chroma[k];
5778 				}
5779 				if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma) {
5780 					meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1;
5781 				} else {
5782 					meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2;
5783 				}
5784 				TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5785 				TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5786 				TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5787 			}
5788 		} else {
5789 			TimePerMetaChunkNominal[k] = 0;
5790 			TimePerMetaChunkVBlank[k] = 0;
5791 			TimePerMetaChunkFlip[k] = 0;
5792 			TimePerChromaMetaChunkNominal[k] = 0;
5793 			TimePerChromaMetaChunkVBlank[k] = 0;
5794 			TimePerChromaMetaChunkFlip[k] = 0;
5795 		}
5796 	}
5797 
5798 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5799 		if (GPUVMEnable == true) {
5800 			if (SourceScan[k] != dm_vert) {
5801 				dpte_group_width_luma = dpte_group_bytes[k] / PTERequestSizeY[k] * PixelPTEReqWidthY[k];
5802 			} else {
5803 				dpte_group_width_luma = dpte_group_bytes[k] / PTERequestSizeY[k] * PixelPTEReqHeightY[k];
5804 			}
5805 			dpte_groups_per_row_luma_ub = dml_ceil(1.0 * dpte_row_width_luma_ub[k] / dpte_group_width_luma, 1);
5806 			time_per_pte_group_nom_luma[k] = DST_Y_PER_PTE_ROW_NOM_L[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5807 			time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5808 			time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5809 			if (BytePerPixelC[k] == 0) {
5810 				time_per_pte_group_nom_chroma[k] = 0;
5811 				time_per_pte_group_vblank_chroma[k] = 0;
5812 				time_per_pte_group_flip_chroma[k] = 0;
5813 			} else {
5814 				if (SourceScan[k] != dm_vert) {
5815 					dpte_group_width_chroma = dpte_group_bytes[k] / PTERequestSizeC[k] * PixelPTEReqWidthC[k];
5816 				} else {
5817 					dpte_group_width_chroma = dpte_group_bytes[k] / PTERequestSizeC[k] * PixelPTEReqHeightC[k];
5818 				}
5819 				dpte_groups_per_row_chroma_ub = dml_ceil(1.0 * dpte_row_width_chroma_ub[k] / dpte_group_width_chroma, 1);
5820 				time_per_pte_group_nom_chroma[k] = DST_Y_PER_PTE_ROW_NOM_C[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5821 				time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5822 				time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5823 			}
5824 		} else {
5825 			time_per_pte_group_nom_luma[k] = 0;
5826 			time_per_pte_group_vblank_luma[k] = 0;
5827 			time_per_pte_group_flip_luma[k] = 0;
5828 			time_per_pte_group_nom_chroma[k] = 0;
5829 			time_per_pte_group_vblank_chroma[k] = 0;
5830 			time_per_pte_group_flip_chroma[k] = 0;
5831 		}
5832 	}
5833 }
5834 
CalculateVMGroupAndRequestTimes(unsigned int NumberOfActivePlanes,bool GPUVMEnable,unsigned int GPUVMMaxPageTableLevels,unsigned int HTotal[],int BytePerPixelC[],double DestinationLinesToRequestVMInVBlank[],double DestinationLinesToRequestVMInImmediateFlip[],bool DCCEnable[],double PixelClock[],int dpte_row_width_luma_ub[],int dpte_row_width_chroma_ub[],int vm_group_bytes[],unsigned int dpde0_bytes_per_frame_ub_l[],unsigned int dpde0_bytes_per_frame_ub_c[],int meta_pte_bytes_per_frame_ub_l[],int meta_pte_bytes_per_frame_ub_c[],double TimePerVMGroupVBlank[],double TimePerVMGroupFlip[],double TimePerVMRequestVBlank[],double TimePerVMRequestFlip[])5835 static void CalculateVMGroupAndRequestTimes(
5836 		unsigned int NumberOfActivePlanes,
5837 		bool GPUVMEnable,
5838 		unsigned int GPUVMMaxPageTableLevels,
5839 		unsigned int HTotal[],
5840 		int BytePerPixelC[],
5841 		double DestinationLinesToRequestVMInVBlank[],
5842 		double DestinationLinesToRequestVMInImmediateFlip[],
5843 		bool DCCEnable[],
5844 		double PixelClock[],
5845 		int dpte_row_width_luma_ub[],
5846 		int dpte_row_width_chroma_ub[],
5847 		int vm_group_bytes[],
5848 		unsigned int dpde0_bytes_per_frame_ub_l[],
5849 		unsigned int dpde0_bytes_per_frame_ub_c[],
5850 		int meta_pte_bytes_per_frame_ub_l[],
5851 		int meta_pte_bytes_per_frame_ub_c[],
5852 		double TimePerVMGroupVBlank[],
5853 		double TimePerVMGroupFlip[],
5854 		double TimePerVMRequestVBlank[],
5855 		double TimePerVMRequestFlip[])
5856 {
5857 	int num_group_per_lower_vm_stage = 0;
5858 	int num_req_per_lower_vm_stage = 0;
5859 	unsigned int k;
5860 
5861 	for (k = 0; k < NumberOfActivePlanes; ++k) {
5862 		if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) {
5863 			if (DCCEnable[k] == false) {
5864 				if (BytePerPixelC[k] > 0) {
5865 					num_group_per_lower_vm_stage = dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k])
5866 						/ (double) (vm_group_bytes[k]), 1) + dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k])
5867 									/ (double) (vm_group_bytes[k]), 1);
5868 				} else {
5869 					num_group_per_lower_vm_stage = dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k])
5870 							/ (double) (vm_group_bytes[k]), 1);
5871 				}
5872 			} else {
5873 				if (GPUVMMaxPageTableLevels == 1) {
5874 					if (BytePerPixelC[k] > 0) {
5875 						num_group_per_lower_vm_stage = dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k])
5876 							/ (double) (vm_group_bytes[k]), 1) + dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k])
5877 									/ (double) (vm_group_bytes[k]), 1);
5878 					} else {
5879 						num_group_per_lower_vm_stage = dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k])
5880 							/ (double) (vm_group_bytes[k]), 1);
5881 					}
5882 				} else {
5883 					if (BytePerPixelC[k] > 0) {
5884 						num_group_per_lower_vm_stage = 2 + dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
5885 								+ dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), 1)
5886 								+ dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
5887 								+ dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), 1);
5888 					} else {
5889 						num_group_per_lower_vm_stage = 1 + dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
5890 								+ dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1);
5891 					}
5892 				}
5893 			}
5894 
5895 			if (DCCEnable[k] == false) {
5896 				if (BytePerPixelC[k] > 0) {
5897 					num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64;
5898 				} else {
5899 					num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64;
5900 				}
5901 			} else {
5902 				if (GPUVMMaxPageTableLevels == 1) {
5903 					if (BytePerPixelC[k] > 0) {
5904 						num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64
5905 								+ meta_pte_bytes_per_frame_ub_c[k] / 64;
5906 					} else {
5907 						num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64;
5908 					}
5909 				} else {
5910 					if (BytePerPixelC[k] > 0) {
5911 						num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64
5912 							+ dpde0_bytes_per_frame_ub_c[k] / 64 + meta_pte_bytes_per_frame_ub_l[k]
5913 									/ 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
5914 					} else {
5915 						num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64
5916 								+ meta_pte_bytes_per_frame_ub_l[k] / 64;
5917 					}
5918 				}
5919 			}
5920 
5921 			TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k]
5922 					/ num_group_per_lower_vm_stage;
5923 			TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k]
5924 					/ num_group_per_lower_vm_stage;
5925 			TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k]
5926 					/ num_req_per_lower_vm_stage;
5927 			TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k]
5928 					/ num_req_per_lower_vm_stage;
5929 
5930 			if (GPUVMMaxPageTableLevels > 2) {
5931 				TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2;
5932 				TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2;
5933 				TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2;
5934 				TimePerVMRequestFlip[k] = TimePerVMRequestFlip[k] / 2;
5935 			}
5936 
5937 		} else {
5938 			TimePerVMGroupVBlank[k] = 0;
5939 			TimePerVMGroupFlip[k] = 0;
5940 			TimePerVMRequestVBlank[k] = 0;
5941 			TimePerVMRequestFlip[k] = 0;
5942 		}
5943 	}
5944 }
5945 
CalculateStutterEfficiency(int NumberOfActivePlanes,long ROBBufferSizeInKByte,double TotalDataReadBandwidth,double DCFCLK,double ReturnBW,double SRExitTime,bool SynchronizedVBlank,int DPPPerPlane[],unsigned int DETBufferSizeY[],int BytePerPixelY[],double BytePerPixelDETY[],double SwathWidthY[],int SwathHeightY[],int SwathHeightC[],double DCCRateLuma[],double DCCRateChroma[],int HTotal[],int VTotal[],double PixelClock[],double VRatio[],enum scan_direction_class SourceScan[],int BlockHeight256BytesY[],int BlockWidth256BytesY[],int BlockHeight256BytesC[],int BlockWidth256BytesC[],int DCCYMaxUncompressedBlock[],int DCCCMaxUncompressedBlock[],int VActive[],bool DCCEnable[],bool WritebackEnable[],double ReadBandwidthPlaneLuma[],double ReadBandwidthPlaneChroma[],double meta_row_bw[],double dpte_row_bw[],double * StutterEfficiencyNotIncludingVBlank,double * StutterEfficiency,double * StutterPeriodOut)5946 static void CalculateStutterEfficiency(
5947 		int NumberOfActivePlanes,
5948 		long ROBBufferSizeInKByte,
5949 		double TotalDataReadBandwidth,
5950 		double DCFCLK,
5951 		double ReturnBW,
5952 		double SRExitTime,
5953 		bool SynchronizedVBlank,
5954 		int DPPPerPlane[],
5955 		unsigned int DETBufferSizeY[],
5956 		int BytePerPixelY[],
5957 		double BytePerPixelDETY[],
5958 		double SwathWidthY[],
5959 		int SwathHeightY[],
5960 		int SwathHeightC[],
5961 		double DCCRateLuma[],
5962 		double DCCRateChroma[],
5963 		int HTotal[],
5964 		int VTotal[],
5965 		double PixelClock[],
5966 		double VRatio[],
5967 		enum scan_direction_class SourceScan[],
5968 		int BlockHeight256BytesY[],
5969 		int BlockWidth256BytesY[],
5970 		int BlockHeight256BytesC[],
5971 		int BlockWidth256BytesC[],
5972 		int DCCYMaxUncompressedBlock[],
5973 		int DCCCMaxUncompressedBlock[],
5974 		int VActive[],
5975 		bool DCCEnable[],
5976 		bool WritebackEnable[],
5977 		double ReadBandwidthPlaneLuma[],
5978 		double ReadBandwidthPlaneChroma[],
5979 		double meta_row_bw[],
5980 		double dpte_row_bw[],
5981 		double *StutterEfficiencyNotIncludingVBlank,
5982 		double *StutterEfficiency,
5983 		double *StutterPeriodOut)
5984 {
5985 	double FullDETBufferingTimeY[DC__NUM_DPP__MAX] = { 0 };
5986 	double FrameTimeForMinFullDETBufferingTime = 0;
5987 	double StutterPeriod = 0;
5988 	double AverageReadBandwidth = 0;
5989 	double TotalRowReadBandwidth = 0;
5990 	double AverageDCCCompressionRate = 0;
5991 	double PartOfBurstThatFitsInROB = 0;
5992 	double StutterBurstTime = 0;
5993 	int TotalActiveWriteback = 0;
5994 	double VBlankTime = 0;
5995 	double SmallestVBlank = 0;
5996 	int BytePerPixelYCriticalPlane = 0;
5997 	double SwathWidthYCriticalPlane = 0;
5998 	double LinesInDETY[DC__NUM_DPP__MAX] = { 0 };
5999 	double LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX] = { 0 };
6000 	double LinesToFinishSwathTransferStutterCriticalPlane = 0;
6001 	double MaximumEffectiveCompressionLuma = 0;
6002 	double    MaximumEffectiveCompressionChroma = 0;
6003 	unsigned int k;
6004 
6005 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6006 		LinesInDETY[k] = DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k];
6007 		LinesInDETYRoundedDownToSwath[k] = dml_floor(LinesInDETY[k], SwathHeightY[k]);
6008 		FullDETBufferingTimeY[k] = LinesInDETYRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) / VRatio[k];
6009 	}
6010 
6011 	StutterPeriod = FullDETBufferingTimeY[0];
6012 	FrameTimeForMinFullDETBufferingTime = VTotal[0] * HTotal[0] / PixelClock[0];
6013 	BytePerPixelYCriticalPlane = BytePerPixelY[0];
6014 	SwathWidthYCriticalPlane = SwathWidthY[0];
6015 	LinesToFinishSwathTransferStutterCriticalPlane = SwathHeightY[0]
6016 			- (LinesInDETY[0] - LinesInDETYRoundedDownToSwath[0]);
6017 
6018 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6019 		if (FullDETBufferingTimeY[k] < StutterPeriod) {
6020 			StutterPeriod = FullDETBufferingTimeY[k];
6021 			FrameTimeForMinFullDETBufferingTime = VTotal[k] * HTotal[k] / PixelClock[k];
6022 			BytePerPixelYCriticalPlane = BytePerPixelY[k];
6023 			SwathWidthYCriticalPlane = SwathWidthY[k];
6024 			LinesToFinishSwathTransferStutterCriticalPlane = SwathHeightY[k]
6025 					- (LinesInDETY[k] - LinesInDETYRoundedDownToSwath[k]);
6026 		}
6027 	}
6028 
6029 	AverageReadBandwidth = 0;
6030 	TotalRowReadBandwidth = 0;
6031 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6032 		if (DCCEnable[k] == true) {
6033 			if ((SourceScan[k] == dm_vert && BlockWidth256BytesY[k] > SwathHeightY[k])
6034 					|| (SourceScan[k] != dm_vert
6035 							&& BlockHeight256BytesY[k] > SwathHeightY[k])
6036 					|| DCCYMaxUncompressedBlock[k] < 256) {
6037 				MaximumEffectiveCompressionLuma = 2;
6038 			} else {
6039 				MaximumEffectiveCompressionLuma = 4;
6040 			}
6041 			AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneLuma[k] / dml_min(DCCRateLuma[k], MaximumEffectiveCompressionLuma);
6042 
6043 			if (ReadBandwidthPlaneChroma[k] > 0) {
6044 				if ((SourceScan[k] == dm_vert && BlockWidth256BytesC[k] > SwathHeightC[k])
6045 						|| (SourceScan[k] != dm_vert && BlockHeight256BytesC[k] > SwathHeightC[k])
6046 						|| DCCCMaxUncompressedBlock[k] < 256) {
6047 					MaximumEffectiveCompressionChroma = 2;
6048 				} else {
6049 					MaximumEffectiveCompressionChroma = 4;
6050 				}
6051 				AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneChroma[k] / dml_min(DCCRateChroma[k], MaximumEffectiveCompressionChroma);
6052 			}
6053 		} else {
6054 			AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneLuma[k] + ReadBandwidthPlaneChroma[k];
6055 		}
6056 		TotalRowReadBandwidth = TotalRowReadBandwidth + DPPPerPlane[k] * (meta_row_bw[k] + dpte_row_bw[k]);
6057 	}
6058 
6059 	AverageDCCCompressionRate = TotalDataReadBandwidth / AverageReadBandwidth;
6060 	PartOfBurstThatFitsInROB = dml_min(StutterPeriod * TotalDataReadBandwidth, ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate);
6061 	StutterBurstTime = PartOfBurstThatFitsInROB / AverageDCCCompressionRate / ReturnBW + (StutterPeriod * TotalDataReadBandwidth
6062 			- PartOfBurstThatFitsInROB) / (DCFCLK * 64) + StutterPeriod * TotalRowReadBandwidth / ReturnBW;
6063 	StutterBurstTime = dml_max(StutterBurstTime, LinesToFinishSwathTransferStutterCriticalPlane * BytePerPixelYCriticalPlane * SwathWidthYCriticalPlane / ReturnBW);
6064 
6065 	TotalActiveWriteback = 0;
6066 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6067 		if (WritebackEnable[k] == true) {
6068 			TotalActiveWriteback = TotalActiveWriteback + 1;
6069 		}
6070 	}
6071 
6072 	if (TotalActiveWriteback == 0) {
6073 		*StutterEfficiencyNotIncludingVBlank = (1
6074 				- (SRExitTime + StutterBurstTime) / StutterPeriod) * 100;
6075 	} else {
6076 		*StutterEfficiencyNotIncludingVBlank = 0;
6077 	}
6078 
6079 	if (SynchronizedVBlank == true || NumberOfActivePlanes == 1) {
6080 		SmallestVBlank = (VTotal[0] - VActive[0]) * HTotal[0] / PixelClock[0];
6081 	} else {
6082 		SmallestVBlank = 0;
6083 	}
6084 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6085 		if (SynchronizedVBlank == true || NumberOfActivePlanes == 1) {
6086 			VBlankTime = (VTotal[k] - VActive[k]) * HTotal[k] / PixelClock[k];
6087 		} else {
6088 			VBlankTime = 0;
6089 		}
6090 		SmallestVBlank = dml_min(SmallestVBlank, VBlankTime);
6091 	}
6092 
6093 	*StutterEfficiency =  (*StutterEfficiencyNotIncludingVBlank / 100.0 * (FrameTimeForMinFullDETBufferingTime - SmallestVBlank) + SmallestVBlank) / FrameTimeForMinFullDETBufferingTime * 100;
6094 
6095 	if (StutterPeriodOut)
6096 		*StutterPeriodOut = StutterPeriod;
6097 }
6098 
CalculateSwathAndDETConfiguration(bool ForceSingleDPP,int NumberOfActivePlanes,unsigned int DETBufferSizeInKByte,double MaximumSwathWidthLuma[],double MaximumSwathWidthChroma[],enum scan_direction_class SourceScan[],enum source_format_class SourcePixelFormat[],enum dm_swizzle_mode SurfaceTiling[],int ViewportWidth[],int ViewportHeight[],int SurfaceWidthY[],int SurfaceWidthC[],int SurfaceHeightY[],int SurfaceHeightC[],int Read256BytesBlockHeightY[],int Read256BytesBlockHeightC[],int Read256BytesBlockWidthY[],int Read256BytesBlockWidthC[],enum odm_combine_mode ODMCombineEnabled[],int BlendingAndTiming[],int BytePerPixY[],int BytePerPixC[],double BytePerPixDETY[],double BytePerPixDETC[],int HActive[],double HRatio[],double HRatioChroma[],int DPPPerPlane[],int swath_width_luma_ub[],int swath_width_chroma_ub[],double SwathWidth[],double SwathWidthChroma[],int SwathHeightY[],int SwathHeightC[],unsigned int DETBufferSizeY[],unsigned int DETBufferSizeC[],bool ViewportSizeSupportPerPlane[],bool * ViewportSizeSupport)6099 static void CalculateSwathAndDETConfiguration(
6100 		bool ForceSingleDPP,
6101 		int NumberOfActivePlanes,
6102 		unsigned int DETBufferSizeInKByte,
6103 		double MaximumSwathWidthLuma[],
6104 		double MaximumSwathWidthChroma[],
6105 		enum scan_direction_class SourceScan[],
6106 		enum source_format_class SourcePixelFormat[],
6107 		enum dm_swizzle_mode SurfaceTiling[],
6108 		int ViewportWidth[],
6109 		int ViewportHeight[],
6110 		int SurfaceWidthY[],
6111 		int SurfaceWidthC[],
6112 		int SurfaceHeightY[],
6113 		int SurfaceHeightC[],
6114 		int Read256BytesBlockHeightY[],
6115 		int Read256BytesBlockHeightC[],
6116 		int Read256BytesBlockWidthY[],
6117 		int Read256BytesBlockWidthC[],
6118 		enum odm_combine_mode ODMCombineEnabled[],
6119 		int BlendingAndTiming[],
6120 		int BytePerPixY[],
6121 		int BytePerPixC[],
6122 		double BytePerPixDETY[],
6123 		double BytePerPixDETC[],
6124 		int HActive[],
6125 		double HRatio[],
6126 		double HRatioChroma[],
6127 		int DPPPerPlane[],
6128 		int swath_width_luma_ub[],
6129 		int swath_width_chroma_ub[],
6130 		double SwathWidth[],
6131 		double SwathWidthChroma[],
6132 		int SwathHeightY[],
6133 		int SwathHeightC[],
6134 		unsigned int DETBufferSizeY[],
6135 		unsigned int DETBufferSizeC[],
6136 		bool ViewportSizeSupportPerPlane[],
6137 		bool *ViewportSizeSupport)
6138 {
6139 	int MaximumSwathHeightY[DC__NUM_DPP__MAX] = { 0 };
6140 	int MaximumSwathHeightC[DC__NUM_DPP__MAX] = { 0 };
6141 	int MinimumSwathHeightY = 0;
6142 	int MinimumSwathHeightC = 0;
6143 	long RoundedUpMaxSwathSizeBytesY = 0;
6144 	long RoundedUpMaxSwathSizeBytesC = 0;
6145 	long RoundedUpMinSwathSizeBytesY = 0;
6146 	long RoundedUpMinSwathSizeBytesC = 0;
6147 	long RoundedUpSwathSizeBytesY = 0;
6148 	long RoundedUpSwathSizeBytesC = 0;
6149 	double SwathWidthSingleDPP[DC__NUM_DPP__MAX] = { 0 };
6150 	double SwathWidthSingleDPPChroma[DC__NUM_DPP__MAX] = { 0 };
6151 	int k;
6152 
6153 	CalculateSwathWidth(
6154 			ForceSingleDPP,
6155 			NumberOfActivePlanes,
6156 			SourcePixelFormat,
6157 			SourceScan,
6158 			ViewportWidth,
6159 			ViewportHeight,
6160 			SurfaceWidthY,
6161 			SurfaceWidthC,
6162 			SurfaceHeightY,
6163 			SurfaceHeightC,
6164 			ODMCombineEnabled,
6165 			BytePerPixY,
6166 			BytePerPixC,
6167 			Read256BytesBlockHeightY,
6168 			Read256BytesBlockHeightC,
6169 			Read256BytesBlockWidthY,
6170 			Read256BytesBlockWidthC,
6171 			BlendingAndTiming,
6172 			HActive,
6173 			HRatio,
6174 			DPPPerPlane,
6175 			SwathWidthSingleDPP,
6176 			SwathWidthSingleDPPChroma,
6177 			SwathWidth,
6178 			SwathWidthChroma,
6179 			MaximumSwathHeightY,
6180 			MaximumSwathHeightC,
6181 			swath_width_luma_ub,
6182 			swath_width_chroma_ub);
6183 
6184 	*ViewportSizeSupport = true;
6185 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6186 		if ((SourcePixelFormat[k] == dm_444_64 || SourcePixelFormat[k] == dm_444_32
6187 				|| SourcePixelFormat[k] == dm_444_16
6188 				|| SourcePixelFormat[k] == dm_mono_16
6189 				|| SourcePixelFormat[k] == dm_mono_8
6190 				|| SourcePixelFormat[k] == dm_rgbe)) {
6191 			if (SurfaceTiling[k] == dm_sw_linear
6192 				|| (SourcePixelFormat[k] == dm_444_64
6193 					&& (SurfaceTiling[k] == dm_sw_64kb_s || SurfaceTiling[k] == dm_sw_64kb_s_t || SurfaceTiling[k] == dm_sw_64kb_s_x)
6194 					&& SourceScan[k] != dm_vert)) {
6195 				MinimumSwathHeightY = MaximumSwathHeightY[k];
6196 			} else if (SourcePixelFormat[k] == dm_444_8 && SourceScan[k] == dm_vert) {
6197 				MinimumSwathHeightY = MaximumSwathHeightY[k];
6198 			} else {
6199 				MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6200 			}
6201 			MinimumSwathHeightC = MaximumSwathHeightC[k];
6202 		} else {
6203 			if (SurfaceTiling[k] == dm_sw_linear) {
6204 				MinimumSwathHeightY = MaximumSwathHeightY[k];
6205 				MinimumSwathHeightC = MaximumSwathHeightC[k];
6206 			} else if (SourcePixelFormat[k] == dm_rgbe_alpha
6207 					&& SourceScan[k] == dm_vert) {
6208 				MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6209 				MinimumSwathHeightC = MaximumSwathHeightC[k];
6210 			} else if (SourcePixelFormat[k] == dm_rgbe_alpha) {
6211 				MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6212 				MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6213 			} else if (SourcePixelFormat[k] == dm_420_8 && SourceScan[k] == dm_vert) {
6214 				MinimumSwathHeightY = MaximumSwathHeightY[k];
6215 				MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6216 			} else {
6217 				MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6218 				MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6219 			}
6220 		}
6221 
6222 		RoundedUpMaxSwathSizeBytesY = swath_width_luma_ub[k] * BytePerPixDETY[k]
6223 				* MaximumSwathHeightY[k];
6224 		RoundedUpMinSwathSizeBytesY = swath_width_luma_ub[k] * BytePerPixDETY[k]
6225 				* MinimumSwathHeightY;
6226 		if (SourcePixelFormat[k] == dm_420_10) {
6227 			RoundedUpMaxSwathSizeBytesY = dml_ceil((double) RoundedUpMaxSwathSizeBytesY, 256);
6228 			RoundedUpMinSwathSizeBytesY = dml_ceil((double) RoundedUpMinSwathSizeBytesY, 256);
6229 		}
6230 		RoundedUpMaxSwathSizeBytesC = swath_width_chroma_ub[k] * BytePerPixDETC[k]
6231 				* MaximumSwathHeightC[k];
6232 		RoundedUpMinSwathSizeBytesC = swath_width_chroma_ub[k] * BytePerPixDETC[k]
6233 				* MinimumSwathHeightC;
6234 		if (SourcePixelFormat[k] == dm_420_10) {
6235 			RoundedUpMaxSwathSizeBytesC = dml_ceil(RoundedUpMaxSwathSizeBytesC, 256);
6236 			RoundedUpMinSwathSizeBytesC = dml_ceil(RoundedUpMinSwathSizeBytesC, 256);
6237 		}
6238 
6239 		if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
6240 				<= DETBufferSizeInKByte * 1024 / 2) {
6241 			SwathHeightY[k] = MaximumSwathHeightY[k];
6242 			SwathHeightC[k] = MaximumSwathHeightC[k];
6243 			RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY;
6244 			RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC;
6245 		} else if (RoundedUpMaxSwathSizeBytesY >= 1.5 * RoundedUpMaxSwathSizeBytesC
6246 				&& RoundedUpMinSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
6247 						<= DETBufferSizeInKByte * 1024 / 2) {
6248 			SwathHeightY[k] = MinimumSwathHeightY;
6249 			SwathHeightC[k] = MaximumSwathHeightC[k];
6250 			RoundedUpSwathSizeBytesY = RoundedUpMinSwathSizeBytesY;
6251 			RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC;
6252 		} else if (RoundedUpMaxSwathSizeBytesY < 1.5 * RoundedUpMaxSwathSizeBytesC
6253 				&& RoundedUpMaxSwathSizeBytesY + RoundedUpMinSwathSizeBytesC
6254 						<= DETBufferSizeInKByte * 1024 / 2) {
6255 			SwathHeightY[k] = MaximumSwathHeightY[k];
6256 			SwathHeightC[k] = MinimumSwathHeightC;
6257 			RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY;
6258 			RoundedUpSwathSizeBytesC = RoundedUpMinSwathSizeBytesC;
6259 		} else {
6260 			SwathHeightY[k] = MinimumSwathHeightY;
6261 			SwathHeightC[k] = MinimumSwathHeightC;
6262 			RoundedUpSwathSizeBytesY = RoundedUpMinSwathSizeBytesY;
6263 			RoundedUpSwathSizeBytesC = RoundedUpMinSwathSizeBytesC;
6264 		}
6265 
6266 		if (SwathHeightC[k] == 0) {
6267 			DETBufferSizeY[k] = DETBufferSizeInKByte * 1024;
6268 			DETBufferSizeC[k] = 0;
6269 		} else if (RoundedUpSwathSizeBytesY <= 1.5 * RoundedUpSwathSizeBytesC) {
6270 			DETBufferSizeY[k] = DETBufferSizeInKByte * 1024 / 2;
6271 			DETBufferSizeC[k] = DETBufferSizeInKByte * 1024 / 2;
6272 		} else {
6273 			DETBufferSizeY[k] = DETBufferSizeInKByte * 1024 * 2 / 3;
6274 			DETBufferSizeC[k] = DETBufferSizeInKByte * 1024 / 3;
6275 		}
6276 
6277 		if (RoundedUpMinSwathSizeBytesY + RoundedUpMinSwathSizeBytesC
6278 				> DETBufferSizeInKByte * 1024 / 2
6279 				|| SwathWidth[k] > MaximumSwathWidthLuma[k]
6280 				|| (SwathHeightC[k] > 0
6281 						&& SwathWidthChroma[k] > MaximumSwathWidthChroma[k])) {
6282 			*ViewportSizeSupport = false;
6283 			ViewportSizeSupportPerPlane[k] = false;
6284 		} else {
6285 			ViewportSizeSupportPerPlane[k] = true;
6286 		}
6287 	}
6288 }
6289 
CalculateSwathWidth(bool ForceSingleDPP,int NumberOfActivePlanes,enum source_format_class SourcePixelFormat[],enum scan_direction_class SourceScan[],unsigned int ViewportWidth[],unsigned int ViewportHeight[],unsigned int SurfaceWidthY[],unsigned int SurfaceWidthC[],unsigned int SurfaceHeightY[],unsigned int SurfaceHeightC[],enum odm_combine_mode ODMCombineEnabled[],int BytePerPixY[],int BytePerPixC[],int Read256BytesBlockHeightY[],int Read256BytesBlockHeightC[],int Read256BytesBlockWidthY[],int Read256BytesBlockWidthC[],int BlendingAndTiming[],unsigned int HActive[],double HRatio[],int DPPPerPlane[],double SwathWidthSingleDPPY[],double SwathWidthSingleDPPC[],double SwathWidthY[],double SwathWidthC[],int MaximumSwathHeightY[],int MaximumSwathHeightC[],unsigned int swath_width_luma_ub[],unsigned int swath_width_chroma_ub[])6290 static void CalculateSwathWidth(
6291 		bool ForceSingleDPP,
6292 		int NumberOfActivePlanes,
6293 		enum source_format_class SourcePixelFormat[],
6294 		enum scan_direction_class SourceScan[],
6295 		unsigned int ViewportWidth[],
6296 		unsigned int ViewportHeight[],
6297 		unsigned int SurfaceWidthY[],
6298 		unsigned int SurfaceWidthC[],
6299 		unsigned int SurfaceHeightY[],
6300 		unsigned int SurfaceHeightC[],
6301 		enum odm_combine_mode ODMCombineEnabled[],
6302 		int BytePerPixY[],
6303 		int BytePerPixC[],
6304 		int Read256BytesBlockHeightY[],
6305 		int Read256BytesBlockHeightC[],
6306 		int Read256BytesBlockWidthY[],
6307 		int Read256BytesBlockWidthC[],
6308 		int BlendingAndTiming[],
6309 		unsigned int HActive[],
6310 		double HRatio[],
6311 		int DPPPerPlane[],
6312 		double SwathWidthSingleDPPY[],
6313 		double SwathWidthSingleDPPC[],
6314 		double SwathWidthY[],
6315 		double SwathWidthC[],
6316 		int MaximumSwathHeightY[],
6317 		int MaximumSwathHeightC[],
6318 		unsigned int swath_width_luma_ub[],
6319 		unsigned int swath_width_chroma_ub[])
6320 {
6321 	unsigned int k, j;
6322 	long surface_width_ub_l;
6323 	long surface_height_ub_l;
6324 	long surface_width_ub_c;
6325 	long surface_height_ub_c;
6326 
6327 	for (k = 0; k < NumberOfActivePlanes; ++k) {
6328 		enum odm_combine_mode MainPlaneODMCombine = 0;
6329 
6330 		if (SourceScan[k] != dm_vert) {
6331 			SwathWidthSingleDPPY[k] = ViewportWidth[k];
6332 		} else {
6333 			SwathWidthSingleDPPY[k] = ViewportHeight[k];
6334 		}
6335 
6336 		MainPlaneODMCombine = ODMCombineEnabled[k];
6337 		for (j = 0; j < NumberOfActivePlanes; ++j) {
6338 			if (BlendingAndTiming[k] == j) {
6339 				MainPlaneODMCombine = ODMCombineEnabled[j];
6340 			}
6341 		}
6342 
6343 		if (MainPlaneODMCombine == dm_odm_combine_mode_4to1) {
6344 			SwathWidthY[k] = dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 4.0 * HRatio[k]));
6345 		} else if (MainPlaneODMCombine == dm_odm_combine_mode_2to1) {
6346 			SwathWidthY[k] = dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 2.0 * HRatio[k]));
6347 		} else if (DPPPerPlane[k] == 2) {
6348 			SwathWidthY[k] = SwathWidthSingleDPPY[k] / 2;
6349 		} else {
6350 			SwathWidthY[k] = SwathWidthSingleDPPY[k];
6351 		}
6352 
6353 		if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 || SourcePixelFormat[k] == dm_420_12) {
6354 			SwathWidthC[k] = SwathWidthY[k] / 2;
6355 			SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k] / 2;
6356 		} else {
6357 			SwathWidthC[k] = SwathWidthY[k];
6358 			SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k];
6359 		}
6360 
6361 		if (ForceSingleDPP == true) {
6362 			SwathWidthY[k] = SwathWidthSingleDPPY[k];
6363 			SwathWidthC[k] = SwathWidthSingleDPPC[k];
6364 		}
6365 
6366 		surface_width_ub_l  = dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
6367 		surface_height_ub_l = dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
6368 
6369 		if (SourceScan[k] != dm_vert) {
6370 			MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k];
6371 			MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k];
6372 			swath_width_luma_ub[k] = dml_min(surface_width_ub_l, (long) dml_ceil(SwathWidthY[k] - 1,
6373 					Read256BytesBlockWidthY[k]) + Read256BytesBlockWidthY[k]);
6374 			if (BytePerPixC[k] > 0) {
6375 				surface_width_ub_c  = dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
6376 				swath_width_chroma_ub[k] = dml_min(surface_width_ub_c, (long) dml_ceil(SwathWidthC[k] - 1,
6377 						Read256BytesBlockWidthC[k]) + Read256BytesBlockWidthC[k]);
6378 			} else {
6379 				swath_width_chroma_ub[k] = 0;
6380 			}
6381 		} else {
6382 			MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k];
6383 			MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k];
6384 			swath_width_luma_ub[k] = dml_min(surface_height_ub_l, (long) dml_ceil(SwathWidthY[k] - 1,
6385 					Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]);
6386 			if (BytePerPixC[k] > 0) {
6387 				surface_height_ub_c = dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
6388 				swath_width_chroma_ub[k] = dml_min(surface_height_ub_c, (long) dml_ceil(SwathWidthC[k] - 1,
6389 						Read256BytesBlockHeightC[k]) + Read256BytesBlockHeightC[k]);
6390 			} else {
6391 				swath_width_chroma_ub[k] = 0;
6392 			}
6393 		}
6394 	}
6395 }
6396 
CalculateExtraLatency(long RoundTripPingLatencyCycles,long ReorderingBytes,double DCFCLK,int TotalNumberOfActiveDPP,int PixelChunkSizeInKByte,int TotalNumberOfDCCActiveDPP,int MetaChunkSize,double ReturnBW,bool GPUVMEnable,bool HostVMEnable,int NumberOfActivePlanes,int NumberOfDPP[],int dpte_group_bytes[],double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,double HostVMMinPageSize,int HostVMMaxNonCachedPageTableLevels)6397 static double CalculateExtraLatency(
6398 		long RoundTripPingLatencyCycles,
6399 		long ReorderingBytes,
6400 		double DCFCLK,
6401 		int TotalNumberOfActiveDPP,
6402 		int PixelChunkSizeInKByte,
6403 		int TotalNumberOfDCCActiveDPP,
6404 		int MetaChunkSize,
6405 		double ReturnBW,
6406 		bool GPUVMEnable,
6407 		bool HostVMEnable,
6408 		int NumberOfActivePlanes,
6409 		int NumberOfDPP[],
6410 		int dpte_group_bytes[],
6411 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6412 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6413 		double HostVMMinPageSize,
6414 		int HostVMMaxNonCachedPageTableLevels)
6415 {
6416 	double ExtraLatencyBytes = 0;
6417 	ExtraLatencyBytes = CalculateExtraLatencyBytes(
6418 					ReorderingBytes,
6419 					TotalNumberOfActiveDPP,
6420 					PixelChunkSizeInKByte,
6421 					TotalNumberOfDCCActiveDPP,
6422 					MetaChunkSize,
6423 					GPUVMEnable,
6424 					HostVMEnable,
6425 					NumberOfActivePlanes,
6426 					NumberOfDPP,
6427 					dpte_group_bytes,
6428 					PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6429 					PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6430 					HostVMMinPageSize,
6431 					HostVMMaxNonCachedPageTableLevels);
6432 
6433 	return (RoundTripPingLatencyCycles + 32) / DCFCLK + ExtraLatencyBytes / ReturnBW;
6434 }
6435 
CalculateExtraLatencyBytes(long ReorderingBytes,int TotalNumberOfActiveDPP,int PixelChunkSizeInKByte,int TotalNumberOfDCCActiveDPP,int MetaChunkSize,bool GPUVMEnable,bool HostVMEnable,int NumberOfActivePlanes,int NumberOfDPP[],int dpte_group_bytes[],double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,double HostVMMinPageSize,int HostVMMaxNonCachedPageTableLevels)6436 static double CalculateExtraLatencyBytes(
6437 		long ReorderingBytes,
6438 		int TotalNumberOfActiveDPP,
6439 		int PixelChunkSizeInKByte,
6440 		int TotalNumberOfDCCActiveDPP,
6441 		int MetaChunkSize,
6442 		bool GPUVMEnable,
6443 		bool HostVMEnable,
6444 		int NumberOfActivePlanes,
6445 		int NumberOfDPP[],
6446 		int dpte_group_bytes[],
6447 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6448 		double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6449 		double HostVMMinPageSize,
6450 		int HostVMMaxNonCachedPageTableLevels)
6451 {
6452 	double ret = 0;
6453 	double HostVMInefficiencyFactor = 0;
6454 	int HostVMDynamicLevels = 0;
6455 	unsigned int k;
6456 
6457 	if (GPUVMEnable == true && HostVMEnable == true) {
6458 		HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
6459 		if (HostVMMinPageSize < 2048) {
6460 			HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
6461 		} else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) {
6462 			HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
6463 		} else {
6464 			HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
6465 		}
6466 	} else {
6467 		HostVMInefficiencyFactor = 1;
6468 		HostVMDynamicLevels = 0;
6469 	}
6470 
6471 	ret = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte + TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0;
6472 
6473 	if (GPUVMEnable == true) {
6474 		for (k = 0; k < NumberOfActivePlanes; ++k) {
6475 			ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] * (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor;
6476 		}
6477 	}
6478 	return ret;
6479 }
6480 
6481 
CalculateUrgentLatency(double UrgentLatencyPixelDataOnly,double UrgentLatencyPixelMixedWithVMData,double UrgentLatencyVMDataOnly,bool DoUrgentLatencyAdjustment,double UrgentLatencyAdjustmentFabricClockComponent,double UrgentLatencyAdjustmentFabricClockReference,double FabricClock)6482 static double CalculateUrgentLatency(
6483 		double UrgentLatencyPixelDataOnly,
6484 		double UrgentLatencyPixelMixedWithVMData,
6485 		double UrgentLatencyVMDataOnly,
6486 		bool DoUrgentLatencyAdjustment,
6487 		double UrgentLatencyAdjustmentFabricClockComponent,
6488 		double UrgentLatencyAdjustmentFabricClockReference,
6489 		double FabricClock)
6490 {
6491 	double ret;
6492 
6493 	ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly);
6494 	if (DoUrgentLatencyAdjustment == true) {
6495 		ret = ret + UrgentLatencyAdjustmentFabricClockComponent * (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
6496 	}
6497 	return ret;
6498 }
6499 
UseMinimumDCFCLK(struct display_mode_lib * mode_lib,struct vba_vars_st * v,int MaxPrefetchMode,int ReorderingBytes)6500 static noinline_for_stack void UseMinimumDCFCLK(
6501 		struct display_mode_lib *mode_lib,
6502 		struct vba_vars_st *v,
6503 		int MaxPrefetchMode,
6504 		int ReorderingBytes)
6505 {
6506 	double   NormalEfficiency = 0;
6507 	double   PTEEfficiency = 0;
6508 	double   TotalMaxPrefetchFlipDPTERowBandwidth[DC__VOLTAGE_STATES][2] = { { 0 } };
6509 	unsigned int i, j, k;
6510 
6511 	NormalEfficiency =  (v->HostVMEnable == true ? v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData
6512 			: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly) / 100.0;
6513 	PTEEfficiency =  (v->HostVMEnable == true ? v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly
6514 			/ v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData : 1.0);
6515 	for (i = 0; i < mode_lib->soc.num_states; ++i) {
6516 		for (j = 0; j <= 1; ++j) {
6517 			double PixelDCFCLKCyclesRequiredInPrefetch[DC__NUM_DPP__MAX] = { 0 };
6518 			double PrefetchPixelLinesTime[DC__NUM_DPP__MAX] = { 0 };
6519 			double DCFCLKRequiredForPeakBandwidthPerPlane[DC__NUM_DPP__MAX] = { 0 };
6520 			double DynamicMetadataVMExtraLatency[DC__NUM_DPP__MAX] = { 0 };
6521 			double MinimumTWait = 0;
6522 			double NonDPTEBandwidth = 0;
6523 			double DPTEBandwidth = 0;
6524 			double DCFCLKRequiredForAverageBandwidth = 0;
6525 			double ExtraLatencyBytes = 0;
6526 			double ExtraLatencyCycles = 0;
6527 			double DCFCLKRequiredForPeakBandwidth = 0;
6528 			int NoOfDPPState[DC__NUM_DPP__MAX] = { 0 };
6529 			double MinimumTvmPlus2Tr0 = 0;
6530 
6531 			TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = 0;
6532 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
6533 				TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = TotalMaxPrefetchFlipDPTERowBandwidth[i][j]
6534 					+ v->NoOfDPP[i][j][k] * v->DPTEBytesPerRow[i][j][k] / (15.75 * v->HTotal[k] / v->PixelClock[k]);
6535 			}
6536 
6537 			for (k = 0; k <= v->NumberOfActivePlanes - 1; ++k) {
6538 				NoOfDPPState[k] = v->NoOfDPP[i][j][k];
6539 			}
6540 
6541 			MinimumTWait = CalculateTWait(MaxPrefetchMode, v->FinalDRAMClockChangeLatency, v->UrgLatency[i], v->SREnterPlusExitTime);
6542 			NonDPTEBandwidth = v->TotalVActivePixelBandwidth[i][j] + v->TotalVActiveCursorBandwidth[i][j] + v->TotalMetaRowBandwidth[i][j];
6543 			DPTEBandwidth =  (v->HostVMEnable == true || v->ImmediateFlipRequirement[0] == dm_immediate_flip_required) ?
6544 					TotalMaxPrefetchFlipDPTERowBandwidth[i][j] : v->TotalDPTERowBandwidth[i][j];
6545 			DCFCLKRequiredForAverageBandwidth = dml_max3(v->ProjectedDCFCLKDeepSleep[i][j],
6546 					(NonDPTEBandwidth + v->TotalDPTERowBandwidth[i][j]) / v->ReturnBusWidth / (v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100),
6547 					(NonDPTEBandwidth + DPTEBandwidth / PTEEfficiency) / NormalEfficiency / v->ReturnBusWidth);
6548 
6549 			ExtraLatencyBytes = CalculateExtraLatencyBytes(ReorderingBytes, v->TotalNumberOfActiveDPP[i][j], v->PixelChunkSizeInKByte, v->TotalNumberOfDCCActiveDPP[i][j],
6550 					v->MetaChunkSize, v->GPUVMEnable, v->HostVMEnable, v->NumberOfActivePlanes, NoOfDPPState, v->dpte_group_bytes,
6551 					v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData, v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6552 					v->HostVMMinPageSize, v->HostVMMaxNonCachedPageTableLevels);
6553 			ExtraLatencyCycles = v->RoundTripPingLatencyCycles + 32 + ExtraLatencyBytes / NormalEfficiency / v->ReturnBusWidth;
6554 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
6555 				double DCFCLKCyclesRequiredInPrefetch = { 0 };
6556 				double ExpectedPrefetchBWAcceleration = { 0 };
6557 				double PrefetchTime = { 0 };
6558 
6559 				PixelDCFCLKCyclesRequiredInPrefetch[k] = (v->PrefetchLinesY[i][j][k] * v->swath_width_luma_ub_all_states[i][j][k] * v->BytePerPixelY[k]
6560 					+ v->PrefetchLinesC[i][j][k] * v->swath_width_chroma_ub_all_states[i][j][k] * v->BytePerPixelC[k]) / NormalEfficiency / v->ReturnBusWidth;
6561 				DCFCLKCyclesRequiredInPrefetch = 2 * ExtraLatencyCycles / NoOfDPPState[k] + v->PDEAndMetaPTEBytesPerFrame[i][j][k] / PTEEfficiency
6562 					/ NormalEfficiency / v->ReturnBusWidth *  (v->GPUVMMaxPageTableLevels > 2 ? 1 : 0) + 2 * v->DPTEBytesPerRow[i][j][k] / PTEEfficiency
6563 					/ NormalEfficiency / v->ReturnBusWidth + 2 * v->MetaRowBytes[i][j][k] / NormalEfficiency / v->ReturnBusWidth + PixelDCFCLKCyclesRequiredInPrefetch[k];
6564 				PrefetchPixelLinesTime[k] = dml_max(v->PrefetchLinesY[i][j][k], v->PrefetchLinesC[i][j][k]) * v->HTotal[k] / v->PixelClock[k];
6565 				ExpectedPrefetchBWAcceleration = (v->VActivePixelBandwidth[i][j][k] + v->VActiveCursorBandwidth[i][j][k]) / (v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k]);
6566 				DynamicMetadataVMExtraLatency[k] = (v->GPUVMEnable == true && v->DynamicMetadataEnable[k] == true && v->DynamicMetadataVMEnabled == true) ?
6567 						v->UrgLatency[i] * v->GPUVMMaxPageTableLevels *  (v->HostVMEnable == true ? v->HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0;
6568 				PrefetchTime = (v->MaximumVStartup[i][j][k] - 1) * v->HTotal[k] / v->PixelClock[k] - MinimumTWait - v->UrgLatency[i] * ((v->GPUVMMaxPageTableLevels <= 2 ? v->GPUVMMaxPageTableLevels
6569 						: v->GPUVMMaxPageTableLevels - 2) * (v->HostVMEnable == true ? v->HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) - DynamicMetadataVMExtraLatency[k];
6570 
6571 				if (PrefetchTime > 0) {
6572 					double ExpectedVRatioPrefetch = { 0 };
6573 					ExpectedVRatioPrefetch = PrefetchPixelLinesTime[k] / (PrefetchTime * PixelDCFCLKCyclesRequiredInPrefetch[k] / DCFCLKCyclesRequiredInPrefetch);
6574 					DCFCLKRequiredForPeakBandwidthPerPlane[k] = NoOfDPPState[k] * PixelDCFCLKCyclesRequiredInPrefetch[k] / PrefetchPixelLinesTime[k]
6575 						* dml_max(1.0, ExpectedVRatioPrefetch) * dml_max(1.0, ExpectedVRatioPrefetch / 4) * ExpectedPrefetchBWAcceleration;
6576 					if (v->HostVMEnable == true || v->ImmediateFlipRequirement[0] == dm_immediate_flip_required) {
6577 						DCFCLKRequiredForPeakBandwidthPerPlane[k] = DCFCLKRequiredForPeakBandwidthPerPlane[k]
6578 							+ NoOfDPPState[k] * DPTEBandwidth / PTEEfficiency / NormalEfficiency / v->ReturnBusWidth;
6579 					}
6580 				} else {
6581 					DCFCLKRequiredForPeakBandwidthPerPlane[k] = v->DCFCLKPerState[i];
6582 				}
6583 				if (v->DynamicMetadataEnable[k] == true) {
6584 					double TsetupPipe = { 0 };
6585 					double TdmbfPipe = { 0 };
6586 					double TdmsksPipe = { 0 };
6587 					double TdmecPipe = { 0 };
6588 					double AllowedTimeForUrgentExtraLatency = { 0 };
6589 
6590 					CalculateDynamicMetadataParameters(
6591 							v->MaxInterDCNTileRepeaters,
6592 							v->RequiredDPPCLK[i][j][k],
6593 							v->RequiredDISPCLK[i][j],
6594 							v->ProjectedDCFCLKDeepSleep[i][j],
6595 							v->PixelClock[k],
6596 							v->HTotal[k],
6597 							v->VTotal[k] - v->VActive[k],
6598 							v->DynamicMetadataTransmittedBytes[k],
6599 							v->DynamicMetadataLinesBeforeActiveRequired[k],
6600 							v->Interlace[k],
6601 							v->ProgressiveToInterlaceUnitInOPP,
6602 							&TsetupPipe,
6603 							&TdmbfPipe,
6604 							&TdmecPipe,
6605 							&TdmsksPipe);
6606 					AllowedTimeForUrgentExtraLatency = v->MaximumVStartup[i][j][k] * v->HTotal[k] / v->PixelClock[k] - MinimumTWait - TsetupPipe
6607 							- TdmbfPipe - TdmecPipe - TdmsksPipe - DynamicMetadataVMExtraLatency[k];
6608 					if (AllowedTimeForUrgentExtraLatency > 0) {
6609 						DCFCLKRequiredForPeakBandwidthPerPlane[k] = dml_max(DCFCLKRequiredForPeakBandwidthPerPlane[k],
6610 								ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency);
6611 					} else {
6612 						DCFCLKRequiredForPeakBandwidthPerPlane[k] = v->DCFCLKPerState[i];
6613 					}
6614 				}
6615 			}
6616 			DCFCLKRequiredForPeakBandwidth = 0;
6617 			for (k = 0; k <= v->NumberOfActivePlanes - 1; ++k) {
6618 				DCFCLKRequiredForPeakBandwidth = DCFCLKRequiredForPeakBandwidth + DCFCLKRequiredForPeakBandwidthPerPlane[k];
6619 			}
6620 			MinimumTvmPlus2Tr0 = v->UrgLatency[i] * (v->GPUVMEnable == true ? (v->HostVMEnable == true ?
6621 					(v->GPUVMMaxPageTableLevels + 2) * (v->HostVMMaxNonCachedPageTableLevels + 1) - 1 : v->GPUVMMaxPageTableLevels + 1) : 0);
6622 			for (k = 0; k < v->NumberOfActivePlanes; ++k) {
6623 				double MaximumTvmPlus2Tr0PlusTsw = { 0 };
6624 				MaximumTvmPlus2Tr0PlusTsw = (v->MaximumVStartup[i][j][k] - 2) * v->HTotal[k] / v->PixelClock[k] - MinimumTWait - DynamicMetadataVMExtraLatency[k];
6625 				if (MaximumTvmPlus2Tr0PlusTsw <= MinimumTvmPlus2Tr0 + PrefetchPixelLinesTime[k] / 4) {
6626 					DCFCLKRequiredForPeakBandwidth = v->DCFCLKPerState[i];
6627 				} else {
6628 					DCFCLKRequiredForPeakBandwidth = dml_max3(DCFCLKRequiredForPeakBandwidth, 2 * ExtraLatencyCycles
6629 							/ (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0 - PrefetchPixelLinesTime[k] / 4),
6630 						(2 * ExtraLatencyCycles + PixelDCFCLKCyclesRequiredInPrefetch[k]) / (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0));
6631 				}
6632 			}
6633 			v->DCFCLKState[i][j] = dml_min(v->DCFCLKPerState[i], 1.05 * (1 + mode_lib->vba.PercentMarginOverMinimumRequiredDCFCLK / 100)
6634 					* dml_max(DCFCLKRequiredForAverageBandwidth, DCFCLKRequiredForPeakBandwidth));
6635 		}
6636 	}
6637 }
6638 
6639