/usr/src/sys/dev/pci/drm/amd/display/dc/dml/dcn30/display_mode_vba

Bug Summary

File:	dev/pci/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c
Warning:	line 1289, column 3 Value stored to 'TimeForFetchingRowInVBlank' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name display_mode_vba_30.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -target-feature +sse -target-feature +sse2 -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c

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