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