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
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
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(a: 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
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
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	DPPCLK: myPipe->DPPCLK,
919	DISPCLK: myPipe->DISPCLK,
920	DCFClkDeepSleep: myPipe->DCFCLKDeepSleep,
921	PixelClock: myPipe->PixelClock,
922	HTotal: myPipe->HTotal,
923	VBlank: myPipe->VBlank,
924	DynamicMetadataTransmittedBytes,
925	DynamicMetadataLinesBeforeActiveRequired,
926	InterlaceEnable: myPipe->InterlaceEnable,
927	ProgressiveToInterlaceUnitInOPP,
928	Tsetup: &Tsetup,
929	Tdmbf: &Tdmbf,
930	Tdmec: &Tdmec,
931	Tdmsks: &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(a: DSTTotalPixelsAfterScaler / myPipe->HTotal, granularity: 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(a: 4.0 * Tvm_trips / LineTime, granularity: 1) / 4 * LineTime;
991	Tr0_trips_rounded = dml_ceil(a: 4.0 * Tr0_trips / LineTime, granularity: 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(a: TWait + TCalc, b: *Tdmdl)) / LineTime
1004	- (*DSTYAfterScaler + *DSTXAfterScaler / myPipe->HTotal);
1005
1006	Lsw_oto = dml_max(a: PrefetchSourceLinesY, b: 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(a: *Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_oto,
1013	b: Tvm_trips,
1014	c: 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	a: (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto,
1021	b: LineTime - Tvm_oto, c: LineTime / 4);
1022	} else
1023	Tr0_oto = (LineTime - Tvm_oto) / 2.0;
1024
1025	Tvm_oto_lines = dml_ceil(a: 4.0 * Tvm_oto / LineTime, granularity: 1) / 4.0;
1026	Tr0_oto_lines = dml_ceil(a: 4.0 * Tr0_oto / LineTime, granularity: 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(a: 4.0 * (dst_y_prefetch_equ + 0.125), granularity: 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(a: *Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_equ, b: Tvm_trips, c: LineTime / 4);
1156	} else {
1157	Tvm_equ = LineTime / 4;
1158	}
1159
1160	if ((GPUVMEnable || myPipe->DCCEnable)) {
1161	Tr0_equ = dml_max4(
1162	a: (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_equ,
1163	b: Tr0_trips,
1164	c: (LineTime - Tvm_equ) / 2,
1165	d: 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(a: 4.0 * TimeForFetchingMetaPTE / LineTime, granularity: 1.0) / 4.0;
1189
1190	*DestinationLinesToRequestRowInVBlank = dml_ceil(a: 4.0 * TimeForFetchingRowInVBlank / LineTime, granularity: 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(a: *VRatioPrefetchY, b: 1.0);
1201	if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
1202	if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
1203	*VRatioPrefetchY = dml_max(a: (double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData,
1204	b: (double) MaxNumSwathY * SwathHeightY / (LinesToRequestPrefetchPixelData - (VInitPreFillY - 3.0) / 2.0));
1205	*VRatioPrefetchY = dml_max(a: *VRatioPrefetchY, b: 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(a: *VRatioPrefetchC, b: 1.0);
1215
1216	if ((SwathHeightC > 4)) {
1217	if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
1218	*VRatioPrefetchC = dml_max(a: *VRatioPrefetchC,
1219	b: (double) MaxNumSwathC * SwathHeightC / (LinesToRequestPrefetchPixelData - (VInitPreFillC - 3.0) / 2.0));
1220	*VRatioPrefetchC = dml_max(a: *VRatioPrefetchC, b: 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(a: prefetch_vm_bw, b: 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
1298	static double RoundToDFSGranularityUp(double Clock, double VCOSpeed)
1299	{
1300	return VCOSpeed * 4 / dml_floor(a: VCOSpeed * 4 / Clock, granularity: 1);
1301	}
1302
1303	static double RoundToDFSGranularityDown(double Clock, double VCOSpeed)
1304	{
1305	return VCOSpeed * 4 / dml_ceil(a: VCOSpeed * 4.0 / Clock, granularity: 1);
1306	}
1307
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(a: detile_buf_vp_horz_limit - 1, granularity: 16);
1421	detile_buf_vp_vert_limit = dml_floor(a: detile_buf_vp_vert_limit - 1, granularity: 16);
1422
1423	MAS_vp_horz_limit = 5760;
1424	MAS_vp_vert_limit = (BytePerPixelC > 0 ? 2880 : 5760);
1425	max_vp_horz_width = dml_min(a: (double) MAS_vp_horz_limit, b: detile_buf_vp_horz_limit);
1426	max_vp_vert_height = dml_min(a: (double) MAS_vp_vert_limit, b: 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(a: full_swath_bytes_horz_wc_l * 2 / 3, granularity: 256);
1448	full_swath_bytes_horz_wc_c = dml_ceil(a: full_swath_bytes_horz_wc_c * 2 / 3, granularity: 256);
1449	full_swath_bytes_vert_wc_l = dml_ceil(a: full_swath_bytes_vert_wc_l * 2 / 3, granularity: 256);
1450	full_swath_bytes_vert_wc_c = dml_ceil(a: full_swath_bytes_vert_wc_c * 2 / 3, granularity: 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
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(a: (VRatio + vtaps + 1) / 2.0, granularity: 1);
1625	else
1626	*VInitPreFill = dml_floor(a: (VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, granularity: 1);
1627
1628	if (!mode_lib->vba.IgnoreViewportPositioning) {
1629
1630	*MaxNumSwath = dml_ceil(a: (*VInitPreFill - 1.0) / SwathHeight, granularity: 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(a: 1U, b: 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(a: *VInitPreFill / SwathHeight, granularity: 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
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(a: 0, b: (int) HostVMMaxNonCachedPageTableLevels - 1);
1710	} else {
1711	HostVMDynamicLevels = dml_max(a: 0, b: (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(a: (double) SwathWidth - 1, granularity: *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(a: (double) SwathWidth - 1, granularity: *MetaRequestHeight)
1725	+ *MetaRequestHeight;
1726	*MetaRowByte = *meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0;
1727	}
1728	DCCMetaSurfaceBytes = DCCMetaPitch * (dml_ceil(a: ViewportHeight - 1, granularity: 64 * BlockHeight256Bytes)
1729	+ 64 * BlockHeight256Bytes) * BytePerPixel / 256;
1730	if (GPUVMEnable == true) {
1731	*MetaPTEBytesFrame = (dml_ceil(a: (double) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / (8 * 4.0 * 1024), granularity: 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(a: ((Pitch * (dml_ceil(a: ViewportHeight - 1, granularity: MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), granularity: 1) + 1);
1756	} else {
1757	*DPDE0BytesFrame = 64 * (dml_ceil(a: ((Pitch * (dml_ceil(a: (double) SwathWidth - 1, granularity: MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), granularity: 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(a: 128, b: 1 << (unsigned int) dml_floor(a: dml_log2(x: PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), granularity: 1));
1806	*dpte_row_width_ub = (dml_ceil(a: ((double) SwathWidth - 1) / *PixelPTEReqWidth, granularity: 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(a: (double) (SwathWidth - 1) / *PixelPTEReqWidth, granularity: 1) + 1) * *PixelPTEReqWidth;
1811	*PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
1812	} else {
1813	*dpte_row_height = dml_min(a: *PixelPTEReqWidth, b: *MacroTileWidth);
1814	*dpte_row_width_ub = (dml_ceil(a: (double) (SwathWidth - 1) / *PixelPTEReqHeight, granularity: 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
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	a: v->ReturnBusWidth * v->DCFCLK,
1872	b: v->DRAMSpeedPerState[v->VoltageLevel] * v->NumberOfChannels * v->DRAMChannelWidth,
1873	c: 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(a: v->WritebackDISPCLK,
1886	b: dml30_CalculateWriteBackDISPCLK(
1887	WritebackPixelFormat: v->WritebackPixelFormat[k],
1888	PixelClock: v->PixelClock[k],
1889	WritebackHRatio: v->WritebackHRatio[k],
1890	WritebackVRatio: v->WritebackVRatio[k],
1891	WritebackHTaps: v->WritebackHTaps[k],
1892	WritebackVTaps: v->WritebackVTaps[k],
1893	WritebackSourceWidth: v->WritebackSourceWidth[k],
1894	WritebackDestinationWidth: v->WritebackDestinationWidth[k],
1895	HTotal: v->HTotal[k],
1896	WritebackLineBufferSize: 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(a: v->MaxDCHUBToPSCLThroughput,
1903	b: v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(a: v->htaps[k] / 6.0, granularity: 1));
1904	} else {
1905	v->PSCL_THROUGHPUT_LUMA[k] = dml_min(
1906	a: v->MaxDCHUBToPSCLThroughput,
1907	b: v->MaxPSCLToLBThroughput);
1908	}
1909
1910	v->DPPCLKUsingSingleDPPLuma = v->PixelClock[k]
1911	* dml_max(a: v->vtaps[k] / 6.0 * dml_min(a: 1.0, b: v->HRatio[k]),
1912	b: dml_max(a: v->HRatio[k] * v->VRatio[k] / v->PSCL_THROUGHPUT_LUMA[k], b: 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(a: v->MaxDCHUBToPSCLThroughput,
1928	b: v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(a: v->HTAPsChroma[k] / 6.0, granularity: 1.0));
1929	} else {
1930	v->PSCL_THROUGHPUT_CHROMA[k] = dml_min(
1931	a: v->MaxDCHUBToPSCLThroughput,
1932	b: v->MaxPSCLToLBThroughput);
1933	}
1934	v->DPPCLKUsingSingleDPPChroma = v->PixelClock[k]
1935	* dml_max3(a: v->VTAPsChroma[k] / 6.0 * dml_min(a: 1.0, b: v->HRatioChroma[k]),
1936	b: v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_THROUGHPUT_CHROMA[k], c: 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	a: v->DPPCLKUsingSingleDPPLuma,
1947	b: 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(a: v->DISPCLKWithRamping,
1956	b: v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1957	* (1 + v->DISPCLKRampingMargin / 100));
1958	v->DISPCLKWithoutRamping = dml_max(a: v->DISPCLKWithoutRamping,
1959	b: v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1960	} else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
1961	v->DISPCLKWithRamping = dml_max(a: v->DISPCLKWithRamping,
1962	b: v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1963	* (1 + v->DISPCLKRampingMargin / 100));
1964	v->DISPCLKWithoutRamping = dml_max(a: v->DISPCLKWithoutRamping,
1965	b: v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1966	} else {
1967	v->DISPCLKWithRamping = dml_max(a: v->DISPCLKWithRamping,
1968	b: v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1969	* (1 + v->DISPCLKRampingMargin / 100));
1970	v->DISPCLKWithoutRamping = dml_max(a: v->DISPCLKWithoutRamping,
1971	b: v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
1972	}
1973	}
1974
1975	v->DISPCLKWithRamping = dml_max(
1976	a: v->DISPCLKWithRamping,
1977	b: v->WritebackDISPCLK);
1978	v->DISPCLKWithoutRamping = dml_max(
1979	a: v->DISPCLKWithoutRamping,
1980	b: v->WritebackDISPCLK);
1981
1982	ASSERT(v->DISPCLKDPPCLKVCOSpeed != 0);
1983	v->DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1984	Clock: v->DISPCLKWithRamping,
1985	VCOSpeed: v->DISPCLKDPPCLKVCOSpeed);
1986	v->DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1987	Clock: v->DISPCLKWithoutRamping,
1988	VCOSpeed: v->DISPCLKDPPCLKVCOSpeed);
1989	v->MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown(
1990	Clock: v->soc.clock_limits[mode_lib->soc.num_states - 1].dispclk_mhz,
1991	VCOSpeed: 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	a: v->GlobalDPPCLK,
2012	b: v->DPPCLK_calculated[k]);
2013	}
2014	v->GlobalDPPCLK = RoundToDFSGranularityUp(
2015	Clock: v->GlobalDPPCLK,
2016	VCOSpeed: v->DISPCLKDPPCLKVCOSpeed);
2017	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2018	v->DPPCLK_calculated[k] = v->GlobalDPPCLK / 255
2019	* dml_ceil(
2020	a: v->DPPCLK_calculated[k] * 255.0
2021	/ v->GlobalDPPCLK,
2022	granularity: 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	SourcePixelFormat: v->SourcePixelFormat[k],
2034	SurfaceTiling: v->SurfaceTiling[k],
2035	BytePerPixelY: &v->BytePerPixelY[k],
2036	BytePerPixelC: &v->BytePerPixelC[k],
2037	BytePerPixelDETY: &v->BytePerPixelDETY[k],
2038	BytePerPixelDETC: &v->BytePerPixelDETC[k],
2039	BlockHeight256BytesY: &v->BlockHeight256BytesY[k],
2040	BlockHeight256BytesC: &v->BlockHeight256BytesC[k],
2041	BlockWidth256BytesY: &v->BlockWidth256BytesY[k],
2042	BlockWidth256BytesC: &v->BlockWidth256BytesC[k]);
2043	}
2044
2045	CalculateSwathWidth(
2046	ForceSingleDPP: false,
2047	NumberOfActivePlanes: v->NumberOfActivePlanes,
2048	SourcePixelFormat: v->SourcePixelFormat,
2049	SourceScan: v->SourceScan,
2050	ViewportWidth: v->ViewportWidth,
2051	ViewportHeight: v->ViewportHeight,
2052	SurfaceWidthY: v->SurfaceWidthY,
2053	SurfaceWidthC: v->SurfaceWidthC,
2054	SurfaceHeightY: v->SurfaceHeightY,
2055	SurfaceHeightC: v->SurfaceHeightC,
2056	ODMCombineEnabled: v->ODMCombineEnabled,
2057	BytePerPixY: v->BytePerPixelY,
2058	BytePerPixC: v->BytePerPixelC,
2059	Read256BytesBlockHeightY: v->BlockHeight256BytesY,
2060	Read256BytesBlockHeightC: v->BlockHeight256BytesC,
2061	Read256BytesBlockWidthY: v->BlockWidth256BytesY,
2062	Read256BytesBlockWidthC: v->BlockWidth256BytesC,
2063	BlendingAndTiming: v->BlendingAndTiming,
2064	HActive: v->HActive,
2065	HRatio: v->HRatio,
2066	DPPPerPlane: v->DPPPerPlane,
2067	SwathWidthSingleDPPY: v->SwathWidthSingleDPPY,
2068	SwathWidthSingleDPPC: v->SwathWidthSingleDPPC,
2069	SwathWidthY: v->SwathWidthY,
2070	SwathWidthC: v->SwathWidthC,
2071	MaximumSwathHeightY: v->dummyinteger3,
2072	MaximumSwathHeightC: v->dummyinteger4,
2073	swath_width_luma_ub: v->swath_width_luma_ub,
2074	swath_width_chroma_ub: 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	NumberOfActivePlanes: v->NumberOfActivePlanes,
2088	BytePerPixelY: v->BytePerPixelY,
2089	BytePerPixelC: v->BytePerPixelC,
2090	VRatio: v->VRatio,
2091	VRatioChroma: v->VRatioChroma,
2092	SwathWidthY: v->SwathWidthY,
2093	SwathWidthC: v->SwathWidthC,
2094	DPPPerPlane: v->DPPPerPlane,
2095	HRatio: v->HRatio,
2096	HRatioChroma: v->HRatioChroma,
2097	PixelClock: v->PixelClock,
2098	PSCL_THROUGHPUT: v->PSCL_THROUGHPUT_LUMA,
2099	PSCL_THROUGHPUT_CHROMA: v->PSCL_THROUGHPUT_CHROMA,
2100	DPPCLK: v->DPPCLK,
2101	ReadBandwidthLuma: v->ReadBandwidthPlaneLuma,
2102	ReadBandwidthChroma: v->ReadBandwidthPlaneChroma,
2103	ReturnBusWidth: v->ReturnBusWidth,
2104	DCFCLKDeepSleep: &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(bpc: v->DSCInputBitPerComponent[k],
2138	BPP,
2139	sliceWidth: dml_ceil(a: (double) v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1),
2140	numSlices: v->NumberOfDSCSlices[k],
2141	pixelFormat: v->OutputFormat[k],
2142	Output: v->Output[k])
2143	+ dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: v->Output[k]);
2144	} else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2145	v->DSCDelay[k] = 2 * dscceComputeDelay(bpc: v->DSCInputBitPerComponent[k],
2146	BPP,
2147	sliceWidth: dml_ceil(a: (double) v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1),
2148	numSlices: v->NumberOfDSCSlices[k] / 2.0,
2149	pixelFormat: v->OutputFormat[k],
2150	Output: v->Output[k])
2151	+ dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: v->Output[k]);
2152	} else {
2153	v->DSCDelay[k] = 4 * dscceComputeDelay(bpc: v->DSCInputBitPerComponent[k],
2154	BPP,
2155	sliceWidth: dml_ceil(a: (double) v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1),
2156	numSlices: v->NumberOfDSCSlices[k] / 4.0,
2157	pixelFormat: v->OutputFormat[k],
2158	Output: v->Output[k])
2159	+ dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: 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	DCCEnable: v->DCCEnable[k],
2197	BlockHeight256Bytes: v->BlockHeight256BytesC[k],
2198	BlockWidth256Bytes: v->BlockWidth256BytesC[k],
2199	SourcePixelFormat: v->SourcePixelFormat[k],
2200	SurfaceTiling: v->SurfaceTiling[k],
2201	BytePerPixel: v->BytePerPixelC[k],
2202	ScanDirection: v->SourceScan[k],
2203	SwathWidth: v->SwathWidthC[k],
2204	ViewportHeight: v->ViewportHeightChroma[k],
2205	GPUVMEnable: v->GPUVMEnable,
2206	HostVMEnable: v->HostVMEnable,
2207	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
2208	GPUVMMinPageSize: v->GPUVMMinPageSize,
2209	HostVMMinPageSize: v->HostVMMinPageSize,
2210	PTEBufferSizeInRequests: v->PTEBufferSizeInRequestsForChroma,
2211	Pitch: v->PitchC[k],
2212	DCCMetaPitch: v->DCCMetaPitchC[k],
2213	MacroTileWidth: &v->MacroTileWidthC[k],
2214	MetaRowByte: &MetaRowByteC,
2215	PixelPTEBytesPerRow: &PixelPTEBytesPerRowC,
2216	PTEBufferSizeNotExceeded: &PTEBufferSizeNotExceededC,
2217	dpte_row_width_ub: &v->dpte_row_width_chroma_ub[k],
2218	dpte_row_height: &v->dpte_row_height_chroma[k],
2219	MetaRequestWidth: &v->meta_req_width_chroma[k],
2220	MetaRequestHeight: &v->meta_req_height_chroma[k],
2221	meta_row_width: &v->meta_row_width_chroma[k],
2222	meta_row_height: &v->meta_row_height_chroma[k],
2223	vm_group_bytes: &v->dummyinteger1,
2224	dpte_group_bytes: &v->dummyinteger2,
2225	PixelPTEReqWidth: &v->PixelPTEReqWidthC[k],
2226	PixelPTEReqHeight: &v->PixelPTEReqHeightC[k],
2227	PTERequestSize: &v->PTERequestSizeC[k],
2228	DPDE0BytesFrame: &v->dpde0_bytes_per_frame_ub_c[k],
2229	MetaPTEBytesFrame: &v->meta_pte_bytes_per_frame_ub_c[k]);
2230
2231	v->PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(
2232	mode_lib,
2233	VRatio: v->VRatioChroma[k],
2234	vtaps: v->VTAPsChroma[k],
2235	Interlace: v->Interlace[k],
2236	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
2237	SwathHeight: v->SwathHeightC[k],
2238	ViewportYStart: v->ViewportYStartC[k],
2239	VInitPreFill: &v->VInitPreFillC[k],
2240	MaxNumSwath: &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	DCCEnable: v->DCCEnable[k],
2254	BlockHeight256Bytes: v->BlockHeight256BytesY[k],
2255	BlockWidth256Bytes: v->BlockWidth256BytesY[k],
2256	SourcePixelFormat: v->SourcePixelFormat[k],
2257	SurfaceTiling: v->SurfaceTiling[k],
2258	BytePerPixel: v->BytePerPixelY[k],
2259	ScanDirection: v->SourceScan[k],
2260	SwathWidth: v->SwathWidthY[k],
2261	ViewportHeight: v->ViewportHeight[k],
2262	GPUVMEnable: v->GPUVMEnable,
2263	HostVMEnable: v->HostVMEnable,
2264	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
2265	GPUVMMinPageSize: v->GPUVMMinPageSize,
2266	HostVMMinPageSize: v->HostVMMinPageSize,
2267	PTEBufferSizeInRequests: v->PTEBufferSizeInRequestsForLuma,
2268	Pitch: v->PitchY[k],
2269	DCCMetaPitch: v->DCCMetaPitchY[k],
2270	MacroTileWidth: &v->MacroTileWidthY[k],
2271	MetaRowByte: &MetaRowByteY,
2272	PixelPTEBytesPerRow: &PixelPTEBytesPerRowY,
2273	PTEBufferSizeNotExceeded: &PTEBufferSizeNotExceededY,
2274	dpte_row_width_ub: &v->dpte_row_width_luma_ub[k],
2275	dpte_row_height: &v->dpte_row_height[k],
2276	MetaRequestWidth: &v->meta_req_width[k],
2277	MetaRequestHeight: &v->meta_req_height[k],
2278	meta_row_width: &v->meta_row_width[k],
2279	meta_row_height: &v->meta_row_height[k],
2280	vm_group_bytes: &v->vm_group_bytes[k],
2281	dpte_group_bytes: &v->dpte_group_bytes[k],
2282	PixelPTEReqWidth: &v->PixelPTEReqWidthY[k],
2283	PixelPTEReqHeight: &v->PixelPTEReqHeightY[k],
2284	PTERequestSize: &v->PTERequestSizeY[k],
2285	DPDE0BytesFrame: &v->dpde0_bytes_per_frame_ub_l[k],
2286	MetaPTEBytesFrame: &v->meta_pte_bytes_per_frame_ub_l[k]);
2287
2288	v->PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
2289	mode_lib,
2290	VRatio: v->VRatio[k],
2291	vtaps: v->vtaps[k],
2292	Interlace: v->Interlace[k],
2293	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
2294	SwathHeight: v->SwathHeightY[k],
2295	ViewportYStart: v->ViewportYStartY[k],
2296	VInitPreFill: &v->VInitPreFillY[k],
2297	MaxNumSwath: &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	GPUVMEnable: v->GPUVMEnable,
2305	SourcePixelFormat: v->SourcePixelFormat[k],
2306	VRatio: v->VRatio[k],
2307	VRatioChroma: v->VRatioChroma[k],
2308	DCCEnable: v->DCCEnable[k],
2309	LineTime: v->HTotal[k] / v->PixelClock[k],
2310	MetaRowByteLuma: MetaRowByteY,
2311	MetaRowByteChroma: MetaRowByteC,
2312	meta_row_height_luma: v->meta_row_height[k],
2313	meta_row_height_chroma: v->meta_row_height_chroma[k],
2314	PixelPTEBytesPerRowLuma: PixelPTEBytesPerRowY,
2315	PixelPTEBytesPerRowChroma: PixelPTEBytesPerRowC,
2316	dpte_row_height_luma: v->dpte_row_height[k],
2317	dpte_row_height_chroma: v->dpte_row_height_chroma[k],
2318	meta_row_bw: &v->meta_row_bw[k],
2319	dpte_row_bw: &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	a: v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2335	b: v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2336	c: v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
2337
2338	v->UrgentExtraLatency = CalculateExtraLatency(
2339	RoundTripPingLatencyCycles: v->RoundTripPingLatencyCycles,
2340	ReorderingBytes: ReorderBytes,
2341	DCFCLK: v->DCFCLK,
2342	TotalNumberOfActiveDPP: v->TotalActiveDPP,
2343	PixelChunkSizeInKByte: v->PixelChunkSizeInKByte,
2344	TotalNumberOfDCCActiveDPP: v->TotalDCCActiveDPP,
2345	MetaChunkSize: v->MetaChunkSize,
2346	ReturnBW: v->ReturnBW,
2347	GPUVMEnable: v->GPUVMEnable,
2348	HostVMEnable: v->HostVMEnable,
2349	NumberOfActivePlanes: v->NumberOfActivePlanes,
2350	NumberOfDPP: v->DPPPerPlane,
2351	dpte_group_bytes: v->dpte_group_bytes,
2352	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2353	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2354	HostVMMinPageSize: v->HostVMMinPageSize,
2355	HostVMMaxNonCachedPageTableLevels: 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(WritebackPixelFormat: v->WritebackPixelFormat[k],
2364	WritebackHRatio: v->WritebackHRatio[k],
2365	WritebackVRatio: v->WritebackVRatio[k],
2366	WritebackVTaps: v->WritebackVTaps[k],
2367	WritebackDestinationWidth: v->WritebackDestinationWidth[k],
2368	WritebackDestinationHeight: v->WritebackDestinationHeight[k],
2369	WritebackSourceHeight: v->WritebackSourceHeight[k],
2370	HTotal: 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(a: v->WritebackDelay[v->VoltageLevel][k],
2377	b: v->WritebackLatency + CalculateWriteBackDelay(
2378	WritebackPixelFormat: v->WritebackPixelFormat[j],
2379	WritebackHRatio: v->WritebackHRatio[j],
2380	WritebackVRatio: v->WritebackVRatio[j],
2381	WritebackVTaps: v->WritebackVTaps[j],
2382	WritebackDestinationWidth: v->WritebackDestinationWidth[j],
2383	WritebackDestinationHeight: v->WritebackDestinationHeight[j],
2384	WritebackSourceHeight: v->WritebackSourceHeight[j],
2385	HTotal: 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(a: 1.0, b: dml_ceil(a: (double) v->WritebackDelay[v->VoltageLevel][k] / (v->HTotal[k] / v->PixelClock[k]), granularity: 1));
2398	}
2399
2400	v->MaximumMaxVStartupLines = 0;
2401	for (k = 0; k < v->NumberOfActivePlanes; ++k)
2402	v->MaximumMaxVStartupLines = dml_max(a: v->MaximumMaxVStartupLines, b: 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(UrgentLatencyPixelDataOnly: v->UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData: v->UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly: v->UrgentLatencyVMDataOnly, DoUrgentLatencyAdjustment: v->DoUrgentLatencyAdjustment, UrgentLatencyAdjustmentFabricClockComponent: v->UrgentLatencyAdjustmentFabricClockComponent, UrgentLatencyAdjustmentFabricClockReference: v->UrgentLatencyAdjustmentFabricClockReference, FabricClockSingle: 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	DRAMClockChangeLatency: v->FinalDRAMClockChangeLatency,
2425	UrgentLatency: v->UrgentLatency,
2426	SREnterPlusExitTime: 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	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2452	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2453	myPipe: &myPipe,
2454	DSCDelay: v->DSCDelay[k],
2455	DPPCLKDelaySubtotalPlusCNVCFormater: v->DPPCLKDelaySubtotal
2456	+ v->DPPCLKDelayCNVCFormater,
2457	DPPCLKDelaySCL: v->DPPCLKDelaySCL,
2458	DPPCLKDelaySCLLBOnly: v->DPPCLKDelaySCLLBOnly,
2459	DPPCLKDelayCNVCCursor: v->DPPCLKDelayCNVCCursor,
2460	DISPCLKDelaySubtotal: v->DISPCLKDelaySubtotal,
2461	DPP_RECOUT_WIDTH: (unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
2462	OutputFormat: v->OutputFormat[k],
2463	MaxInterDCNTileRepeaters: v->MaxInterDCNTileRepeaters,
2464	VStartup: dml_min(a: v->VStartupLines, b: v->MaxVStartupLines[k]),
2465	MaxVStartup: v->MaxVStartupLines[k],
2466	GPUVMPageTableLevels: v->GPUVMMaxPageTableLevels,
2467	GPUVMEnable: v->GPUVMEnable,
2468	HostVMEnable: v->HostVMEnable,
2469	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
2470	HostVMMinPageSize: v->HostVMMinPageSize,
2471	DynamicMetadataEnable: v->DynamicMetadataEnable[k],
2472	DynamicMetadataVMEnabled: v->DynamicMetadataVMEnabled,
2473	DynamicMetadataLinesBeforeActiveRequired: v->DynamicMetadataLinesBeforeActiveRequired[k],
2474	DynamicMetadataTransmittedBytes: v->DynamicMetadataTransmittedBytes[k],
2475	UrgentLatency: v->UrgentLatency,
2476	UrgentExtraLatency: v->UrgentExtraLatency,
2477	TCalc: v->TCalc,
2478	PDEAndMetaPTEBytesFrame: v->PDEAndMetaPTEBytesFrame[k],
2479	MetaRowByte: v->MetaRowByte[k],
2480	PixelPTEBytesPerRow: v->PixelPTEBytesPerRow[k],
2481	PrefetchSourceLinesY: v->PrefetchSourceLinesY[k],
2482	SwathWidthY: v->SwathWidthY[k],
2483	BytePerPixelY: v->BytePerPixelY[k],
2484	VInitPreFillY: v->VInitPreFillY[k],
2485	MaxNumSwathY: v->MaxNumSwathY[k],
2486	PrefetchSourceLinesC: v->PrefetchSourceLinesC[k],
2487	SwathWidthC: v->SwathWidthC[k],
2488	BytePerPixelC: v->BytePerPixelC[k],
2489	VInitPreFillC: v->VInitPreFillC[k],
2490	MaxNumSwathC: v->MaxNumSwathC[k],
2491	swath_width_luma_ub: v->swath_width_luma_ub[k],
2492	swath_width_chroma_ub: v->swath_width_chroma_ub[k],
2493	SwathHeightY: v->SwathHeightY[k],
2494	SwathHeightC: v->SwathHeightC[k],
2495	TWait,
2496	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
2497	DSTXAfterScaler: &v->DSTXAfterScaler[k],
2498	DSTYAfterScaler: &v->DSTYAfterScaler[k],
2499	DestinationLinesForPrefetch: &v->DestinationLinesForPrefetch[k],
2500	PrefetchBandwidth: &v->PrefetchBandwidth[k],
2501	DestinationLinesToRequestVMInVBlank: &v->DestinationLinesToRequestVMInVBlank[k],
2502	DestinationLinesToRequestRowInVBlank: &v->DestinationLinesToRequestRowInVBlank[k],
2503	VRatioPrefetchY: &v->VRatioPrefetchY[k],
2504	VRatioPrefetchC: &v->VRatioPrefetchC[k],
2505	RequiredPrefetchPixDataBWLuma: &v->RequiredPrefetchPixDataBWLuma[k],
2506	RequiredPrefetchPixDataBWChroma: &v->RequiredPrefetchPixDataBWChroma[k],
2507	NotEnoughTimeForDynamicMetadata: &v->NotEnoughTimeForDynamicMetadata[k],
2508	Tno_bw: &v->Tno_bw[k],
2509	prefetch_vmrow_bw: &v->prefetch_vmrow_bw[k],
2510	Tdmdl_vm: &v->Tdmdl_vm[k],
2511	Tdmdl: &v->Tdmdl[k],
2512	VUpdateOffsetPix: &v->VUpdateOffsetPix[k],
2513	VUpdateWidthPix: &v->VUpdateWidthPix[k],
2514	VReadyOffsetPix: &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(a: 150.0 / v->DPPCLK[k], b: TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[k];
2519	v->VUpdateOffsetPix[k] = dml_ceil(a: v->HTotal[k] / 4.0, granularity: 1);
2520	v->VStartup[k] = dml_min(a: v->VStartupLines, b: 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(a: 150.0 / v->DPPCLK[k], b: TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[x];
2526	v->VUpdateOffsetPix[k] = dml_ceil(a: v->HTotal[x] / 4.0, granularity: 1);
2527	if (!v->MaxVStartupLines[x])
2528	v->MaxVStartupLines[x] = v->MaxVStartupLines[k];
2529	v->VStartup[k] = dml_min(a: v->VStartupLines, b: 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	swath_width_luma_ub: v->swath_width_luma_ub[k],
2550	swath_width_chroma_ub: v->swath_width_chroma_ub[k],
2551	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
2552	SwathHeightY: v->SwathHeightY[k],
2553	SwathHeightC: v->SwathHeightC[k],
2554	LineTime: v->HTotal[k] / v->PixelClock[k],
2555	UrgentLatency: v->UrgentLatency,
2556	CursorBufferSize: v->CursorBufferSize,
2557	CursorWidth: v->CursorWidth[k][0],
2558	CursorBPP: v->CursorBPP[k][0],
2559	VRatio: v->VRatio[k],
2560	VRatioC: v->VRatioChroma[k],
2561	BytePerPixelInDETY: v->BytePerPixelDETY[k],
2562	BytePerPixelInDETC: v->BytePerPixelDETC[k],
2563	DETBufferSizeY: v->DETBufferSizeY[k],
2564	DETBufferSizeC: v->DETBufferSizeC[k],
2565	UrgentBurstFactorCursor: &v->UrgentBurstFactorCursor[k],
2566	UrgentBurstFactorLuma: &v->UrgentBurstFactorLuma[k],
2567	UrgentBurstFactorChroma: &v->UrgentBurstFactorChroma[k],
2568	NotEnoughUrgentLatencyHiding: &v->NoUrgentLatencyHiding[k]);
2569
2570	CalculateUrgentBurstFactor(
2571	swath_width_luma_ub: v->swath_width_luma_ub[k],
2572	swath_width_chroma_ub: v->swath_width_chroma_ub[k],
2573	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
2574	SwathHeightY: v->SwathHeightY[k],
2575	SwathHeightC: v->SwathHeightC[k],
2576	LineTime: v->HTotal[k] / v->PixelClock[k],
2577	UrgentLatency: v->UrgentLatency,
2578	CursorBufferSize: v->CursorBufferSize,
2579	CursorWidth: v->CursorWidth[k][0],
2580	CursorBPP: v->CursorBPP[k][0],
2581	VRatio: v->VRatioPrefetchY[k],
2582	VRatioC: v->VRatioPrefetchC[k],
2583	BytePerPixelInDETY: v->BytePerPixelDETY[k],
2584	BytePerPixelInDETC: v->BytePerPixelDETC[k],
2585	DETBufferSizeY: v->DETBufferSizeY[k],
2586	DETBufferSizeC: v->DETBufferSizeC[k],
2587	UrgentBurstFactorCursor: &v->UrgentBurstFactorCursorPre[k],
2588	UrgentBurstFactorLuma: &v->UrgentBurstFactorLumaPre[k],
2589	UrgentBurstFactorChroma: &v->UrgentBurstFactorChromaPre[k],
2590	NotEnoughUrgentLatencyHiding: &v->NoUrgentLatencyHidingPre[k]);
2591
2592	MaxTotalRDBandwidth = MaxTotalRDBandwidth +
2593	dml_max3(a: v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2594	b: 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	c: 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(a: v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2607	b: 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	c: 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	a: v->ReadBandwidthPlaneLuma[k] * v->UrgentBurstFactorLuma[k]
2645	+ v->ReadBandwidthPlaneChroma[k] * v->UrgentBurstFactorChroma[k]
2646	+ v->cursor_bw[k] * v->UrgentBurstFactorCursor[k],
2647	b: 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	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2660	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2661	UrgentExtraLatency: v->UrgentExtraLatency,
2662	UrgentLatency: v->UrgentLatency,
2663	GPUVMMaxPageTableLevels: v->GPUVMMaxPageTableLevels,
2664	HostVMEnable: v->HostVMEnable,
2665	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
2666	GPUVMEnable: v->GPUVMEnable,
2667	HostVMMinPageSize: v->HostVMMinPageSize,
2668	PDEAndMetaPTEBytesPerFrame: v->PDEAndMetaPTEBytesFrame[k],
2669	MetaRowBytes: v->MetaRowByte[k],
2670	DPTEBytesPerRow: v->PixelPTEBytesPerRow[k],
2671	BandwidthAvailableForImmediateFlip: v->BandwidthAvailableForImmediateFlip,
2672	TotImmediateFlipBytes: v->TotImmediateFlipBytes,
2673	SourcePixelFormat: v->SourcePixelFormat[k],
2674	LineTime: v->HTotal[k] / v->PixelClock[k],
2675	VRatio: v->VRatio[k],
2676	VRatioChroma: v->VRatioChroma[k],
2677	Tno_bw: v->Tno_bw[k],
2678	DCCEnable: v->DCCEnable[k],
2679	dpte_row_height: v->dpte_row_height[k],
2680	meta_row_height: v->meta_row_height[k],
2681	dpte_row_height_chroma: v->dpte_row_height_chroma[k],
2682	meta_row_height_chroma: v->meta_row_height_chroma[k],
2683	DestinationLinesToRequestVMInImmediateFlip: &v->DestinationLinesToRequestVMInImmediateFlip[k],
2684	DestinationLinesToRequestRowInImmediateFlip: &v->DestinationLinesToRequestRowInImmediateFlip[k],
2685	final_flip_bw: &v->final_flip_bw[k],
2686	ImmediateFlipSupportedForPipe: &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	a: v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2693	b: 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	c: 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(a: v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2704	b: v->DPPPerPlane[k] * v->final_flip_bw[k] + v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k] + v->cursor_bw[k],
2705	c: 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	NumberOfActivePlanes: v->NumberOfActivePlanes,
2745	MaxLineBufferLines: v->MaxLineBufferLines,
2746	LineBufferSize: v->LineBufferSize,
2747	DPPOutputBufferPixels: v->DPPOutputBufferPixels,
2748	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
2749	WritebackInterfaceBufferSize: v->WritebackInterfaceBufferSize,
2750	DCFCLK: v->DCFCLK,
2751	ReturnBW: v->ReturnBW,
2752	GPUVMEnable: v->GPUVMEnable,
2753	dpte_group_bytes: v->dpte_group_bytes,
2754	MetaChunkSize: v->MetaChunkSize,
2755	UrgentLatency: v->UrgentLatency,
2756	ExtraLatency: v->UrgentExtraLatency,
2757	WritebackLatency: v->WritebackLatency,
2758	WritebackChunkSize: v->WritebackChunkSize,
2759	SOCCLK: v->SOCCLK,
2760	DRAMClockChangeLatency: v->FinalDRAMClockChangeLatency,
2761	SRExitTime: v->SRExitTime,
2762	SREnterPlusExitTime: v->SREnterPlusExitTime,
2763	DCFCLKDeepSleep: v->DCFCLKDeepSleep,
2764	DPPPerPlane: v->DPPPerPlane,
2765	DCCEnable: v->DCCEnable,
2766	DPPCLK: v->DPPCLK,
2767	DETBufferSizeY: v->DETBufferSizeY,
2768	DETBufferSizeC: v->DETBufferSizeC,
2769	SwathHeightY: v->SwathHeightY,
2770	SwathHeightC: v->SwathHeightC,
2771	LBBitPerPixel: v->LBBitPerPixel,
2772	SwathWidthY: v->SwathWidthY,
2773	SwathWidthC: v->SwathWidthC,
2774	HRatio: v->HRatio,
2775	HRatioChroma: v->HRatioChroma,
2776	vtaps: v->vtaps,
2777	VTAPsChroma: v->VTAPsChroma,
2778	VRatio: v->VRatio,
2779	VRatioChroma: v->VRatioChroma,
2780	HTotal: v->HTotal,
2781	PixelClock: v->PixelClock,
2782	BlendingAndTiming: v->BlendingAndTiming,
2783	BytePerPixelDETY: v->BytePerPixelDETY,
2784	BytePerPixelDETC: v->BytePerPixelDETC,
2785	DSTXAfterScaler: v->DSTXAfterScaler,
2786	DSTYAfterScaler: v->DSTYAfterScaler,
2787	WritebackEnable: v->WritebackEnable,
2788	WritebackPixelFormat: v->WritebackPixelFormat,
2789	WritebackDestinationWidth: v->WritebackDestinationWidth,
2790	WritebackDestinationHeight: v->WritebackDestinationHeight,
2791	WritebackSourceHeight: v->WritebackSourceHeight,
2792	DRAMClockChangeSupport: &DRAMClockChangeSupport,
2793	UrgentWatermark: &v->UrgentWatermark,
2794	WritebackUrgentWatermark: &v->WritebackUrgentWatermark,
2795	DRAMClockChangeWatermark: &v->DRAMClockChangeWatermark,
2796	WritebackDRAMClockChangeWatermark: &v->WritebackDRAMClockChangeWatermark,
2797	StutterExitWatermark: &v->StutterExitWatermark,
2798	StutterEnterPlusExitWatermark: &v->StutterEnterPlusExitWatermark,
2799	MinActiveDRAMClockChangeLatencySupported: &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(a: 0,
2813	b: 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	NumberOfActivePlanes: v->NumberOfActivePlanes,
2825	VRatio: v->VRatio,
2826	VRatioChroma: v->VRatioChroma,
2827	VRatioPrefetchY: v->VRatioPrefetchY,
2828	VRatioPrefetchC: v->VRatioPrefetchC,
2829	swath_width_luma_ub: v->swath_width_luma_ub,
2830	swath_width_chroma_ub: v->swath_width_chroma_ub,
2831	DPPPerPlane: v->DPPPerPlane,
2832	HRatio: v->HRatio,
2833	HRatioChroma: v->HRatioChroma,
2834	PixelClock: v->PixelClock,
2835	PSCL_THROUGHPUT: v->PSCL_THROUGHPUT_LUMA,
2836	PSCL_THROUGHPUT_CHROMA: v->PSCL_THROUGHPUT_CHROMA,
2837	DPPCLK: v->DPPCLK,
2838	BytePerPixelC: v->BytePerPixelC,
2839	SourceScan: v->SourceScan,
2840	NumberOfCursors: v->NumberOfCursors,
2841	CursorWidth: v->CursorWidth,
2842	CursorBPP: v->CursorBPP,
2843	BlockWidth256BytesY: v->BlockWidth256BytesY,
2844	BlockHeight256BytesY: v->BlockHeight256BytesY,
2845	BlockWidth256BytesC: v->BlockWidth256BytesC,
2846	BlockHeight256BytesC: v->BlockHeight256BytesC,
2847	DisplayPipeLineDeliveryTimeLuma: v->DisplayPipeLineDeliveryTimeLuma,
2848	DisplayPipeLineDeliveryTimeChroma: v->DisplayPipeLineDeliveryTimeChroma,
2849	DisplayPipeLineDeliveryTimeLumaPrefetch: v->DisplayPipeLineDeliveryTimeLumaPrefetch,
2850	DisplayPipeLineDeliveryTimeChromaPrefetch: v->DisplayPipeLineDeliveryTimeChromaPrefetch,
2851	DisplayPipeRequestDeliveryTimeLuma: v->DisplayPipeRequestDeliveryTimeLuma,
2852	DisplayPipeRequestDeliveryTimeChroma: v->DisplayPipeRequestDeliveryTimeChroma,
2853	DisplayPipeRequestDeliveryTimeLumaPrefetch: v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
2854	DisplayPipeRequestDeliveryTimeChromaPrefetch: v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
2855	CursorRequestDeliveryTime: v->CursorRequestDeliveryTime,
2856	CursorRequestDeliveryTimePrefetch: v->CursorRequestDeliveryTimePrefetch);
2857
2858	CalculateMetaAndPTETimes(
2859	NumberOfActivePlanes: v->NumberOfActivePlanes,
2860	GPUVMEnable: v->GPUVMEnable,
2861	MetaChunkSize: v->MetaChunkSize,
2862	MinMetaChunkSizeBytes: v->MinMetaChunkSizeBytes,
2863	HTotal: v->HTotal,
2864	VRatio: v->VRatio,
2865	VRatioChroma: v->VRatioChroma,
2866	DestinationLinesToRequestRowInVBlank: v->DestinationLinesToRequestRowInVBlank,
2867	DestinationLinesToRequestRowInImmediateFlip: v->DestinationLinesToRequestRowInImmediateFlip,
2868	DCCEnable: v->DCCEnable,
2869	PixelClock: v->PixelClock,
2870	BytePerPixelY: v->BytePerPixelY,
2871	BytePerPixelC: v->BytePerPixelC,
2872	SourceScan: v->SourceScan,
2873	dpte_row_height: v->dpte_row_height,
2874	dpte_row_height_chroma: v->dpte_row_height_chroma,
2875	meta_row_width: v->meta_row_width,
2876	meta_row_width_chroma: v->meta_row_width_chroma,
2877	meta_row_height: v->meta_row_height,
2878	meta_row_height_chroma: v->meta_row_height_chroma,
2879	meta_req_width: v->meta_req_width,
2880	meta_req_width_chroma: v->meta_req_width_chroma,
2881	meta_req_height: v->meta_req_height,
2882	meta_req_height_chroma: v->meta_req_height_chroma,
2883	dpte_group_bytes: v->dpte_group_bytes,
2884	PTERequestSizeY: v->PTERequestSizeY,
2885	PTERequestSizeC: v->PTERequestSizeC,
2886	PixelPTEReqWidthY: v->PixelPTEReqWidthY,
2887	PixelPTEReqHeightY: v->PixelPTEReqHeightY,
2888	PixelPTEReqWidthC: v->PixelPTEReqWidthC,
2889	PixelPTEReqHeightC: v->PixelPTEReqHeightC,
2890	dpte_row_width_luma_ub: v->dpte_row_width_luma_ub,
2891	dpte_row_width_chroma_ub: v->dpte_row_width_chroma_ub,
2892	DST_Y_PER_PTE_ROW_NOM_L: v->DST_Y_PER_PTE_ROW_NOM_L,
2893	DST_Y_PER_PTE_ROW_NOM_C: v->DST_Y_PER_PTE_ROW_NOM_C,
2894	DST_Y_PER_META_ROW_NOM_L: v->DST_Y_PER_META_ROW_NOM_L,
2895	DST_Y_PER_META_ROW_NOM_C: v->DST_Y_PER_META_ROW_NOM_C,
2896	TimePerMetaChunkNominal: v->TimePerMetaChunkNominal,
2897	TimePerChromaMetaChunkNominal: v->TimePerChromaMetaChunkNominal,
2898	TimePerMetaChunkVBlank: v->TimePerMetaChunkVBlank,
2899	TimePerChromaMetaChunkVBlank: v->TimePerChromaMetaChunkVBlank,
2900	TimePerMetaChunkFlip: v->TimePerMetaChunkFlip,
2901	TimePerChromaMetaChunkFlip: v->TimePerChromaMetaChunkFlip,
2902	time_per_pte_group_nom_luma: v->time_per_pte_group_nom_luma,
2903	time_per_pte_group_vblank_luma: v->time_per_pte_group_vblank_luma,
2904	time_per_pte_group_flip_luma: v->time_per_pte_group_flip_luma,
2905	time_per_pte_group_nom_chroma: v->time_per_pte_group_nom_chroma,
2906	time_per_pte_group_vblank_chroma: v->time_per_pte_group_vblank_chroma,
2907	time_per_pte_group_flip_chroma: v->time_per_pte_group_flip_chroma);
2908
2909	CalculateVMGroupAndRequestTimes(
2910	NumberOfActivePlanes: v->NumberOfActivePlanes,
2911	GPUVMEnable: v->GPUVMEnable,
2912	GPUVMMaxPageTableLevels: v->GPUVMMaxPageTableLevels,
2913	HTotal: v->HTotal,
2914	BytePerPixelC: v->BytePerPixelC,
2915	DestinationLinesToRequestVMInVBlank: v->DestinationLinesToRequestVMInVBlank,
2916	DestinationLinesToRequestVMInImmediateFlip: v->DestinationLinesToRequestVMInImmediateFlip,
2917	DCCEnable: v->DCCEnable,
2918	PixelClock: v->PixelClock,
2919	dpte_row_width_luma_ub: v->dpte_row_width_luma_ub,
2920	dpte_row_width_chroma_ub: v->dpte_row_width_chroma_ub,
2921	vm_group_bytes: v->vm_group_bytes,
2922	dpde0_bytes_per_frame_ub_l: v->dpde0_bytes_per_frame_ub_l,
2923	dpde0_bytes_per_frame_ub_c: v->dpde0_bytes_per_frame_ub_c,
2924	meta_pte_bytes_per_frame_ub_l: v->meta_pte_bytes_per_frame_ub_l,
2925	meta_pte_bytes_per_frame_ub_c: v->meta_pte_bytes_per_frame_ub_c,
2926	TimePerVMGroupVBlank: v->TimePerVMGroupVBlank,
2927	TimePerVMGroupFlip: v->TimePerVMGroupFlip,
2928	TimePerVMRequestVBlank: v->TimePerVMRequestVBlank,
2929	TimePerVMRequestFlip: 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	a: v->DRAMClockChangeWatermark,
2939	b: dml_max(
2940	a: v->StutterEnterPlusExitWatermark,
2941	b: v->UrgentWatermark));
2942	} else if (PrefetchMode == 1) {
2943	v->AllowDRAMClockChangeDuringVBlank[k] = false;
2944	v->AllowDRAMSelfRefreshDuringVBlank[k] = true;
2945	v->MinTTUVBlank[k] = dml_max(
2946	a: v->StutterEnterPlusExitWatermark,
2947	b: 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(DCCEnabled: v->DCCEnable[k], DCCProgrammingAssumesScanDirectionUnknown: false, // We should always know the direction DCCProgrammingAssumesScanDirectionUnknown,
2962	SourcePixelFormat: v->SourcePixelFormat[k],
2963	SurfaceWidthLuma: v->SurfaceWidthY[k],
2964	SurfaceWidthChroma: v->SurfaceWidthC[k],
2965	SurfaceHeightLuma: v->SurfaceHeightY[k],
2966	SurfaceHeightChroma: v->SurfaceHeightC[k],
2967	DETBufferSize: v->DETBufferSizeInKByte[0] * 1024,
2968	RequestHeight256ByteLuma: v->BlockHeight256BytesY[k],
2969	RequestHeight256ByteChroma: v->BlockHeight256BytesC[k],
2970	TilingFormat: v->SurfaceTiling[k],
2971	BytePerPixelY: v->BytePerPixelY[k],
2972	BytePerPixelC: v->BytePerPixelC[k],
2973	BytePerPixelDETY: v->BytePerPixelDETY[k],
2974	BytePerPixelDETC: v->BytePerPixelDETC[k],
2975	ScanOrientation: v->SourceScan[k],
2976	MaxUncompressedBlockLuma: &v->DCCYMaxUncompressedBlock[k],
2977	MaxUncompressedBlockChroma: &v->DCCCMaxUncompressedBlock[k],
2978	MaxCompressedBlockLuma: &v->DCCYMaxCompressedBlock[k],
2979	MaxCompressedBlockChroma: &v->DCCCMaxCompressedBlock[k],
2980	IndependentBlockLuma: &v->DCCYIndependentBlock[k],
2981	IndependentBlockChroma: &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(a: v->VStartupMargin, b: margin);
3006	}
3007	}
3008	}
3009
3010	// Stutter Efficiency
3011	CalculateStutterEfficiency(
3012	NumberOfActivePlanes: v->NumberOfActivePlanes,
3013	ROBBufferSizeInKByte: v->ROBBufferSizeInKByte,
3014	TotalDataReadBandwidth: v->TotalDataReadBandwidth,
3015	DCFCLK: v->DCFCLK,
3016	ReturnBW: v->ReturnBW,
3017	SRExitTime: v->SRExitTime,
3018	SynchronizedVBlank: v->SynchronizedVBlank,
3019	DPPPerPlane: v->DPPPerPlane,
3020	DETBufferSizeY: v->DETBufferSizeY,
3021	BytePerPixelY: v->BytePerPixelY,
3022	BytePerPixelDETY: v->BytePerPixelDETY,
3023	SwathWidthY: v->SwathWidthY,
3024	SwathHeightY: v->SwathHeightY,
3025	SwathHeightC: v->SwathHeightC,
3026	DCCRateLuma: v->DCCRateLuma,
3027	DCCRateChroma: v->DCCRateChroma,
3028	HTotal: v->HTotal,
3029	VTotal: v->VTotal,
3030	PixelClock: v->PixelClock,
3031	VRatio: v->VRatio,
3032	SourceScan: v->SourceScan,
3033	BlockHeight256BytesY: v->BlockHeight256BytesY,
3034	BlockWidth256BytesY: v->BlockWidth256BytesY,
3035	BlockHeight256BytesC: v->BlockHeight256BytesC,
3036	BlockWidth256BytesC: v->BlockWidth256BytesC,
3037	DCCYMaxUncompressedBlock: v->DCCYMaxUncompressedBlock,
3038	DCCCMaxUncompressedBlock: v->DCCCMaxUncompressedBlock,
3039	VActive: v->VActive,
3040	DCCEnable: v->DCCEnable,
3041	WritebackEnable: v->WritebackEnable,
3042	ReadBandwidthPlaneLuma: v->ReadBandwidthPlaneLuma,
3043	ReadBandwidthPlaneChroma: v->ReadBandwidthPlaneChroma,
3044	meta_row_bw: v->meta_row_bw,
3045	dpte_row_bw: v->dpte_row_bw,
3046	StutterEfficiencyNotIncludingVBlank: &v->StutterEfficiencyNotIncludingVBlank,
3047	StutterEfficiency: &v->StutterEfficiency,
3048	StutterPeriodOut: &v->StutterPeriod);
3049	}
3050
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	SourcePixelFormat: mode_lib->vba.SourcePixelFormat[k],
3076	SurfaceTiling: mode_lib->vba.SurfaceTiling[k],
3077	BytePerPixelY: &BytePerPixY[k],
3078	BytePerPixelC: &BytePerPixC[k],
3079	BytePerPixelDETY: &BytePerPixDETY[k],
3080	BytePerPixelDETC: &BytePerPixDETC[k],
3081	BlockHeight256BytesY: &Read256BytesBlockHeightY[k],
3082	BlockHeight256BytesC: &Read256BytesBlockHeightC[k],
3083	BlockWidth256BytesY: &Read256BytesBlockWidthY[k],
3084	BlockWidth256BytesC: &Read256BytesBlockWidthC[k]);
3085	}
3086	CalculateSwathAndDETConfiguration(
3087	ForceSingleDPP: false,
3088	NumberOfActivePlanes: mode_lib->vba.NumberOfActivePlanes,
3089	DETBufferSizeInKByte: mode_lib->vba.DETBufferSizeInKByte[0],
3090	MaximumSwathWidthLuma: dummy1,
3091	MaximumSwathWidthChroma: dummy2,
3092	SourceScan: mode_lib->vba.SourceScan,
3093	SourcePixelFormat: mode_lib->vba.SourcePixelFormat,
3094	SurfaceTiling: mode_lib->vba.SurfaceTiling,
3095	ViewportWidth: mode_lib->vba.ViewportWidth,
3096	ViewportHeight: mode_lib->vba.ViewportHeight,
3097	SurfaceWidthY: mode_lib->vba.SurfaceWidthY,
3098	SurfaceWidthC: mode_lib->vba.SurfaceWidthC,
3099	SurfaceHeightY: mode_lib->vba.SurfaceHeightY,
3100	SurfaceHeightC: mode_lib->vba.SurfaceHeightC,
3101	Read256BytesBlockHeightY,
3102	Read256BytesBlockHeightC,
3103	Read256BytesBlockWidthY,
3104	Read256BytesBlockWidthC,
3105	ODMCombineEnabled: mode_lib->vba.ODMCombineEnabled,
3106	BlendingAndTiming: mode_lib->vba.BlendingAndTiming,
3107	BytePerPixY,
3108	BytePerPixC,
3109	BytePerPixDETY,
3110	BytePerPixDETC,
3111	HActive: mode_lib->vba.HActive,
3112	HRatio: mode_lib->vba.HRatio,
3113	HRatioChroma: mode_lib->vba.HRatioChroma,
3114	DPPPerPlane: mode_lib->vba.DPPPerPlane,
3115	swath_width_luma_ub: dummy5,
3116	swath_width_chroma_ub: dummy6,
3117	SwathWidth: dummy3,
3118	SwathWidthChroma: dummy4,
3119	SwathHeightY: mode_lib->vba.SwathHeightY,
3120	SwathHeightC: mode_lib->vba.SwathHeightC,
3121	DETBufferSizeY: mode_lib->vba.DETBufferSizeY,
3122	DETBufferSizeC: mode_lib->vba.DETBufferSizeC,
3123	ViewportSizeSupportPerPlane: dummy7,
3124	ViewportSizeSupport: &dummysinglestring);
3125	}
3126
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
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(a: DRAMClockChangeLatency + UrgentLatency,
3224	b: dml_max(a: SREnterPlusExitTime, b: UrgentLatency));
3225	} else if (PrefetchMode == 1) {
3226	return dml_max(a: SREnterPlusExitTime, b: UrgentLatency);
3227	} else {
3228	return UrgentLatency;
3229	}
3230	}
3231
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(a: WritebackHTaps / 8.0, granularity: 1) / WritebackHRatio;
3247	DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(a: WritebackDestinationWidth / 6.0, granularity: 1) + 8.0) / HTotal;
3248	DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / WritebackSourceWidth;
3249	return dml_max3(a: DISPCLK_H, b: DISPCLK_V, c: DISPCLK_HB);
3250	}
3251
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(a: (double) WritebackDestinationWidth, b: dml_ceil(a: WritebackDestinationWidth / 6.0, granularity: 1) * WritebackVTaps);
3269	Output_lines_last_notclamped = WritebackDestinationHeight - 1 - dml_ceil(a: (WritebackSourceHeight - WritebackVInit) / WritebackVRatio, granularity: 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
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(a: 150.0 / DPPCLK, b: TotalRepeaterDelayTime + 20 / DCFClkDeepSleep + 10 / DPPCLK) * PixelClock;
3291	VUpdateOffsetPix = dml_ceil(a: HTotal / 4.0, granularity: 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
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
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(a: Tno_bw + PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / ImmediateFlipBW,
3396	b: UrgentExtraLatency + UrgentLatency * (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1), c: LineTime / 4.0);
3397	} else {
3398	TimeForFetchingMetaPTEImmediateFlip = 0;
3399	}
3400
3401	*DestinationLinesToRequestVMInImmediateFlip = dml_ceil(a: 4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), granularity: 1) / 4.0;
3402	if ((GPUVMEnable == true || DCCEnable == true)) {
3403	TimeForFetchingRowInVBlankImmediateFlip = dml_max3(a: (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW,
3404	b: UrgentLatency * (HostVMDynamicLevelsTrips + 1), c: LineTime / 4);
3405	} else {
3406	TimeForFetchingRowInVBlankImmediateFlip = 0;
3407	}
3408
3409	*DestinationLinesToRequestRowInImmediateFlip = dml_ceil(a: 4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), granularity: 1) / 4.0;
3410
3411	if (GPUVMEnable == true) {
3412	*final_flip_bw = dml_max(a: PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
3413	b: (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(a: dpte_row_height * LineTime / VRatio, b: dpte_row_height_chroma * LineTime / VRatioChroma);
3424	} else if (GPUVMEnable != true && DCCEnable == true) {
3425	min_row_time = dml_min(a: meta_row_height * LineTime / VRatio, b: meta_row_height_chroma * LineTime / VRatioChroma);
3426	} else {
3427	min_row_time = dml_min4(a: dpte_row_height * LineTime / VRatio, b: meta_row_height * LineTime / VRatio,
3428	c: dpte_row_height_chroma * LineTime / VRatioChroma, d: 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(a: dpte_row_height * LineTime / VRatio, b: 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
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(a: 16.0 * MaxLinkBPP, granularity: 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
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	AllowDRAMSelfRefreshOrDRAMClockChangeInVblank: mode_lib->vba.AllowDRAMSelfRefreshOrDRAMClockChangeInVblank,
3563	MinPrefetchMode: &MinPrefetchMode, MaxPrefetchMode: &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	SourcePixelFormat: v->SourcePixelFormat[k],
3623	SurfaceTiling: v->SurfaceTiling[k],
3624	BytePerPixelY: &v->BytePerPixelY[k],
3625	BytePerPixelC: &v->BytePerPixelC[k],
3626	BytePerPixelDETY: &v->BytePerPixelInDETY[k],
3627	BytePerPixelDETC: &v->BytePerPixelInDETC[k],
3628	BlockHeight256BytesY: &v->Read256BlockHeightY[k],
3629	BlockHeight256BytesC: &v->Read256BlockHeightC[k],
3630	BlockWidth256BytesY: &v->Read256BlockWidthY[k],
3631	BlockWidth256BytesC: &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(a: v->BytePerPixelInDETY[k], granularity: 1.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
3644	v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(a: v->BytePerPixelInDETC[k], granularity: 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(a: v->WritebackRequiredDISPCLK,
3746	b: dml30_CalculateWriteBackDISPCLK(
3747	WritebackPixelFormat: v->WritebackPixelFormat[k],
3748	PixelClock: v->PixelClock[k],
3749	WritebackHRatio: v->WritebackHRatio[k],
3750	WritebackVRatio: v->WritebackVRatio[k],
3751	WritebackHTaps: v->WritebackHTaps[k],
3752	WritebackVTaps: v->WritebackVTaps[k],
3753	WritebackSourceWidth: v->WritebackSourceWidth[k],
3754	WritebackDestinationWidth: v->WritebackDestinationWidth[k],
3755	HTotal: v->HTotal[k],
3756	WritebackLineBufferSize: 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(a: v->MaxDCHUBToPSCLThroughput, b: v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(a: v->htaps[k] / 6.0, granularity: 1.0));
3762	} else {
3763	v->PSCL_FACTOR[k] = dml_min(a: v->MaxDCHUBToPSCLThroughput, b: 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(a: v->vtaps[k] / 6.0 * dml_min(a: 1.0, b: v->HRatio[k]), b: v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k], c: 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(a: v->MaxDCHUBToPSCLThroughput,
3775	b: v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(a: v->HTAPsChroma[k] / 6.0, granularity: 1.0));
3776	} else {
3777	v->PSCL_FACTOR_CHROMA[k] = dml_min(a: v->MaxDCHUBToPSCLThroughput, b: v->MaxPSCLToLBThroughput);
3778	}
3779	v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k] * dml_max5(a: v->vtaps[k] / 6.0 * dml_min(a: 1.0, b: v->HRatio[k]),
3780	b: v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k],
3781	c: v->VTAPsChroma[k] / 6.0 * dml_min(a: 1.0, b: v->HRatioChroma[k]),
3782	d: v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_FACTOR_CHROMA[k],
3783	e: 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(a: v->HRatio[k], b: 1.0) / v->LBBitPerPixel[k]
3808	/ (v->vtaps[k] + dml_max(a: dml_ceil(a: v->VRatio[k], granularity: 1.0) - 2, b: 0.0));
3809	if (v->BytePerPixelC[k] == 0.0) {
3810	v->MaximumSwathWidthInLineBufferChroma = 0;
3811	} else {
3812	v->MaximumSwathWidthInLineBufferChroma = v->LineBufferSize * dml_max(a: v->HRatioChroma[k], b: 1.0) / v->LBBitPerPixel[k]
3813	/ (v->VTAPsChroma[k] + dml_max(a: dml_ceil(a: v->VRatioChroma[k], granularity: 1.0) - 2, b: 0.0));
3814	}
3815	v->MaximumSwathWidthLuma[k] = dml_min(a: MaximumSwathWidthSupportLuma, b: v->MaximumSwathWidthInLineBufferLuma);
3816	v->MaximumSwathWidthChroma[k] = dml_min(a: MaximumSwathWidthSupportChroma, b: v->MaximumSwathWidthInLineBufferChroma);
3817	}
3818
3819	CalculateSwathAndDETConfiguration(
3820	ForceSingleDPP: true,
3821	NumberOfActivePlanes: v->NumberOfActivePlanes,
3822	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
3823	MaximumSwathWidthLuma: v->MaximumSwathWidthLuma,
3824	MaximumSwathWidthChroma: v->MaximumSwathWidthChroma,
3825	SourceScan: v->SourceScan,
3826	SourcePixelFormat: v->SourcePixelFormat,
3827	SurfaceTiling: v->SurfaceTiling,
3828	ViewportWidth: v->ViewportWidth,
3829	ViewportHeight: v->ViewportHeight,
3830	SurfaceWidthY: v->SurfaceWidthY,
3831	SurfaceWidthC: v->SurfaceWidthC,
3832	SurfaceHeightY: v->SurfaceHeightY,
3833	SurfaceHeightC: v->SurfaceHeightC,
3834	Read256BytesBlockHeightY: v->Read256BlockHeightY,
3835	Read256BytesBlockHeightC: v->Read256BlockHeightC,
3836	Read256BytesBlockWidthY: v->Read256BlockWidthY,
3837	Read256BytesBlockWidthC: v->Read256BlockWidthC,
3838	ODMCombineEnabled: v->odm_combine_dummy,
3839	BlendingAndTiming: v->BlendingAndTiming,
3840	BytePerPixY: v->BytePerPixelY,
3841	BytePerPixC: v->BytePerPixelC,
3842	BytePerPixDETY: v->BytePerPixelInDETY,
3843	BytePerPixDETC: v->BytePerPixelInDETC,
3844	HActive: v->HActive,
3845	HRatio: v->HRatio,
3846	HRatioChroma: v->HRatioChroma,
3847	DPPPerPlane: v->DPPPerPlane,
3848	swath_width_luma_ub: v->swath_width_luma_ub,
3849	swath_width_chroma_ub: v->swath_width_chroma_ub,
3850	SwathWidth: v->SwathWidthY,
3851	SwathWidthChroma: v->SwathWidthC,
3852	SwathHeightY: v->SwathHeightY,
3853	SwathHeightC: v->SwathHeightC,
3854	DETBufferSizeY: v->DETBufferSizeY,
3855	DETBufferSizeC: v->DETBufferSizeC,
3856	ViewportSizeSupportPerPlane: v->SingleDPPViewportSizeSupportPerPlane,
3857	ViewportSizeSupport: &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(Clock: v->MaxDispclk[i], VCOSpeed: v->DISPCLKDPPCLKVCOSpeed);
3862	v->MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(Clock: v->MaxDppclk[i], VCOSpeed: 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(a: v->RequiredDISPCLK[i][j], b: 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(a: v->RequiredDISPCLK[i][j], b: 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(a: v->RequiredDISPCLK[i][j], b: 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(a: v->PixelClockBackEnd[k] / 400.0, granularity: 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	LinkBitRate: dml_min(a: 600.0, b: v->PHYCLKPerState[i]) * 10,
4064	Lanes: 3,
4065	HTotal: v->HTotal[k],
4066	HActive: v->HActive[k],
4067	PixelClock: v->PixelClockBackEnd[k],
4068	DesiredBPP: v->ForcedOutputLinkBPP[k],
4069	DSCEnable: false,
4070	Output: v->Output[k],
4071	Format: v->OutputFormat[k],
4072	DSCInputBitPerComponent: v->DSCInputBitPerComponent[k],
4073	DSCSlices: v->NumberOfDSCSlices[k],
4074	AudioRate: v->AudioSampleRate[k],
4075	AudioLayout: v->AudioSampleLayout[k],
4076	ODMCombine: 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	LinkBitRate: (1.0 - v->Downspreading / 100.0) * 2700,
4096	Lanes: v->OutputLinkDPLanes[k],
4097	HTotal: v->HTotal[k],
4098	HActive: v->HActive[k],
4099	PixelClock: v->PixelClockBackEnd[k],
4100	DesiredBPP: v->ForcedOutputLinkBPP[k],
4101	DSCEnable: v->LinkDSCEnable,
4102	Output: v->Output[k],
4103	Format: v->OutputFormat[k],
4104	DSCInputBitPerComponent: v->DSCInputBitPerComponent[k],
4105	DSCSlices: v->NumberOfDSCSlices[k],
4106	AudioRate: v->AudioSampleRate[k],
4107	AudioLayout: v->AudioSampleLayout[k],
4108	ODMCombine: 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	LinkBitRate: (1.0 - v->Downspreading / 100.0) * 5400,
4116	Lanes: v->OutputLinkDPLanes[k],
4117	HTotal: v->HTotal[k],
4118	HActive: v->HActive[k],
4119	PixelClock: v->PixelClockBackEnd[k],
4120	DesiredBPP: v->ForcedOutputLinkBPP[k],
4121	DSCEnable: v->LinkDSCEnable,
4122	Output: v->Output[k],
4123	Format: v->OutputFormat[k],
4124	DSCInputBitPerComponent: v->DSCInputBitPerComponent[k],
4125	DSCSlices: v->NumberOfDSCSlices[k],
4126	AudioRate: v->AudioSampleRate[k],
4127	AudioLayout: v->AudioSampleLayout[k],
4128	ODMCombine: 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	LinkBitRate: (1.0 - v->Downspreading / 100.0) * 8100,
4136	Lanes: v->OutputLinkDPLanes[k],
4137	HTotal: v->HTotal[k],
4138	HActive: v->HActive[k],
4139	PixelClock: v->PixelClockBackEnd[k],
4140	DesiredBPP: v->ForcedOutputLinkBPP[k],
4141	DSCEnable: v->LinkDSCEnable,
4142	Output: v->Output[k],
4143	Format: v->OutputFormat[k],
4144	DSCInputBitPerComponent: v->DSCInputBitPerComponent[k],
4145	DSCSlices: v->NumberOfDSCSlices[k],
4146	AudioRate: v->AudioSampleRate[k],
4147	AudioLayout: v->AudioSampleLayout[k],
4148	ODMCombine: 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	LinkBitRate: (1.0 - v->Downspreading / 100.0) * 8100,
4158	Lanes: v->OutputLinkDPLanes[k],
4159	HTotal: v->HTotal[k],
4160	HActive: v->HActive[k],
4161	PixelClock: v->PixelClockBackEnd[k],
4162	DesiredBPP: v->ForcedOutputLinkBPP[k],
4163	DSCEnable: v->LinkDSCEnable,
4164	Output: v->Output[k],
4165	Format: v->OutputFormat[k],
4166	DSCInputBitPerComponent: v->DSCInputBitPerComponent[k],
4167	DSCSlices: v->NumberOfDSCSlices[k],
4168	AudioRate: v->AudioSampleRate[k],
4169	AudioLayout: v->AudioSampleLayout[k],
4170	ODMCombine: 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	bpc: v->DSCInputBitPerComponent[k],
4236	BPP: v->BPP,
4237	sliceWidth: dml_ceil(a: 1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1.0),
4238	numSlices: v->NumberOfDSCSlices[k],
4239	pixelFormat: v->OutputFormat[k],
4240	Output: v->Output[k]) + dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: 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	bpc: v->DSCInputBitPerComponent[k],
4245	BPP: v->BPP,
4246	sliceWidth: dml_ceil(a: 1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1.0),
4247	numSlices: v->NumberOfDSCSlices[k] / 2,
4248	pixelFormat: v->OutputFormat[k],
4249	Output: v->Output[k]) + dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: v->Output[k]);
4250	} else {
4251	v->DSCDelayPerState[i][k] = 4.0
4252	* (dscceComputeDelay(
4253	bpc: v->DSCInputBitPerComponent[k],
4254	BPP: v->BPP,
4255	sliceWidth: dml_ceil(a: 1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], granularity: 1.0),
4256	numSlices: v->NumberOfDSCSlices[k] / 4,
4257	pixelFormat: v->OutputFormat[k],
4258	Output: v->Output[k]) + dscComputeDelay(pixelFormat: v->OutputFormat[k], Output: 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 = start_state; 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	ForceSingleDPP: false,
4286	NumberOfActivePlanes: v->NumberOfActivePlanes,
4287	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
4288	MaximumSwathWidthLuma: v->MaximumSwathWidthLuma,
4289	MaximumSwathWidthChroma: v->MaximumSwathWidthChroma,
4290	SourceScan: v->SourceScan,
4291	SourcePixelFormat: v->SourcePixelFormat,
4292	SurfaceTiling: v->SurfaceTiling,
4293	ViewportWidth: v->ViewportWidth,
4294	ViewportHeight: v->ViewportHeight,
4295	SurfaceWidthY: v->SurfaceWidthY,
4296	SurfaceWidthC: v->SurfaceWidthC,
4297	SurfaceHeightY: v->SurfaceHeightY,
4298	SurfaceHeightC: v->SurfaceHeightC,
4299	Read256BytesBlockHeightY: v->Read256BlockHeightY,
4300	Read256BytesBlockHeightC: v->Read256BlockHeightC,
4301	Read256BytesBlockWidthY: v->Read256BlockWidthY,
4302	Read256BytesBlockWidthC: v->Read256BlockWidthC,
4303	ODMCombineEnabled: v->ODMCombineEnableThisState,
4304	BlendingAndTiming: v->BlendingAndTiming,
4305	BytePerPixY: v->BytePerPixelY,
4306	BytePerPixC: v->BytePerPixelC,
4307	BytePerPixDETY: v->BytePerPixelInDETY,
4308	BytePerPixDETC: v->BytePerPixelInDETC,
4309	HActive: v->HActive,
4310	HRatio: v->HRatio,
4311	HRatioChroma: v->HRatioChroma,
4312	DPPPerPlane: v->NoOfDPPThisState,
4313	swath_width_luma_ub: v->swath_width_luma_ub_this_state,
4314	swath_width_chroma_ub: v->swath_width_chroma_ub_this_state,
4315	SwathWidth: v->SwathWidthYThisState,
4316	SwathWidthChroma: v->SwathWidthCThisState,
4317	SwathHeightY: v->SwathHeightYThisState,
4318	SwathHeightC: v->SwathHeightCThisState,
4319	DETBufferSizeY: v->DETBufferSizeYThisState,
4320	DETBufferSizeC: v->DETBufferSizeCThisState,
4321	ViewportSizeSupportPerPlane: v->dummystring,
4322	ViewportSizeSupport: &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	DCCEnable: v->DCCEnable[k],
4376	BlockHeight256Bytes: v->Read256BlockHeightC[k],
4377	BlockWidth256Bytes: v->Read256BlockWidthY[k],
4378	SourcePixelFormat: v->SourcePixelFormat[k],
4379	SurfaceTiling: v->SurfaceTiling[k],
4380	BytePerPixel: v->BytePerPixelC[k],
4381	ScanDirection: v->SourceScan[k],
4382	SwathWidth: v->SwathWidthCThisState[k],
4383	ViewportHeight: v->ViewportHeightChroma[k],
4384	GPUVMEnable: v->GPUVMEnable,
4385	HostVMEnable: v->HostVMEnable,
4386	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
4387	GPUVMMinPageSize: v->GPUVMMinPageSize,
4388	HostVMMinPageSize: v->HostVMMinPageSize,
4389	PTEBufferSizeInRequests: v->PTEBufferSizeInRequestsForChroma,
4390	Pitch: v->PitchC[k],
4391	DCCMetaPitch: 0.0,
4392	MacroTileWidth: &v->MacroTileWidthC[k],
4393	MetaRowByte: &v->MetaRowBytesC,
4394	PixelPTEBytesPerRow: &v->DPTEBytesPerRowC,
4395	PTEBufferSizeNotExceeded: &v->PTEBufferSizeNotExceededC[i][j][k],
4396	dpte_row_width_ub: &v->dummyinteger7,
4397	dpte_row_height: &v->dpte_row_height_chroma[k],
4398	MetaRequestWidth: &v->dummyinteger28,
4399	MetaRequestHeight: &v->dummyinteger26,
4400	meta_row_width: &v->dummyinteger23,
4401	meta_row_height: &v->meta_row_height_chroma[k],
4402	vm_group_bytes: &v->dummyinteger8,
4403	dpte_group_bytes: &v->dummyinteger9,
4404	PixelPTEReqWidth: &v->dummyinteger19,
4405	PixelPTEReqHeight: &v->dummyinteger20,
4406	PTERequestSize: &v->dummyinteger17,
4407	DPDE0BytesFrame: &v->dummyinteger10,
4408	MetaPTEBytesFrame: &v->dummyinteger11);
4409
4410	v->PrefetchLinesC[i][j][k] = CalculatePrefetchSourceLines(
4411	mode_lib,
4412	VRatio: v->VRatioChroma[k],
4413	vtaps: v->VTAPsChroma[k],
4414	Interlace: v->Interlace[k],
4415	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
4416	SwathHeight: v->SwathHeightCThisState[k],
4417	ViewportYStart: v->ViewportYStartC[k],
4418	VInitPreFill: &v->PrefillC[k],
4419	MaxNumSwath: &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	DCCEnable: v->DCCEnable[k],
4432	BlockHeight256Bytes: v->Read256BlockHeightY[k],
4433	BlockWidth256Bytes: v->Read256BlockWidthY[k],
4434	SourcePixelFormat: v->SourcePixelFormat[k],
4435	SurfaceTiling: v->SurfaceTiling[k],
4436	BytePerPixel: v->BytePerPixelY[k],
4437	ScanDirection: v->SourceScan[k],
4438	SwathWidth: v->SwathWidthYThisState[k],
4439	ViewportHeight: v->ViewportHeight[k],
4440	GPUVMEnable: v->GPUVMEnable,
4441	HostVMEnable: v->HostVMEnable,
4442	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
4443	GPUVMMinPageSize: v->GPUVMMinPageSize,
4444	HostVMMinPageSize: v->HostVMMinPageSize,
4445	PTEBufferSizeInRequests: v->PTEBufferSizeInRequestsForLuma,
4446	Pitch: v->PitchY[k],
4447	DCCMetaPitch: v->DCCMetaPitchY[k],
4448	MacroTileWidth: &v->MacroTileWidthY[k],
4449	MetaRowByte: &v->MetaRowBytesY,
4450	PixelPTEBytesPerRow: &v->DPTEBytesPerRowY,
4451	PTEBufferSizeNotExceeded: &v->PTEBufferSizeNotExceededY[i][j][k],
4452	dpte_row_width_ub: v->dummyinteger4,
4453	dpte_row_height: &v->dpte_row_height[k],
4454	MetaRequestWidth: &v->dummyinteger29,
4455	MetaRequestHeight: &v->dummyinteger27,
4456	meta_row_width: &v->dummyinteger24,
4457	meta_row_height: &v->meta_row_height[k],
4458	vm_group_bytes: &v->dummyinteger25,
4459	dpte_group_bytes: &v->dpte_group_bytes[k],
4460	PixelPTEReqWidth: &v->dummyinteger21,
4461	PixelPTEReqHeight: &v->dummyinteger22,
4462	PTERequestSize: &v->dummyinteger18,
4463	DPDE0BytesFrame: &v->dummyinteger5,
4464	MetaPTEBytesFrame: &v->dummyinteger6);
4465	v->PrefetchLinesY[i][j][k] = CalculatePrefetchSourceLines(
4466	mode_lib,
4467	VRatio: v->VRatio[k],
4468	vtaps: v->vtaps[k],
4469	Interlace: v->Interlace[k],
4470	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
4471	SwathHeight: v->SwathHeightYThisState[k],
4472	ViewportYStart: v->ViewportYStartY[k],
4473	VInitPreFill: &v->PrefillY[k],
4474	MaxNumSwath: &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	GPUVMEnable: v->GPUVMEnable,
4481	SourcePixelFormat: v->SourcePixelFormat[k],
4482	VRatio: v->VRatio[k],
4483	VRatioChroma: v->VRatioChroma[k],
4484	DCCEnable: v->DCCEnable[k],
4485	LineTime: v->HTotal[k] / v->PixelClock[k],
4486	MetaRowByteLuma: v->MetaRowBytesY,
4487	MetaRowByteChroma: v->MetaRowBytesC,
4488	meta_row_height_luma: v->meta_row_height[k],
4489	meta_row_height_chroma: v->meta_row_height_chroma[k],
4490	PixelPTEBytesPerRowLuma: v->DPTEBytesPerRowY,
4491	PixelPTEBytesPerRowChroma: v->DPTEBytesPerRowC,
4492	dpte_row_height_luma: v->dpte_row_height[k],
4493	dpte_row_height_chroma: v->dpte_row_height_chroma[k],
4494	meta_row_bw: &v->meta_row_bandwidth[i][j][k],
4495	dpte_row_bw: &v->dpte_row_bandwidth[i][j][k]);
4496	}
4497	v->UrgLatency[i] = CalculateUrgentLatency(
4498	UrgentLatencyPixelDataOnly: v->UrgentLatencyPixelDataOnly,
4499	UrgentLatencyPixelMixedWithVMData: v->UrgentLatencyPixelMixedWithVMData,
4500	UrgentLatencyVMDataOnly: v->UrgentLatencyVMDataOnly,
4501	DoUrgentLatencyAdjustment: v->DoUrgentLatencyAdjustment,
4502	UrgentLatencyAdjustmentFabricClockComponent: v->UrgentLatencyAdjustmentFabricClockComponent,
4503	UrgentLatencyAdjustmentFabricClockReference: v->UrgentLatencyAdjustmentFabricClockReference,
4504	FabricClockSingle: v->FabricClockPerState[i]);
4505
4506	for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4507	CalculateUrgentBurstFactor(
4508	swath_width_luma_ub: v->swath_width_luma_ub_this_state[k],
4509	swath_width_chroma_ub: v->swath_width_chroma_ub_this_state[k],
4510	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
4511	SwathHeightY: v->SwathHeightYThisState[k],
4512	SwathHeightC: v->SwathHeightCThisState[k],
4513	LineTime: v->HTotal[k] / v->PixelClock[k],
4514	UrgentLatency: v->UrgLatency[i],
4515	CursorBufferSize: v->CursorBufferSize,
4516	CursorWidth: v->CursorWidth[k][0],
4517	CursorBPP: v->CursorBPP[k][0],
4518	VRatio: v->VRatio[k],
4519	VRatioC: v->VRatioChroma[k],
4520	BytePerPixelInDETY: v->BytePerPixelInDETY[k],
4521	BytePerPixelInDETC: v->BytePerPixelInDETC[k],
4522	DETBufferSizeY: v->DETBufferSizeYThisState[k],
4523	DETBufferSizeC: v->DETBufferSizeCThisState[k],
4524	UrgentBurstFactorCursor: &v->UrgentBurstFactorCursor[k],
4525	UrgentBurstFactorLuma: &v->UrgentBurstFactorLuma[k],
4526	UrgentBurstFactorChroma: &v->UrgentBurstFactorChroma[k],
4527	NotEnoughUrgentLatencyHiding: &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	NumberOfActivePlanes: v->NumberOfActivePlanes,
4557	BytePerPixelY: v->BytePerPixelY,
4558	BytePerPixelC: v->BytePerPixelC,
4559	VRatio: v->VRatio,
4560	VRatioChroma: v->VRatioChroma,
4561	SwathWidthY: v->SwathWidthYThisState,
4562	SwathWidthC: v->SwathWidthCThisState,
4563	DPPPerPlane: v->NoOfDPPThisState,
4564	HRatio: v->HRatio,
4565	HRatioChroma: v->HRatioChroma,
4566	PixelClock: v->PixelClock,
4567	PSCL_THROUGHPUT: v->PSCL_FACTOR,
4568	PSCL_THROUGHPUT_CHROMA: v->PSCL_FACTOR_CHROMA,
4569	DPPCLK: v->RequiredDPPCLKThisState,
4570	ReadBandwidthLuma: v->ReadBandwidthLuma,
4571	ReadBandwidthChroma: v->ReadBandwidthChroma,
4572	ReturnBusWidth: v->ReturnBusWidth,
4573	DCFCLKDeepSleep: &v->ProjectedDCFCLKDeepSleep[i][j]);
4574	}
4575	}
4576
4577	//Calculate Return BW
4578
4579	for (i = start_state; 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	WritebackPixelFormat: v->WritebackPixelFormat[k],
4587	WritebackHRatio: v->WritebackHRatio[k],
4588	WritebackVRatio: v->WritebackVRatio[k],
4589	WritebackVTaps: v->WritebackVTaps[k],
4590	WritebackDestinationWidth: v->WritebackDestinationWidth[k],
4591	WritebackDestinationHeight: v->WritebackDestinationHeight[k],
4592	WritebackSourceHeight: v->WritebackSourceHeight[k],
4593	HTotal: 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	a: v->WritebackDelayTime[k],
4601	b: v->WritebackLatency
4602	+ CalculateWriteBackDelay(
4603	WritebackPixelFormat: v->WritebackPixelFormat[m],
4604	WritebackHRatio: v->WritebackHRatio[m],
4605	WritebackVRatio: v->WritebackVRatio[m],
4606	WritebackVTaps: v->WritebackVTaps[m],
4607	WritebackDestinationWidth: v->WritebackDestinationWidth[m],
4608	WritebackDestinationHeight: v->WritebackDestinationHeight[m],
4609	WritebackSourceHeight: v->WritebackSourceHeight[m],
4610	HTotal: 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(a: 1.0, b: dml_ceil(a: 1.0 * v->WritebackDelayTime[k] / (v->HTotal[k] / v->PixelClock[k]), granularity: 1.0));
4626	v->MaxMaxVStartup[i][j] = dml_max(a: v->MaxMaxVStartup[i][j], b: v->MaximumVStartup[i][j][k]);
4627	}
4628	}
4629	}
4630
4631	ReorderingBytes = v->NumberOfChannels
4632	* dml_max3(
4633	a: v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
4634	b: v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
4635	c: v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
4636	v->FinalDRAMClockChangeLatency = (v->DRAMClockChangeLatencyOverride > 0 ? v->DRAMClockChangeLatencyOverride : v->DRAMClockChangeLatency);
4637
4638	for (i = start_state; 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 = start_state; 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 = start_state; i < mode_lib->soc.num_states; ++i) {
4660	for (j = 0; j <= 1; ++j) {
4661	v->IdealSDPPortBandwidthPerState[i][j] = dml_min3(
4662	a: v->ReturnBusWidth * v->DCFCLKState[i][j],
4663	b: v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth,
4664	c: 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 = start_state; 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 = start_state; i < mode_lib->soc.num_states; ++i) {
4696	for (j = 0; j <= 1; ++j) {
4697	v->MaxTotalVerticalActiveAvailableBandwidth[i][j] = dml_min(
4698	a: v->IdealSDPPortBandwidthPerState[i][j] * v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
4699	b: 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 = start_state; 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	RoundTripPingLatencyCycles: v->RoundTripPingLatencyCycles,
4738	ReorderingBytes,
4739	DCFCLK: v->DCFCLKState[i][j],
4740	TotalNumberOfActiveDPP: v->TotalNumberOfActiveDPP[i][j],
4741	PixelChunkSizeInKByte: v->PixelChunkSizeInKByte,
4742	TotalNumberOfDCCActiveDPP: v->TotalNumberOfDCCActiveDPP[i][j],
4743	MetaChunkSize: v->MetaChunkSize,
4744	ReturnBW: v->ReturnBWPerState[i][j],
4745	GPUVMEnable: v->GPUVMEnable,
4746	HostVMEnable: v->HostVMEnable,
4747	NumberOfActivePlanes: v->NumberOfActivePlanes,
4748	NumberOfDPP: v->NoOfDPPThisState,
4749	dpte_group_bytes: v->dpte_group_bytes,
4750	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4751	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4752	HostVMMinPageSize: v->HostVMMinPageSize,
4753	HostVMMaxNonCachedPageTableLevels: 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(PrefetchMode: v->PrefetchModePerState[i][j], DRAMClockChangeLatency: v->FinalDRAMClockChangeLatency, UrgentLatency: v->UrgLatency[i], SREnterPlusExitTime: 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	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4786	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4787	myPipe: &myPipe,
4788	DSCDelay: v->DSCDelayPerState[i][k],
4789	DPPCLKDelaySubtotalPlusCNVCFormater: v->DPPCLKDelaySubtotal + v->DPPCLKDelayCNVCFormater,
4790	DPPCLKDelaySCL: v->DPPCLKDelaySCL,
4791	DPPCLKDelaySCLLBOnly: v->DPPCLKDelaySCLLBOnly,
4792	DPPCLKDelayCNVCCursor: v->DPPCLKDelayCNVCCursor,
4793	DISPCLKDelaySubtotal: v->DISPCLKDelaySubtotal,
4794	DPP_RECOUT_WIDTH: v->SwathWidthYThisState[k] / v->HRatio[k],
4795	OutputFormat: v->OutputFormat[k],
4796	MaxInterDCNTileRepeaters: v->MaxInterDCNTileRepeaters,
4797	VStartup: dml_min(a: v->MaxVStartup, b: v->MaximumVStartup[i][j][k]),
4798	MaxVStartup: v->MaximumVStartup[i][j][k],
4799	GPUVMPageTableLevels: v->GPUVMMaxPageTableLevels,
4800	GPUVMEnable: v->GPUVMEnable,
4801	HostVMEnable: v->HostVMEnable,
4802	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
4803	HostVMMinPageSize: v->HostVMMinPageSize,
4804	DynamicMetadataEnable: v->DynamicMetadataEnable[k],
4805	DynamicMetadataVMEnabled: v->DynamicMetadataVMEnabled,
4806	DynamicMetadataLinesBeforeActiveRequired: v->DynamicMetadataLinesBeforeActiveRequired[k],
4807	DynamicMetadataTransmittedBytes: v->DynamicMetadataTransmittedBytes[k],
4808	UrgentLatency: v->UrgLatency[i],
4809	UrgentExtraLatency: v->ExtraLatency,
4810	TCalc: v->TimeCalc,
4811	PDEAndMetaPTEBytesFrame: v->PDEAndMetaPTEBytesPerFrame[i][j][k],
4812	MetaRowByte: v->MetaRowBytes[i][j][k],
4813	PixelPTEBytesPerRow: v->DPTEBytesPerRow[i][j][k],
4814	PrefetchSourceLinesY: v->PrefetchLinesY[i][j][k],
4815	SwathWidthY: v->SwathWidthYThisState[k],
4816	BytePerPixelY: v->BytePerPixelY[k],
4817	VInitPreFillY: v->PrefillY[k],
4818	MaxNumSwathY: v->MaxNumSwY[k],
4819	PrefetchSourceLinesC: v->PrefetchLinesC[i][j][k],
4820	SwathWidthC: v->SwathWidthCThisState[k],
4821	BytePerPixelC: v->BytePerPixelC[k],
4822	VInitPreFillC: v->PrefillC[k],
4823	MaxNumSwathC: v->MaxNumSwC[k],
4824	swath_width_luma_ub: v->swath_width_luma_ub_this_state[k],
4825	swath_width_chroma_ub: v->swath_width_chroma_ub_this_state[k],
4826	SwathHeightY: v->SwathHeightYThisState[k],
4827	SwathHeightC: v->SwathHeightCThisState[k],
4828	TWait: v->TWait,
4829	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
4830	DSTXAfterScaler: &v->DSTXAfterScaler[k],
4831	DSTYAfterScaler: &v->DSTYAfterScaler[k],
4832	DestinationLinesForPrefetch: &v->LineTimesForPrefetch[k],
4833	PrefetchBandwidth: &v->PrefetchBW[k],
4834	DestinationLinesToRequestVMInVBlank: &v->LinesForMetaPTE[k],
4835	DestinationLinesToRequestRowInVBlank: &v->LinesForMetaAndDPTERow[k],
4836	VRatioPrefetchY: &v->VRatioPreY[i][j][k],
4837	VRatioPrefetchC: &v->VRatioPreC[i][j][k],
4838	RequiredPrefetchPixDataBWLuma: &v->RequiredPrefetchPixelDataBWLuma[i][j][k],
4839	RequiredPrefetchPixDataBWChroma: &v->RequiredPrefetchPixelDataBWChroma[i][j][k],
4840	NotEnoughTimeForDynamicMetadata: &v->NoTimeForDynamicMetadata[i][j][k],
4841	Tno_bw: &v->Tno_bw[k],
4842	prefetch_vmrow_bw: &v->prefetch_vmrow_bw[k],
4843	Tdmdl_vm: &v->Tdmdl_vm[k],
4844	Tdmdl: &v->Tdmdl[k],
4845	VUpdateOffsetPix: &v->VUpdateOffsetPix[k],
4846	VUpdateWidthPix: &v->VUpdateWidthPix[k],
4847	VReadyOffsetPix: &v->VReadyOffsetPix[k]);
4848	}
4849
4850	for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4851	CalculateUrgentBurstFactor(
4852	swath_width_luma_ub: v->swath_width_luma_ub_this_state[k],
4853	swath_width_chroma_ub: v->swath_width_chroma_ub_this_state[k],
4854	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
4855	SwathHeightY: v->SwathHeightYThisState[k],
4856	SwathHeightC: v->SwathHeightCThisState[k],
4857	LineTime: v->HTotal[k] / v->PixelClock[k],
4858	UrgentLatency: v->UrgLatency[i],
4859	CursorBufferSize: v->CursorBufferSize,
4860	CursorWidth: v->CursorWidth[k][0],
4861	CursorBPP: v->CursorBPP[k][0],
4862	VRatio: v->VRatioPreY[i][j][k],
4863	VRatioC: v->VRatioPreC[i][j][k],
4864	BytePerPixelInDETY: v->BytePerPixelInDETY[k],
4865	BytePerPixelInDETC: v->BytePerPixelInDETC[k],
4866	DETBufferSizeY: v->DETBufferSizeYThisState[k],
4867	DETBufferSizeC: v->DETBufferSizeCThisState[k],
4868	UrgentBurstFactorCursor: &v->UrgentBurstFactorCursorPre[k],
4869	UrgentBurstFactorLuma: &v->UrgentBurstFactorLumaPre[k],
4870	UrgentBurstFactorChroma: &v->UrgentBurstFactorChromaPre[k],
4871	NotEnoughUrgentLatencyHiding: &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	a: v->VActivePixelBandwidth[i][j][k],
4882	b: 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	c: v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
4885	d: 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	a: v->VActivePixelBandwidth[i][j][k] + v->VActiveCursorBandwidth[i][j][k],
4937	b: 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	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4953	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4954	UrgentExtraLatency: v->ExtraLatency,
4955	UrgentLatency: v->UrgLatency[i],
4956	GPUVMMaxPageTableLevels: v->GPUVMMaxPageTableLevels,
4957	HostVMEnable: v->HostVMEnable,
4958	HostVMMaxNonCachedPageTableLevels: v->HostVMMaxNonCachedPageTableLevels,
4959	GPUVMEnable: v->GPUVMEnable,
4960	HostVMMinPageSize: v->HostVMMinPageSize,
4961	PDEAndMetaPTEBytesPerFrame: v->PDEAndMetaPTEBytesPerFrame[i][j][k],
4962	MetaRowBytes: v->MetaRowBytes[i][j][k],
4963	DPTEBytesPerRow: v->DPTEBytesPerRow[i][j][k],
4964	BandwidthAvailableForImmediateFlip: v->BandwidthAvailableForImmediateFlip,
4965	TotImmediateFlipBytes: v->TotImmediateFlipBytes,
4966	SourcePixelFormat: v->SourcePixelFormat[k],
4967	LineTime: v->HTotal[k] / v->PixelClock[k],
4968	VRatio: v->VRatio[k],
4969	VRatioChroma: v->VRatioChroma[k],
4970	Tno_bw: v->Tno_bw[k],
4971	DCCEnable: v->DCCEnable[k],
4972	dpte_row_height: v->dpte_row_height[k],
4973	meta_row_height: v->meta_row_height[k],
4974	dpte_row_height_chroma: v->dpte_row_height_chroma[k],
4975	meta_row_height_chroma: v->meta_row_height_chroma[k],
4976	DestinationLinesToRequestVMInImmediateFlip: &v->DestinationLinesToRequestVMInImmediateFlip[k],
4977	DestinationLinesToRequestRowInImmediateFlip: &v->DestinationLinesToRequestRowInImmediateFlip[k],
4978	final_flip_bw: &v->final_flip_bw[k],
4979	ImmediateFlipSupportedForPipe: &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	a: v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
4986	b: v->NoOfDPP[i][j][k] * v->final_flip_bw[k] + v->VActivePixelBandwidth[i][j][k]
4987	+ v->VActiveCursorBandwidth[i][j][k],
4988	c: 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	PrefetchMode: v->PrefetchModePerState[i][j],
5022	NumberOfActivePlanes: v->NumberOfActivePlanes,
5023	MaxLineBufferLines: v->MaxLineBufferLines,
5024	LineBufferSize: v->LineBufferSize,
5025	DPPOutputBufferPixels: v->DPPOutputBufferPixels,
5026	DETBufferSizeInKByte: v->DETBufferSizeInKByte[0],
5027	WritebackInterfaceBufferSize: v->WritebackInterfaceBufferSize,
5028	DCFCLK: v->DCFCLKState[i][j],
5029	ReturnBW: v->ReturnBWPerState[i][j],
5030	GPUVMEnable: v->GPUVMEnable,
5031	dpte_group_bytes: v->dpte_group_bytes,
5032	MetaChunkSize: v->MetaChunkSize,
5033	UrgentLatency: v->UrgLatency[i],
5034	ExtraLatency: v->ExtraLatency,
5035	WritebackLatency: v->WritebackLatency,
5036	WritebackChunkSize: v->WritebackChunkSize,
5037	SOCCLK: v->SOCCLKPerState[i],
5038	DRAMClockChangeLatency: v->FinalDRAMClockChangeLatency,
5039	SRExitTime: v->SRExitTime,
5040	SREnterPlusExitTime: v->SREnterPlusExitTime,
5041	DCFCLKDeepSleep: v->ProjectedDCFCLKDeepSleep[i][j],
5042	DPPPerPlane: v->NoOfDPPThisState,
5043	DCCEnable: v->DCCEnable,
5044	DPPCLK: v->RequiredDPPCLKThisState,
5045	DETBufferSizeY: v->DETBufferSizeYThisState,
5046	DETBufferSizeC: v->DETBufferSizeCThisState,
5047	SwathHeightY: v->SwathHeightYThisState,
5048	SwathHeightC: v->SwathHeightCThisState,
5049	LBBitPerPixel: v->LBBitPerPixel,
5050	SwathWidthY: v->SwathWidthYThisState,
5051	SwathWidthC: v->SwathWidthCThisState,
5052	HRatio: v->HRatio,
5053	HRatioChroma: v->HRatioChroma,
5054	vtaps: v->vtaps,
5055	VTAPsChroma: v->VTAPsChroma,
5056	VRatio: v->VRatio,
5057	VRatioChroma: v->VRatioChroma,
5058	HTotal: v->HTotal,
5059	PixelClock: v->PixelClock,
5060	BlendingAndTiming: v->BlendingAndTiming,
5061	BytePerPixelDETY: v->BytePerPixelInDETY,
5062	BytePerPixelDETC: v->BytePerPixelInDETC,
5063	DSTXAfterScaler: v->DSTXAfterScaler,
5064	DSTYAfterScaler: v->DSTYAfterScaler,
5065	WritebackEnable: v->WritebackEnable,
5066	WritebackPixelFormat: v->WritebackPixelFormat,
5067	WritebackDestinationWidth: v->WritebackDestinationWidth,
5068	WritebackDestinationHeight: v->WritebackDestinationHeight,
5069	WritebackSourceHeight: v->WritebackSourceHeight,
5070	DRAMClockChangeSupport: &v->DRAMClockChangeSupport[i][j],
5071	UrgentWatermark: &v->UrgentWatermark,
5072	WritebackUrgentWatermark: &v->WritebackUrgentWatermark,
5073	DRAMClockChangeWatermark: &v->DRAMClockChangeWatermark,
5074	WritebackDRAMClockChangeWatermark: &v->WritebackDRAMClockChangeWatermark,
5075	StutterExitWatermark: &v->StutterExitWatermark,
5076	StutterEnterPlusExitWatermark: &v->StutterEnterPlusExitWatermark,
5077	MinActiveDRAMClockChangeLatencySupported: &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(a: dml_max(a: v->PitchY[k], b: v->SurfaceWidthY[k]), granularity: v->MacroTileWidthY[k]);
5108	if (v->DCCEnable[k] == true) {
5109	v->AlignedDCCMetaPitchY[k] = dml_ceil(a: dml_max(a: v->DCCMetaPitchY[k], b: v->SurfaceWidthY[k]), granularity: 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(a: dml_max(a: v->PitchC[k], b: v->SurfaceWidthC[k]), granularity: v->MacroTileWidthC[k]);
5116	if (v->DCCEnable[k] == true) {
5117	v->AlignedDCCMetaPitchC[k] = dml_ceil(a: dml_max(a: v->DCCMetaPitchC[k], b: v->SurfaceWidthC[k]), granularity: 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
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(a: (double) MaxLineBufferLines, b: dml_floor(a: LineBufferSize / LBBitPerPixel[k] / (SwathWidthY[k] / dml_max(a: HRatio[k], b: 1.0)), granularity: 1)) - (vtaps[k] - 1);
5304
5305	mode_lib->vba.LBLatencyHidingSourceLinesC = dml_min(a: (double) MaxLineBufferLines, b: dml_floor(a: LineBufferSize / LBBitPerPixel[k] / (SwathWidthC[k] / dml_max(a: HRatioChroma[k], b: 1.0)), granularity: 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(a: LinesInDETY[k], granularity: 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(a: LinesInDETC, granularity: 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(a: ActiveDRAMClockChangeLatencyMarginY, b: 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(a: mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], b: 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(a: SREnterPlusExitTime + ExtraLatency + 10 / DCFCLKDeepSleep, b: TimeToFinishSwathTransferStutterCriticalPlane);
5405
5406	}
5407
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(a: 1.1 * SwathWidthY[k] * BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma, b: 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(a: mode_lib->vba.DCFCLKDeepSleepPerPlane[k], b: 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(a: 8.0, b: ReadBandwidth / ReturnBusWidth);
5466
5467	for (k = 0; k < NumberOfActivePlanes; ++k) {
5468	*DCFCLKDeepSleep = dml_max(a: *DCFCLKDeepSleep, b: mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
5469	}
5470	}
5471
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(a: dml_log2(x: CursorBufferSize * 1024.0 / (CursorWidth * CursorBPP / 8.0)), granularity: 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(a: LinesInDETLuma, granularity: 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(a: LinesInDETChroma, granularity: 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
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(a: CursorWidth[k][0] * CursorBPP[k][0] / 256 / 8, granularity: 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
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(a: 1.0 * dpte_row_width_luma_ub[k] / dpte_group_width_luma, granularity: 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(a: 1.0 * dpte_row_width_chroma_ub[k] / dpte_group_width_chroma, granularity: 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
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(a: (double) (dpde0_bytes_per_frame_ub_l[k])
5866	/ (double) (vm_group_bytes[k]), granularity: 1) + dml_ceil(a: (double) (dpde0_bytes_per_frame_ub_c[k])
5867	/ (double) (vm_group_bytes[k]), granularity: 1);
5868	} else {
5869	num_group_per_lower_vm_stage = dml_ceil(a: (double) (dpde0_bytes_per_frame_ub_l[k])
5870	/ (double) (vm_group_bytes[k]), granularity: 1);
5871	}
5872	} else {
5873	if (GPUVMMaxPageTableLevels == 1) {
5874	if (BytePerPixelC[k] > 0) {
5875	num_group_per_lower_vm_stage = dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_l[k])
5876	/ (double) (vm_group_bytes[k]), granularity: 1) + dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_c[k])
5877	/ (double) (vm_group_bytes[k]), granularity: 1);
5878	} else {
5879	num_group_per_lower_vm_stage = dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_l[k])
5880	/ (double) (vm_group_bytes[k]), granularity: 1);
5881	}
5882	} else {
5883	if (BytePerPixelC[k] > 0) {
5884	num_group_per_lower_vm_stage = 2 + dml_ceil(a: (double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), granularity: 1)
5885	+ dml_ceil(a: (double) (dpde0_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), granularity: 1)
5886	+ dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), granularity: 1)
5887	+ dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), granularity: 1);
5888	} else {
5889	num_group_per_lower_vm_stage = 1 + dml_ceil(a: (double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), granularity: 1)
5890	+ dml_ceil(a: (double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), granularity: 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
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(a: LinesInDETY[k], granularity: 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(a: DCCRateLuma[k], b: 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(a: DCCRateChroma[k], b: 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(a: StutterPeriod * TotalDataReadBandwidth, b: ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate);
6061	StutterBurstTime = PartOfBurstThatFitsInROB / AverageDCCCompressionRate / ReturnBW + (StutterPeriod * TotalDataReadBandwidth
6062	- PartOfBurstThatFitsInROB) / (DCFCLK * 64) + StutterPeriod * TotalRowReadBandwidth / ReturnBW;
6063	StutterBurstTime = dml_max(a: StutterBurstTime, b: 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(a: SmallestVBlank, b: VBlankTime);
6091	}
6092
6093	*StutterEfficiency = (*StutterEfficiencyNotIncludingVBlank / 100.0 * (FrameTimeForMinFullDETBufferingTime - SmallestVBlank) + SmallestVBlank) / FrameTimeForMinFullDETBufferingTime * 100;
6094
6095	if (StutterPeriodOut)
6096	*StutterPeriodOut = StutterPeriod;
6097	}
6098
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	SwathWidthSingleDPPY: SwathWidthSingleDPP,
6176	SwathWidthSingleDPPC: SwathWidthSingleDPPChroma,
6177	SwathWidthY: SwathWidth,
6178	SwathWidthC: 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(a: (double) RoundedUpMaxSwathSizeBytesY, granularity: 256);
6228	RoundedUpMinSwathSizeBytesY = dml_ceil(a: (double) RoundedUpMinSwathSizeBytesY, granularity: 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(a: RoundedUpMaxSwathSizeBytesC, granularity: 256);
6236	RoundedUpMinSwathSizeBytesC = dml_ceil(a: RoundedUpMinSwathSizeBytesC, granularity: 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
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(a: SwathWidthSingleDPPY[k], b: dml_round(a: HActive[k] / 4.0 * HRatio[k]));
6345	} else if (MainPlaneODMCombine == dm_odm_combine_mode_2to1) {
6346	SwathWidthY[k] = dml_min(a: SwathWidthSingleDPPY[k], b: dml_round(a: 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(a: SurfaceWidthY[k], granularity: Read256BytesBlockWidthY[k]);
6367	surface_height_ub_l = dml_ceil(a: SurfaceHeightY[k], granularity: 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(a: surface_width_ub_l, b: (long) dml_ceil(a: SwathWidthY[k] - 1,
6373	granularity: Read256BytesBlockWidthY[k]) + Read256BytesBlockWidthY[k]);
6374	if (BytePerPixC[k] > 0) {
6375	surface_width_ub_c = dml_ceil(a: SurfaceWidthC[k], granularity: Read256BytesBlockWidthC[k]);
6376	swath_width_chroma_ub[k] = dml_min(a: surface_width_ub_c, b: (long) dml_ceil(a: SwathWidthC[k] - 1,
6377	granularity: 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(a: surface_height_ub_l, b: (long) dml_ceil(a: SwathWidthY[k] - 1,
6385	granularity: Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]);
6386	if (BytePerPixC[k] > 0) {
6387	surface_height_ub_c = dml_ceil(a: SurfaceHeightC[k], granularity: Read256BytesBlockHeightC[k]);
6388	swath_width_chroma_ub[k] = dml_min(a: surface_height_ub_c, b: (long) dml_ceil(a: SwathWidthC[k] - 1,
6389	granularity: Read256BytesBlockHeightC[k]) + Read256BytesBlockHeightC[k]);
6390	} else {
6391	swath_width_chroma_ub[k] = 0;
6392	}
6393	}
6394	}
6395	}
6396
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
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(a: 0, b: (int) HostVMMaxNonCachedPageTableLevels - 1);
6463	} else {
6464	HostVMDynamicLevels = dml_max(a: 0, b: (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
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(a: UrgentLatencyPixelDataOnly, b: UrgentLatencyPixelMixedWithVMData, c: UrgentLatencyVMDataOnly);
6494	if (DoUrgentLatencyAdjustment == true) {
6495	ret = ret + UrgentLatencyAdjustmentFabricClockComponent * (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
6496	}
6497	return ret;
6498	}
6499
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(PrefetchMode: MaxPrefetchMode, DRAMClockChangeLatency: v->FinalDRAMClockChangeLatency, UrgentLatency: v->UrgLatency[i], SREnterPlusExitTime: 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(a: v->ProjectedDCFCLKDeepSleep[i][j],
6546	b: (NonDPTEBandwidth + v->TotalDPTERowBandwidth[i][j]) / v->ReturnBusWidth / (v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100),
6547	c: (NonDPTEBandwidth + DPTEBandwidth / PTEEfficiency) / NormalEfficiency / v->ReturnBusWidth);
6548
6549	ExtraLatencyBytes = CalculateExtraLatencyBytes(ReorderingBytes, TotalNumberOfActiveDPP: v->TotalNumberOfActiveDPP[i][j], PixelChunkSizeInKByte: v->PixelChunkSizeInKByte, TotalNumberOfDCCActiveDPP: v->TotalNumberOfDCCActiveDPP[i][j],
6550	MetaChunkSize: v->MetaChunkSize, GPUVMEnable: v->GPUVMEnable, HostVMEnable: v->HostVMEnable, NumberOfActivePlanes: v->NumberOfActivePlanes, NumberOfDPP: NoOfDPPState, dpte_group_bytes: v->dpte_group_bytes,
6551	PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData, PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly: v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6552	HostVMMinPageSize: v->HostVMMinPageSize, HostVMMaxNonCachedPageTableLevels: 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(a: v->PrefetchLinesY[i][j][k], b: 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(a: 1.0, b: ExpectedVRatioPrefetch) * dml_max(a: 1.0, b: 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	MaxInterDCNTileRepeaters: v->MaxInterDCNTileRepeaters,
6592	DPPCLK: v->RequiredDPPCLK[i][j][k],
6593	DISPCLK: v->RequiredDISPCLK[i][j],
6594	DCFClkDeepSleep: v->ProjectedDCFCLKDeepSleep[i][j],
6595	PixelClock: v->PixelClock[k],
6596	HTotal: v->HTotal[k],
6597	VBlank: v->VTotal[k] - v->VActive[k],
6598	DynamicMetadataTransmittedBytes: v->DynamicMetadataTransmittedBytes[k],
6599	DynamicMetadataLinesBeforeActiveRequired: v->DynamicMetadataLinesBeforeActiveRequired[k],
6600	InterlaceEnable: v->Interlace[k],
6601	ProgressiveToInterlaceUnitInOPP: v->ProgressiveToInterlaceUnitInOPP,
6602	Tsetup: &TsetupPipe,
6603	Tdmbf: &TdmbfPipe,
6604	Tdmec: &TdmecPipe,
6605	Tdmsks: &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(a: DCFCLKRequiredForPeakBandwidthPerPlane[k],
6610	b: 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(a: DCFCLKRequiredForPeakBandwidth, b: 2 * ExtraLatencyCycles
6629	/ (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0 - PrefetchPixelLinesTime[k] / 4),
6630	c: (2 * ExtraLatencyCycles + PixelDCFCLKCyclesRequiredInPrefetch[k]) / (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0));
6631	}
6632	}
6633	v->DCFCLKState[i][j] = dml_min(a: v->DCFCLKPerState[i], b: 1.05 * (1 + mode_lib->vba.PercentMarginOverMinimumRequiredDCFCLK / 100)
6634	* dml_max(a: DCFCLKRequiredForAverageBandwidth, b: DCFCLKRequiredForPeakBandwidth));
6635	}
6636	}
6637	}
6638
6639