2 * Copyright 2020 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
26 #ifdef CONFIG_DRM_AMD_DC_DCN3_0
29 #include "../display_mode_lib.h"
30 #include "display_mode_vba_30.h"
31 #include "../dml_inline_defs.h"
36 * This file is gcc-parsable HW gospel, coming straight from HW engineers.
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.
48 double DCFCLKDeepSleep;
49 unsigned int DPPPerPlane;
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;
60 unsigned int DCCEnable;
61 bool ODMCombineEnabled;
65 #define BPP_BLENDED_PIPE 0xffffffff
67 static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib);
68 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
69 struct display_mode_lib *mode_lib);
70 static unsigned int dscceComputeDelay(
73 unsigned int sliceWidth,
74 unsigned int numSlices,
75 enum output_format_class pixelFormat,
76 enum output_encoder_class Output);
77 static unsigned int dscComputeDelay(
78 enum output_format_class pixelFormat,
79 enum output_encoder_class Output);
80 // Super monster function with some 45 argument
81 static bool CalculatePrefetchSchedule(
82 struct display_mode_lib *mode_lib,
83 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
84 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
86 unsigned int DSCDelay,
87 double DPPCLKDelaySubtotalPlusCNVCFormater,
88 double DPPCLKDelaySCL,
89 double DPPCLKDelaySCLLBOnly,
90 double DPPCLKDelayCNVCCursor,
91 double DISPCLKDelaySubtotal,
92 unsigned int DPP_RECOUT_WIDTH,
93 enum output_format_class OutputFormat,
94 unsigned int MaxInterDCNTileRepeaters,
95 unsigned int VStartup,
96 unsigned int MaxVStartup,
97 unsigned int GPUVMPageTableLevels,
100 unsigned int HostVMMaxNonCachedPageTableLevels,
101 double HostVMMinPageSize,
102 bool DynamicMetadataEnable,
103 bool DynamicMetadataVMEnabled,
104 int DynamicMetadataLinesBeforeActiveRequired,
105 unsigned int DynamicMetadataTransmittedBytes,
106 double UrgentLatency,
107 double UrgentExtraLatency,
109 unsigned int PDEAndMetaPTEBytesFrame,
110 unsigned int MetaRowByte,
111 unsigned int PixelPTEBytesPerRow,
112 double PrefetchSourceLinesY,
113 unsigned int SwathWidthY,
115 double VInitPreFillY,
116 unsigned int MaxNumSwathY,
117 double PrefetchSourceLinesC,
118 unsigned int SwathWidthC,
120 double VInitPreFillC,
121 unsigned int MaxNumSwathC,
122 long swath_width_luma_ub,
123 long swath_width_chroma_ub,
124 unsigned int SwathHeightY,
125 unsigned int SwathHeightC,
127 bool ProgressiveToInterlaceUnitInOPP,
128 double *DSTXAfterScaler,
129 double *DSTYAfterScaler,
130 double *DestinationLinesForPrefetch,
131 double *PrefetchBandwidth,
132 double *DestinationLinesToRequestVMInVBlank,
133 double *DestinationLinesToRequestRowInVBlank,
134 double *VRatioPrefetchY,
135 double *VRatioPrefetchC,
136 double *RequiredPrefetchPixDataBWLuma,
137 double *RequiredPrefetchPixDataBWChroma,
138 bool *NotEnoughTimeForDynamicMetadata,
140 double *prefetch_vmrow_bw,
143 unsigned int *VUpdateOffsetPix,
144 double *VUpdateWidthPix,
145 double *VReadyOffsetPix);
146 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed);
147 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed);
148 static void CalculateDCCConfiguration(
150 bool DCCProgrammingAssumesScanDirectionUnknown,
151 enum source_format_class SourcePixelFormat,
152 unsigned int ViewportWidthLuma,
153 unsigned int ViewportWidthChroma,
154 unsigned int ViewportHeightLuma,
155 unsigned int ViewportHeightChroma,
156 double DETBufferSize,
157 unsigned int RequestHeight256ByteLuma,
158 unsigned int RequestHeight256ByteChroma,
159 enum dm_swizzle_mode TilingFormat,
160 unsigned int BytePerPixelY,
161 unsigned int BytePerPixelC,
162 double BytePerPixelDETY,
163 double BytePerPixelDETC,
164 enum scan_direction_class ScanOrientation,
165 unsigned int *MaxUncompressedBlockLuma,
166 unsigned int *MaxUncompressedBlockChroma,
167 unsigned int *MaxCompressedBlockLuma,
168 unsigned int *MaxCompressedBlockChroma,
169 unsigned int *IndependentBlockLuma,
170 unsigned int *IndependentBlockChroma);
171 static double CalculatePrefetchSourceLines(
172 struct display_mode_lib *mode_lib,
176 bool ProgressiveToInterlaceUnitInOPP,
177 unsigned int SwathHeight,
178 unsigned int ViewportYStart,
179 double *VInitPreFill,
180 unsigned int *MaxNumSwath);
181 static unsigned int CalculateVMAndRowBytes(
182 struct display_mode_lib *mode_lib,
184 unsigned int BlockHeight256Bytes,
185 unsigned int BlockWidth256Bytes,
186 enum source_format_class SourcePixelFormat,
187 unsigned int SurfaceTiling,
188 unsigned int BytePerPixel,
189 enum scan_direction_class ScanDirection,
190 unsigned int SwathWidth,
191 unsigned int ViewportHeight,
194 unsigned int HostVMMaxNonCachedPageTableLevels,
195 unsigned int GPUVMMinPageSize,
196 unsigned int HostVMMinPageSize,
197 unsigned int PTEBufferSizeInRequests,
199 unsigned int DCCMetaPitch,
200 unsigned int *MacroTileWidth,
201 unsigned int *MetaRowByte,
202 unsigned int *PixelPTEBytesPerRow,
203 bool *PTEBufferSizeNotExceeded,
204 unsigned int *dpte_row_width_ub,
205 unsigned int *dpte_row_height,
206 unsigned int *MetaRequestWidth,
207 unsigned int *MetaRequestHeight,
208 unsigned int *meta_row_width,
209 unsigned int *meta_row_height,
210 unsigned int *vm_group_bytes,
211 unsigned int *dpte_group_bytes,
212 unsigned int *PixelPTEReqWidth,
213 unsigned int *PixelPTEReqHeight,
214 unsigned int *PTERequestSize,
215 unsigned int *DPDE0BytesFrame,
216 unsigned int *MetaPTEBytesFrame);
217 static double CalculateTWait(
218 unsigned int PrefetchMode,
219 double DRAMClockChangeLatency,
220 double UrgentLatency,
221 double SREnterPlusExitTime);
222 static void CalculateRowBandwidth(
224 enum source_format_class SourcePixelFormat,
229 unsigned int MetaRowByteLuma,
230 unsigned int MetaRowByteChroma,
231 unsigned int meta_row_height_luma,
232 unsigned int meta_row_height_chroma,
233 unsigned int PixelPTEBytesPerRowLuma,
234 unsigned int PixelPTEBytesPerRowChroma,
235 unsigned int dpte_row_height_luma,
236 unsigned int dpte_row_height_chroma,
238 double *dpte_row_bw);
239 static void CalculateFlipSchedule(
240 struct display_mode_lib *mode_lib,
241 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
242 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
243 double UrgentExtraLatency,
244 double UrgentLatency,
245 unsigned int GPUVMMaxPageTableLevels,
247 unsigned int HostVMMaxNonCachedPageTableLevels,
249 double HostVMMinPageSize,
250 double PDEAndMetaPTEBytesPerFrame,
252 double DPTEBytesPerRow,
253 double BandwidthAvailableForImmediateFlip,
254 unsigned int TotImmediateFlipBytes,
255 enum source_format_class SourcePixelFormat,
261 unsigned int dpte_row_height,
262 unsigned int meta_row_height,
263 unsigned int dpte_row_height_chroma,
264 unsigned int meta_row_height_chroma,
265 double *DestinationLinesToRequestVMInImmediateFlip,
266 double *DestinationLinesToRequestRowInImmediateFlip,
267 double *final_flip_bw,
268 bool *ImmediateFlipSupportedForPipe);
269 static double CalculateWriteBackDelay(
270 enum source_format_class WritebackPixelFormat,
271 double WritebackHRatio,
272 double WritebackVRatio,
273 unsigned int WritebackVTaps,
274 long WritebackDestinationWidth,
275 long WritebackDestinationHeight,
276 long WritebackSourceHeight,
277 unsigned int HTotal);
278 static void CalculateDynamicMetadataParameters(
279 int MaxInterDCNTileRepeaters,
282 double DCFClkDeepSleep,
286 long DynamicMetadataTransmittedBytes,
287 long DynamicMetadataLinesBeforeActiveRequired,
289 bool ProgressiveToInterlaceUnitInOPP,
294 static void CalculateWatermarksAndDRAMSpeedChangeSupport(
295 struct display_mode_lib *mode_lib,
296 unsigned int PrefetchMode,
297 unsigned int NumberOfActivePlanes,
298 unsigned int MaxLineBufferLines,
299 unsigned int LineBufferSize,
300 unsigned int DPPOutputBufferPixels,
301 double DETBufferSizeInKByte,
302 unsigned int WritebackInterfaceBufferSize,
306 unsigned int dpte_group_bytes[],
307 unsigned int MetaChunkSize,
308 double UrgentLatency,
310 double WritebackLatency,
311 double WritebackChunkSize,
313 double DRAMClockChangeLatency,
315 double SREnterPlusExitTime,
316 double DCFCLKDeepSleep,
317 unsigned int DPPPerPlane[],
320 double DETBufferSizeY[],
321 double DETBufferSizeC[],
322 unsigned int SwathHeightY[],
323 unsigned int SwathHeightC[],
324 unsigned int LBBitPerPixel[],
325 double SwathWidthY[],
326 double SwathWidthC[],
328 double HRatioChroma[],
329 unsigned int vtaps[],
330 unsigned int VTAPsChroma[],
332 double VRatioChroma[],
333 unsigned int HTotal[],
335 unsigned int BlendingAndTiming[],
336 double BytePerPixelDETY[],
337 double BytePerPixelDETC[],
338 double DSTXAfterScaler[],
339 double DSTYAfterScaler[],
340 bool WritebackEnable[],
341 enum source_format_class WritebackPixelFormat[],
342 double WritebackDestinationWidth[],
343 double WritebackDestinationHeight[],
344 double WritebackSourceHeight[],
345 enum clock_change_support *DRAMClockChangeSupport,
346 double *UrgentWatermark,
347 double *WritebackUrgentWatermark,
348 double *DRAMClockChangeWatermark,
349 double *WritebackDRAMClockChangeWatermark,
350 double *StutterExitWatermark,
351 double *StutterEnterPlusExitWatermark,
352 double *MinActiveDRAMClockChangeLatencySupported);
353 static void CalculateDCFCLKDeepSleep(
354 struct display_mode_lib *mode_lib,
355 unsigned int NumberOfActivePlanes,
359 double VRatioChroma[],
360 double SwathWidthY[],
361 double SwathWidthC[],
362 unsigned int DPPPerPlane[],
364 double HRatioChroma[],
366 double PSCL_THROUGHPUT[],
367 double PSCL_THROUGHPUT_CHROMA[],
369 double ReadBandwidthLuma[],
370 double ReadBandwidthChroma[],
372 double *DCFCLKDeepSleep);
373 static void CalculateUrgentBurstFactor(
374 long swath_width_luma_ub,
375 long swath_width_chroma_ub,
376 unsigned int DETBufferSizeInKByte,
377 unsigned int SwathHeightY,
378 unsigned int SwathHeightC,
380 double UrgentLatency,
381 double CursorBufferSize,
382 unsigned int CursorWidth,
383 unsigned int CursorBPP,
386 double BytePerPixelInDETY,
387 double BytePerPixelInDETC,
388 double DETBufferSizeY,
389 double DETBufferSizeC,
390 double *UrgentBurstFactorCursor,
391 double *UrgentBurstFactorLuma,
392 double *UrgentBurstFactorChroma,
393 bool *NotEnoughUrgentLatencyHiding);
395 static void UseMinimumDCFCLK(
396 struct display_mode_lib *mode_lib,
397 int MaxInterDCNTileRepeaters,
399 double FinalDRAMClockChangeLatency,
400 double SREnterPlusExitTime,
402 int RoundTripPingLatencyCycles,
404 int PixelChunkSizeInKByte,
407 int GPUVMMaxPageTableLevels,
409 int NumberOfActivePlanes,
410 double HostVMMinPageSize,
411 int HostVMMaxNonCachedPageTableLevels,
412 bool DynamicMetadataVMEnabled,
413 enum immediate_flip_requirement ImmediateFlipRequirement,
414 bool ProgressiveToInterlaceUnitInOPP,
415 double MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
416 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
417 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
418 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly,
421 int DynamicMetadataTransmittedBytes[],
422 int DynamicMetadataLinesBeforeActiveRequired[],
424 double RequiredDPPCLK[][2][DC__NUM_DPP__MAX],
425 double RequiredDISPCLK[][2],
427 unsigned int NoOfDPP[][2][DC__NUM_DPP__MAX],
428 double ProjectedDCFCLKDeepSleep[][2],
429 double MaximumVStartup[][2][DC__NUM_DPP__MAX],
430 double TotalVActivePixelBandwidth[][2],
431 double TotalVActiveCursorBandwidth[][2],
432 double TotalMetaRowBandwidth[][2],
433 double TotalDPTERowBandwidth[][2],
434 unsigned int TotalNumberOfActiveDPP[][2],
435 unsigned int TotalNumberOfDCCActiveDPP[][2],
436 int dpte_group_bytes[],
437 double PrefetchLinesY[][2][DC__NUM_DPP__MAX],
438 double PrefetchLinesC[][2][DC__NUM_DPP__MAX],
439 int swath_width_luma_ub_all_states[][2][DC__NUM_DPP__MAX],
440 int swath_width_chroma_ub_all_states[][2][DC__NUM_DPP__MAX],
445 double PDEAndMetaPTEBytesPerFrame[][2][DC__NUM_DPP__MAX],
446 double DPTEBytesPerRow[][2][DC__NUM_DPP__MAX],
447 double MetaRowBytes[][2][DC__NUM_DPP__MAX],
448 bool DynamicMetadataEnable[],
449 double VActivePixelBandwidth[][2][DC__NUM_DPP__MAX],
450 double VActiveCursorBandwidth[][2][DC__NUM_DPP__MAX],
451 double ReadBandwidthLuma[],
452 double ReadBandwidthChroma[],
453 double DCFCLKPerState[],
454 double DCFCLKState[][2]);
455 static void CalculatePixelDeliveryTimes(
456 unsigned int NumberOfActivePlanes,
458 double VRatioChroma[],
459 double VRatioPrefetchY[],
460 double VRatioPrefetchC[],
461 unsigned int swath_width_luma_ub[],
462 unsigned int swath_width_chroma_ub[],
463 unsigned int DPPPerPlane[],
465 double HRatioChroma[],
467 double PSCL_THROUGHPUT[],
468 double PSCL_THROUGHPUT_CHROMA[],
471 enum scan_direction_class SourceScan[],
472 unsigned int NumberOfCursors[],
473 unsigned int CursorWidth[][2],
474 unsigned int CursorBPP[][2],
475 unsigned int BlockWidth256BytesY[],
476 unsigned int BlockHeight256BytesY[],
477 unsigned int BlockWidth256BytesC[],
478 unsigned int BlockHeight256BytesC[],
479 double DisplayPipeLineDeliveryTimeLuma[],
480 double DisplayPipeLineDeliveryTimeChroma[],
481 double DisplayPipeLineDeliveryTimeLumaPrefetch[],
482 double DisplayPipeLineDeliveryTimeChromaPrefetch[],
483 double DisplayPipeRequestDeliveryTimeLuma[],
484 double DisplayPipeRequestDeliveryTimeChroma[],
485 double DisplayPipeRequestDeliveryTimeLumaPrefetch[],
486 double DisplayPipeRequestDeliveryTimeChromaPrefetch[],
487 double CursorRequestDeliveryTime[],
488 double CursorRequestDeliveryTimePrefetch[]);
490 static void CalculateMetaAndPTETimes(
491 int NumberOfActivePlanes,
494 int MinMetaChunkSizeBytes,
497 double VRatioChroma[],
498 double DestinationLinesToRequestRowInVBlank[],
499 double DestinationLinesToRequestRowInImmediateFlip[],
504 enum scan_direction_class SourceScan[],
505 int dpte_row_height[],
506 int dpte_row_height_chroma[],
507 int meta_row_width[],
508 int meta_row_width_chroma[],
509 int meta_row_height[],
510 int meta_row_height_chroma[],
511 int meta_req_width[],
512 int meta_req_width_chroma[],
513 int meta_req_height[],
514 int meta_req_height_chroma[],
515 int dpte_group_bytes[],
516 int PTERequestSizeY[],
517 int PTERequestSizeC[],
518 int PixelPTEReqWidthY[],
519 int PixelPTEReqHeightY[],
520 int PixelPTEReqWidthC[],
521 int PixelPTEReqHeightC[],
522 int dpte_row_width_luma_ub[],
523 int dpte_row_width_chroma_ub[],
524 double DST_Y_PER_PTE_ROW_NOM_L[],
525 double DST_Y_PER_PTE_ROW_NOM_C[],
526 double DST_Y_PER_META_ROW_NOM_L[],
527 double DST_Y_PER_META_ROW_NOM_C[],
528 double TimePerMetaChunkNominal[],
529 double TimePerChromaMetaChunkNominal[],
530 double TimePerMetaChunkVBlank[],
531 double TimePerChromaMetaChunkVBlank[],
532 double TimePerMetaChunkFlip[],
533 double TimePerChromaMetaChunkFlip[],
534 double time_per_pte_group_nom_luma[],
535 double time_per_pte_group_vblank_luma[],
536 double time_per_pte_group_flip_luma[],
537 double time_per_pte_group_nom_chroma[],
538 double time_per_pte_group_vblank_chroma[],
539 double time_per_pte_group_flip_chroma[]);
541 static void CalculateVMGroupAndRequestTimes(
542 unsigned int NumberOfActivePlanes,
544 unsigned int GPUVMMaxPageTableLevels,
545 unsigned int HTotal[],
547 double DestinationLinesToRequestVMInVBlank[],
548 double DestinationLinesToRequestVMInImmediateFlip[],
551 int dpte_row_width_luma_ub[],
552 int dpte_row_width_chroma_ub[],
553 int vm_group_bytes[],
554 unsigned int dpde0_bytes_per_frame_ub_l[],
555 unsigned int dpde0_bytes_per_frame_ub_c[],
556 int meta_pte_bytes_per_frame_ub_l[],
557 int meta_pte_bytes_per_frame_ub_c[],
558 double TimePerVMGroupVBlank[],
559 double TimePerVMGroupFlip[],
560 double TimePerVMRequestVBlank[],
561 double TimePerVMRequestFlip[]);
563 static void CalculateStutterEfficiency(
564 int NumberOfActivePlanes,
565 long ROBBufferSizeInKByte,
566 double TotalDataReadBandwidth,
570 bool SynchronizedVBlank,
572 double DETBufferSizeY[],
574 double BytePerPixelDETY[],
575 double SwathWidthY[],
578 double DCCRateLuma[],
579 double DCCRateChroma[],
584 enum scan_direction_class SourceScan[],
585 int BlockHeight256BytesY[],
586 int BlockWidth256BytesY[],
587 int BlockHeight256BytesC[],
588 int BlockWidth256BytesC[],
589 int DCCYMaxUncompressedBlock[],
590 int DCCCMaxUncompressedBlock[],
593 bool WritebackEnable[],
594 double ReadBandwidthPlaneLuma[],
595 double ReadBandwidthPlaneChroma[],
596 double meta_row_bw[],
597 double dpte_row_bw[],
598 double *StutterEfficiencyNotIncludingVBlank,
599 double *StutterEfficiency);
601 static void CalculateSwathAndDETConfiguration(
603 int NumberOfActivePlanes,
604 long DETBufferSizeInKByte,
605 double MaximumSwathWidthLuma[],
606 double MaximumSwathWidthChroma[],
607 enum scan_direction_class SourceScan[],
608 enum source_format_class SourcePixelFormat[],
609 enum dm_swizzle_mode SurfaceTiling[],
611 int ViewportHeight[],
614 int SurfaceHeightY[],
615 int SurfaceHeightC[],
616 int Read256BytesBlockHeightY[],
617 int Read256BytesBlockHeightC[],
618 int Read256BytesBlockWidthY[],
619 int Read256BytesBlockWidthC[],
620 enum odm_combine_mode ODMCombineEnabled[],
621 int BlendingAndTiming[],
624 double BytePerPixDETY[],
625 double BytePerPixDETC[],
628 double HRatioChroma[],
630 int swath_width_luma_ub[],
631 int swath_width_chroma_ub[],
633 double SwathWidthChroma[],
636 double DETBufferSizeY[],
637 double DETBufferSizeC[],
638 bool ViewportSizeSupportPerPlane[],
639 bool *ViewportSizeSupport);
640 static void CalculateSwathWidth(
642 int NumberOfActivePlanes,
643 enum source_format_class SourcePixelFormat[],
644 enum scan_direction_class SourceScan[],
645 unsigned int ViewportWidth[],
646 unsigned int ViewportHeight[],
647 unsigned int SurfaceWidthY[],
648 unsigned int SurfaceWidthC[],
649 unsigned int SurfaceHeightY[],
650 unsigned int SurfaceHeightC[],
651 enum odm_combine_mode ODMCombineEnabled[],
654 int Read256BytesBlockHeightY[],
655 int Read256BytesBlockHeightC[],
656 int Read256BytesBlockWidthY[],
657 int Read256BytesBlockWidthC[],
658 int BlendingAndTiming[],
659 unsigned int HActive[],
662 double SwathWidthSingleDPPY[],
663 double SwathWidthSingleDPPC[],
664 double SwathWidthY[],
665 double SwathWidthC[],
666 int MaximumSwathHeightY[],
667 int MaximumSwathHeightC[],
668 unsigned int swath_width_luma_ub[],
669 unsigned int swath_width_chroma_ub[]);
670 static double CalculateExtraLatency(
671 long RoundTripPingLatencyCycles,
672 long ReorderingBytes,
674 int TotalNumberOfActiveDPP,
675 int PixelChunkSizeInKByte,
676 int TotalNumberOfDCCActiveDPP,
681 int NumberOfActivePlanes,
683 int dpte_group_bytes[],
684 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
685 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
686 double HostVMMinPageSize,
687 int HostVMMaxNonCachedPageTableLevels);
688 static double CalculateExtraLatencyBytes(
689 long ReorderingBytes,
690 int TotalNumberOfActiveDPP,
691 int PixelChunkSizeInKByte,
692 int TotalNumberOfDCCActiveDPP,
696 int NumberOfActivePlanes,
698 int dpte_group_bytes[],
699 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
700 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
701 double HostVMMinPageSize,
702 int HostVMMaxNonCachedPageTableLevels);
703 static double CalculateUrgentLatency(
704 double UrgentLatencyPixelDataOnly,
705 double UrgentLatencyPixelMixedWithVMData,
706 double UrgentLatencyVMDataOnly,
707 bool DoUrgentLatencyAdjustment,
708 double UrgentLatencyAdjustmentFabricClockComponent,
709 double UrgentLatencyAdjustmentFabricClockReference,
710 double FabricClockSingle);
712 static bool CalculateBytePerPixelAnd256BBlockSizes(
713 enum source_format_class SourcePixelFormat,
714 enum dm_swizzle_mode SurfaceTiling,
715 unsigned int *BytePerPixelY,
716 unsigned int *BytePerPixelC,
717 double *BytePerPixelDETY,
718 double *BytePerPixelDETC,
719 unsigned int *BlockHeight256BytesY,
720 unsigned int *BlockHeight256BytesC,
721 unsigned int *BlockWidth256BytesY,
722 unsigned int *BlockWidth256BytesC);
724 void dml30_recalculate(struct display_mode_lib *mode_lib)
726 ModeSupportAndSystemConfiguration(mode_lib);
727 PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
728 DisplayPipeConfiguration(mode_lib);
729 DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
732 static unsigned int dscceComputeDelay(
735 unsigned int sliceWidth,
736 unsigned int numSlices,
737 enum output_format_class pixelFormat,
738 enum output_encoder_class Output)
740 // valid bpc = source bits per component in the set of {8, 10, 12}
741 // valid bpp = increments of 1/16 of a bit
742 // min = 6/7/8 in N420/N422/444, respectively
743 // max = such that compression is 1:1
744 //valid sliceWidth = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
745 //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
746 //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
749 unsigned int rcModelSize = 8192;
751 // N422/N420 operate at 2 pixels per clock
752 unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, P, l0, a, ax, L,
755 if (pixelFormat == dm_420)
757 // #all other modes operate at 1 pixel per clock
758 else if (pixelFormat == dm_444)
760 else if (pixelFormat == dm_n422)
765 //initial transmit delay as per PPS
766 initalXmitDelay = dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock);
776 //divide by pixel per cycle to compute slice width as seen by DSC
777 w = sliceWidth / pixelsPerClock;
779 //422 mode has an additional cycle of delay
780 if (pixelFormat == dm_420 || pixelFormat == dm_444 || pixelFormat == dm_n422)
785 //main calculation for the dscce
786 ix = initalXmitDelay + 45;
791 ax = (a + 2) / 3 + D + 6 + 1;
792 L = (ax + wx - 1) / wx;
793 if ((ix % w) == 0 && P != 0)
797 Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22;
799 //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
800 pixels = Delay * 3 * pixelsPerClock;
804 static unsigned int dscComputeDelay(enum output_format_class pixelFormat, enum output_encoder_class Output)
806 unsigned int Delay = 0;
808 if (pixelFormat == dm_420) {
813 // dscc - input deserializer
815 // dscc gets pixels every other cycle
817 // dscc - input cdc fifo
819 // dscc gets pixels every other cycle
821 // dscc - cdc uncertainty
823 // dscc - output cdc fifo
825 // dscc gets pixels every other cycle
827 // dscc - cdc uncertainty
829 // dscc - output serializer
833 } else if (pixelFormat == dm_n422) {
838 // dscc - input deserializer
840 // dscc - input cdc fifo
842 // dscc - cdc uncertainty
844 // dscc - output cdc fifo
846 // dscc - cdc uncertainty
848 // dscc - output serializer
858 // dscc - input deserializer
860 // dscc - input cdc fifo
862 // dscc - cdc uncertainty
864 // dscc - output cdc fifo
866 // dscc - output serializer
868 // dscc - cdc uncertainty
877 static bool CalculatePrefetchSchedule(
878 struct display_mode_lib *mode_lib,
879 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
880 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
882 unsigned int DSCDelay,
883 double DPPCLKDelaySubtotalPlusCNVCFormater,
884 double DPPCLKDelaySCL,
885 double DPPCLKDelaySCLLBOnly,
886 double DPPCLKDelayCNVCCursor,
887 double DISPCLKDelaySubtotal,
888 unsigned int DPP_RECOUT_WIDTH,
889 enum output_format_class OutputFormat,
890 unsigned int MaxInterDCNTileRepeaters,
891 unsigned int VStartup,
892 unsigned int MaxVStartup,
893 unsigned int GPUVMPageTableLevels,
896 unsigned int HostVMMaxNonCachedPageTableLevels,
897 double HostVMMinPageSize,
898 bool DynamicMetadataEnable,
899 bool DynamicMetadataVMEnabled,
900 int DynamicMetadataLinesBeforeActiveRequired,
901 unsigned int DynamicMetadataTransmittedBytes,
902 double UrgentLatency,
903 double UrgentExtraLatency,
905 unsigned int PDEAndMetaPTEBytesFrame,
906 unsigned int MetaRowByte,
907 unsigned int PixelPTEBytesPerRow,
908 double PrefetchSourceLinesY,
909 unsigned int SwathWidthY,
911 double VInitPreFillY,
912 unsigned int MaxNumSwathY,
913 double PrefetchSourceLinesC,
914 unsigned int SwathWidthC,
916 double VInitPreFillC,
917 unsigned int MaxNumSwathC,
918 long swath_width_luma_ub,
919 long swath_width_chroma_ub,
920 unsigned int SwathHeightY,
921 unsigned int SwathHeightC,
923 bool ProgressiveToInterlaceUnitInOPP,
924 double *DSTXAfterScaler,
925 double *DSTYAfterScaler,
926 double *DestinationLinesForPrefetch,
927 double *PrefetchBandwidth,
928 double *DestinationLinesToRequestVMInVBlank,
929 double *DestinationLinesToRequestRowInVBlank,
930 double *VRatioPrefetchY,
931 double *VRatioPrefetchC,
932 double *RequiredPrefetchPixDataBWLuma,
933 double *RequiredPrefetchPixDataBWChroma,
934 bool *NotEnoughTimeForDynamicMetadata,
936 double *prefetch_vmrow_bw,
939 unsigned int *VUpdateOffsetPix,
940 double *VUpdateWidthPix,
941 double *VReadyOffsetPix)
943 bool MyError = false;
944 unsigned int DPPCycles = 0, DISPCLKCycles = 0;
945 double DSTTotalPixelsAfterScaler = 0;
946 double LineTime = 0, Tsetup = 0;
947 double dst_y_prefetch_equ = 0;
949 double prefetch_bw_oto = 0;
952 double Tvm_oto_lines = 0;
953 double Tr0_oto_lines = 0;
954 double dst_y_prefetch_oto = 0;
955 double TimeForFetchingMetaPTE = 0;
956 double TimeForFetchingRowInVBlank = 0;
957 double LinesToRequestPrefetchPixelData = 0;
958 double HostVMInefficiencyFactor = 0;
959 unsigned int HostVMDynamicLevelsTrips = 0;
960 double trip_to_mem = 0;
961 double Tvm_trips = 0;
962 double Tr0_trips = 0;
963 double Tvm_trips_rounded = 0;
964 double Tr0_trips_rounded = 0;
966 double Tpre_rounded = 0;
967 double prefetch_bw_equ = 0;
974 if (GPUVMEnable == true && HostVMEnable == true) {
975 HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
976 HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
978 HostVMInefficiencyFactor = 1;
979 HostVMDynamicLevelsTrips = 0;
982 CalculateDynamicMetadataParameters(
983 MaxInterDCNTileRepeaters,
986 myPipe->DCFCLKDeepSleep,
990 DynamicMetadataTransmittedBytes,
991 DynamicMetadataLinesBeforeActiveRequired,
992 myPipe->InterlaceEnable,
993 ProgressiveToInterlaceUnitInOPP,
999 LineTime = myPipe->HTotal / myPipe->PixelClock;
1000 trip_to_mem = UrgentLatency;
1001 Tvm_trips = UrgentExtraLatency + trip_to_mem * (GPUVMPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1);
1003 if (DynamicMetadataVMEnabled == true && GPUVMEnable == true) {
1004 *Tdmdl = TWait + Tvm_trips + trip_to_mem;
1006 *Tdmdl = TWait + UrgentExtraLatency;
1009 if (DynamicMetadataEnable == true) {
1010 if (VStartup * LineTime < Tsetup + *Tdmdl + Tdmbf + Tdmec + Tdmsks) {
1011 *NotEnoughTimeForDynamicMetadata = true;
1013 *NotEnoughTimeForDynamicMetadata = false;
1014 dml_print("DML: Not Enough Time for Dynamic Meta!\n");
1015 dml_print("DML: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", Tdmbf);
1016 dml_print("DML: Tdmec: %fus - time dio takes to transfer dmd\n", Tdmec);
1017 dml_print("DML: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", Tdmsks);
1018 dml_print("DML: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", *Tdmdl);
1021 *NotEnoughTimeForDynamicMetadata = false;
1024 *Tdmdl_vm = (DynamicMetadataEnable == true && DynamicMetadataVMEnabled == true && GPUVMEnable == true ? TWait + Tvm_trips : 0);
1026 if (myPipe->ScalerEnabled)
1027 DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCL;
1029 DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCLLBOnly;
1031 DPPCycles = DPPCycles + myPipe->NumberOfCursors * DPPCLKDelayCNVCCursor;
1033 DISPCLKCycles = DISPCLKDelaySubtotal;
1035 if (myPipe->DPPCLK == 0.0 || myPipe->DISPCLK == 0.0)
1038 *DSTXAfterScaler = DPPCycles * myPipe->PixelClock / myPipe->DPPCLK + DISPCLKCycles * myPipe->PixelClock / myPipe->DISPCLK
1041 *DSTXAfterScaler = *DSTXAfterScaler + ((myPipe->ODMCombineEnabled)?18:0) + (myPipe->DPPPerPlane - 1) * DPP_RECOUT_WIDTH;
1043 if (OutputFormat == dm_420 || (myPipe->InterlaceEnable && ProgressiveToInterlaceUnitInOPP))
1044 *DSTYAfterScaler = 1;
1046 *DSTYAfterScaler = 0;
1048 DSTTotalPixelsAfterScaler = *DSTYAfterScaler * myPipe->HTotal + *DSTXAfterScaler;
1049 *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / myPipe->HTotal, 1);
1050 *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * myPipe->HTotal));
1055 Tr0_trips = trip_to_mem * (HostVMDynamicLevelsTrips + 1);
1056 Tvm_trips_rounded = dml_ceil(4.0 * Tvm_trips / LineTime, 1) / 4 * LineTime;
1057 Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1) / 4 * LineTime;
1060 if (GPUVMPageTableLevels >= 3) {
1061 *Tno_bw = UrgentExtraLatency + trip_to_mem * ((GPUVMPageTableLevels - 2) - 1);
1064 } else if (!myPipe->DCCEnable)
1067 *Tno_bw = LineTime / 4;
1069 dst_y_prefetch_equ = VStartup - (Tsetup + dml_max(TWait + TCalc, *Tdmdl)) / LineTime
1070 - (*DSTYAfterScaler + *DSTXAfterScaler / myPipe->HTotal);
1072 Lsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC);
1073 Tsw_oto = Lsw_oto * LineTime;
1075 prefetch_bw_oto = (PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC) / Tsw_oto;
1077 if (GPUVMEnable == true) {
1078 Tvm_oto = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_oto,
1082 Tvm_oto = LineTime / 4.0;
1084 if ((GPUVMEnable == true || myPipe->DCCEnable == true)) {
1086 (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto,
1087 LineTime - Tvm_oto, LineTime / 4);
1089 Tr0_oto = (LineTime - Tvm_oto) / 2.0;
1091 Tvm_oto_lines = dml_ceil(4.0 * Tvm_oto / LineTime, 1) / 4.0;
1092 Tr0_oto_lines = dml_ceil(4.0 * Tr0_oto / LineTime, 1) / 4.0;
1093 dst_y_prefetch_oto = Tvm_oto_lines + 2 * Tr0_oto_lines + Lsw_oto;
1095 dst_y_prefetch_equ = dml_floor(4.0 * (dst_y_prefetch_equ + 0.125), 1) / 4.0;
1096 Tpre_rounded = dst_y_prefetch_equ * LineTime;
1098 dml_print("DML: dst_y_prefetch_oto: %f\n", dst_y_prefetch_oto);
1099 dml_print("DML: dst_y_prefetch_equ: %f\n", dst_y_prefetch_equ);
1101 dml_print("DML: LineTime: %f\n", LineTime);
1102 dml_print("DML: VStartup: %d\n", VStartup);
1103 dml_print("DML: Tvstartup: %fus - time between vstartup and first pixel of active\n", VStartup * LineTime);
1104 dml_print("DML: Tsetup: %fus - time from vstartup to vready\n", Tsetup);
1105 dml_print("DML: TCalc: %fus - time for calculations in dchub starting at vready\n", TCalc);
1106 dml_print("DML: TWait: %fus - time for fabric to become ready max(pstate exit,cstate enter/exit, urgent latency) after TCalc\n", TWait);
1107 dml_print("DML: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", Tdmbf);
1108 dml_print("DML: Tdmec: %fus - time dio takes to transfer dmd\n", Tdmec);
1109 dml_print("DML: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", Tdmsks);
1110 dml_print("DML: Tdmdl_vm: %fus - time for vm stages of dmd \n", *Tdmdl_vm);
1111 dml_print("DML: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", *Tdmdl);
1112 dml_print("DML: dst_x_after_scl: %f pixels - number of pixel clocks pipeline and buffer delay after scaler \n", *DSTXAfterScaler);
1113 dml_print("DML: dst_y_after_scl: %d lines - number of lines of pipeline and buffer delay after scaler \n", (int)*DSTYAfterScaler);
1115 *PrefetchBandwidth = 0;
1116 *DestinationLinesToRequestVMInVBlank = 0;
1117 *DestinationLinesToRequestRowInVBlank = 0;
1118 *VRatioPrefetchY = 0;
1119 *VRatioPrefetchC = 0;
1120 *RequiredPrefetchPixDataBWLuma = 0;
1121 if (dst_y_prefetch_equ > 1) {
1122 double PrefetchBandwidth1 = 0;
1123 double PrefetchBandwidth2 = 0;
1124 double PrefetchBandwidth3 = 0;
1125 double PrefetchBandwidth4 = 0;
1127 if (Tpre_rounded - *Tno_bw > 0)
1128 PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte
1129 + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor
1130 + PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY
1131 + PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC)
1132 / (Tpre_rounded - *Tno_bw);
1134 PrefetchBandwidth1 = 0;
1136 if (VStartup == MaxVStartup && (PrefetchBandwidth1 > 4 * prefetch_bw_oto) && (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - *Tno_bw) > 0) {
1137 PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - *Tno_bw);
1140 if (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded > 0)
1141 PrefetchBandwidth2 = (PDEAndMetaPTEBytesFrame *
1142 HostVMInefficiencyFactor + PrefetchSourceLinesY *
1143 swath_width_luma_ub * BytePerPixelY +
1144 PrefetchSourceLinesC * swath_width_chroma_ub *
1146 (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded);
1148 PrefetchBandwidth2 = 0;
1150 if (Tpre_rounded - Tvm_trips_rounded > 0)
1151 PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow *
1152 HostVMInefficiencyFactor + PrefetchSourceLinesY *
1153 swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC *
1154 swath_width_chroma_ub * BytePerPixelC) / (Tpre_rounded -
1157 PrefetchBandwidth3 = 0;
1159 if (VStartup == MaxVStartup && (PrefetchBandwidth3 > 4 * prefetch_bw_oto) && Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - Tvm_trips_rounded > 0) {
1160 PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (Tpre_rounded - Tsw_oto / 4 - 0.75 * LineTime - Tvm_trips_rounded);
1163 if (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded > 0)
1164 PrefetchBandwidth4 = (PrefetchSourceLinesY * swath_width_luma_ub * BytePerPixelY + PrefetchSourceLinesC * swath_width_chroma_ub * BytePerPixelC)
1165 / (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded);
1167 PrefetchBandwidth4 = 0;
1174 if (PrefetchBandwidth1 > 0) {
1175 if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth1
1176 >= Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth1 >= Tr0_trips_rounded) {
1185 if (PrefetchBandwidth2 > 0) {
1186 if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth2
1187 >= Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth2 < Tr0_trips_rounded) {
1196 if (PrefetchBandwidth3 > 0) {
1197 if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth3
1198 < Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / PrefetchBandwidth3 >= Tr0_trips_rounded) {
1208 prefetch_bw_equ = PrefetchBandwidth1;
1209 } else if (Case2OK) {
1210 prefetch_bw_equ = PrefetchBandwidth2;
1211 } else if (Case3OK) {
1212 prefetch_bw_equ = PrefetchBandwidth3;
1214 prefetch_bw_equ = PrefetchBandwidth4;
1217 dml_print("DML: prefetch_bw_equ: %f\n", prefetch_bw_equ);
1219 if (prefetch_bw_equ > 0) {
1220 if (GPUVMEnable == true) {
1221 Tvm_equ = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_equ, Tvm_trips, LineTime / 4);
1223 Tvm_equ = LineTime / 4;
1226 if ((GPUVMEnable == true || myPipe->DCCEnable == true)) {
1228 (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_equ,
1230 (LineTime - Tvm_equ) / 2,
1233 Tr0_equ = (LineTime - Tvm_equ) / 2;
1238 dml_print("DML: prefetch_bw_equ equals 0! %s:%d\n", __FILE__, __LINE__);
1242 if (dst_y_prefetch_oto < dst_y_prefetch_equ) {
1243 *DestinationLinesForPrefetch = dst_y_prefetch_oto;
1244 TimeForFetchingMetaPTE = Tvm_oto;
1245 TimeForFetchingRowInVBlank = Tr0_oto;
1246 *PrefetchBandwidth = prefetch_bw_oto;
1248 *DestinationLinesForPrefetch = dst_y_prefetch_equ;
1249 TimeForFetchingMetaPTE = Tvm_equ;
1250 TimeForFetchingRowInVBlank = Tr0_equ;
1251 *PrefetchBandwidth = prefetch_bw_equ;
1254 *DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * TimeForFetchingMetaPTE / LineTime, 1.0) / 4.0;
1256 *DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * TimeForFetchingRowInVBlank / LineTime, 1.0) / 4.0;
1259 LinesToRequestPrefetchPixelData = *DestinationLinesForPrefetch - *DestinationLinesToRequestVMInVBlank
1260 - 2 * *DestinationLinesToRequestRowInVBlank;
1262 if (LinesToRequestPrefetchPixelData > 0 && prefetch_bw_equ > 0) {
1264 *VRatioPrefetchY = (double) PrefetchSourceLinesY
1265 / LinesToRequestPrefetchPixelData;
1266 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
1267 if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
1268 if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
1269 *VRatioPrefetchY = dml_max((double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData,
1270 (double) MaxNumSwathY * SwathHeightY / (LinesToRequestPrefetchPixelData - (VInitPreFillY - 3.0) / 2.0));
1271 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
1274 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1275 *VRatioPrefetchY = 0;
1279 *VRatioPrefetchC = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData;
1280 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
1282 if ((SwathHeightC > 4)) {
1283 if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
1284 *VRatioPrefetchC = dml_max(*VRatioPrefetchC,
1285 (double) MaxNumSwathC * SwathHeightC / (LinesToRequestPrefetchPixelData - (VInitPreFillC - 3.0) / 2.0));
1286 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
1289 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1290 *VRatioPrefetchC = 0;
1294 *RequiredPrefetchPixDataBWLuma = (double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData * BytePerPixelY * swath_width_luma_ub / LineTime;
1295 *RequiredPrefetchPixDataBWChroma = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData * BytePerPixelC * swath_width_chroma_ub / LineTime;
1298 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1299 dml_print("DML: LinesToRequestPrefetchPixelData: %f, should be > 0\n", LinesToRequestPrefetchPixelData);
1300 *VRatioPrefetchY = 0;
1301 *VRatioPrefetchC = 0;
1302 *RequiredPrefetchPixDataBWLuma = 0;
1303 *RequiredPrefetchPixDataBWChroma = 0;
1306 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);
1307 dml_print("DML: Tvm: %fus - time to fetch page tables for meta surface\n", TimeForFetchingMetaPTE);
1308 dml_print("DML: Tr0: %fus - time to fetch first row of data pagetables and first row of meta data (done in parallel)\n", TimeForFetchingRowInVBlank);
1309 dml_print("DML: Tr1: %fus - time to fetch second row of data pagetables and second row of meta data (done in parallel)\n", TimeForFetchingRowInVBlank);
1310 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);
1311 dml_print("DML: To: %fus - time for propagation from scaler to optc\n", (*DSTYAfterScaler + ((*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime);
1312 dml_print("DML: Tvstartup - Tsetup - Tcalc - Twait - Tpre - To > 0\n");
1313 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);
1314 dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %d\n", PixelPTEBytesPerRow);
1318 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1322 double prefetch_vm_bw = 0;
1323 double prefetch_row_bw = 0;
1325 if (PDEAndMetaPTEBytesFrame == 0) {
1327 } else if (*DestinationLinesToRequestVMInVBlank > 0) {
1328 prefetch_vm_bw = PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInVBlank * LineTime);
1332 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1334 if (MetaRowByte + PixelPTEBytesPerRow == 0) {
1335 prefetch_row_bw = 0;
1336 } else if (*DestinationLinesToRequestRowInVBlank > 0) {
1337 prefetch_row_bw = (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInVBlank * LineTime);
1339 prefetch_row_bw = 0;
1341 dml_print("DML: MyErr set %s:%d\n", __FILE__, __LINE__);
1344 *prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw);
1348 *PrefetchBandwidth = 0;
1349 TimeForFetchingMetaPTE = 0;
1350 TimeForFetchingRowInVBlank = 0;
1351 *DestinationLinesToRequestVMInVBlank = 0;
1352 *DestinationLinesToRequestRowInVBlank = 0;
1353 *DestinationLinesForPrefetch = 0;
1354 LinesToRequestPrefetchPixelData = 0;
1355 *VRatioPrefetchY = 0;
1356 *VRatioPrefetchC = 0;
1357 *RequiredPrefetchPixDataBWLuma = 0;
1358 *RequiredPrefetchPixDataBWChroma = 0;
1364 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed)
1366 return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1);
1369 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed)
1371 return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4.0 / Clock, 1);
1374 static void CalculateDCCConfiguration(
1376 bool DCCProgrammingAssumesScanDirectionUnknown,
1377 enum source_format_class SourcePixelFormat,
1378 unsigned int SurfaceWidthLuma,
1379 unsigned int SurfaceWidthChroma,
1380 unsigned int SurfaceHeightLuma,
1381 unsigned int SurfaceHeightChroma,
1382 double DETBufferSize,
1383 unsigned int RequestHeight256ByteLuma,
1384 unsigned int RequestHeight256ByteChroma,
1385 enum dm_swizzle_mode TilingFormat,
1386 unsigned int BytePerPixelY,
1387 unsigned int BytePerPixelC,
1388 double BytePerPixelDETY,
1389 double BytePerPixelDETC,
1390 enum scan_direction_class ScanOrientation,
1391 unsigned int *MaxUncompressedBlockLuma,
1392 unsigned int *MaxUncompressedBlockChroma,
1393 unsigned int *MaxCompressedBlockLuma,
1394 unsigned int *MaxCompressedBlockChroma,
1395 unsigned int *IndependentBlockLuma,
1396 unsigned int *IndependentBlockChroma)
1404 int req128_horz_wc_l = 0;
1405 int req128_horz_wc_c = 0;
1406 int req128_vert_wc_l = 0;
1407 int req128_vert_wc_c = 0;
1408 int segment_order_horz_contiguous_luma = 0;
1409 int segment_order_horz_contiguous_chroma = 0;
1410 int segment_order_vert_contiguous_luma = 0;
1411 int segment_order_vert_contiguous_chroma = 0;
1413 long full_swath_bytes_horz_wc_l = 0;
1414 long full_swath_bytes_horz_wc_c = 0;
1415 long full_swath_bytes_vert_wc_l = 0;
1416 long full_swath_bytes_vert_wc_c = 0;
1418 long swath_buf_size = 0;
1419 double detile_buf_vp_horz_limit = 0;
1420 double detile_buf_vp_vert_limit = 0;
1422 long MAS_vp_horz_limit = 0;
1423 long MAS_vp_vert_limit = 0;
1424 long max_vp_horz_width = 0;
1425 long max_vp_vert_height = 0;
1426 long eff_surf_width_l = 0;
1427 long eff_surf_width_c = 0;
1428 long eff_surf_height_l = 0;
1429 long eff_surf_height_c = 0;
1433 REQ_128BytesNonContiguous,
1434 REQ_128BytesContiguous,
1438 RequestType RequestLuma;
1439 RequestType RequestChroma;
1441 yuv420 = ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12) ? 1 : 0);
1447 if (BytePerPixelY == 1)
1449 if (BytePerPixelC == 1)
1451 if (BytePerPixelY == 8
1452 && (TilingFormat == dm_sw_64kb_s || TilingFormat == dm_sw_64kb_s_t
1453 || TilingFormat == dm_sw_64kb_s_x))
1455 if (BytePerPixelC == 8
1456 && (TilingFormat == dm_sw_64kb_s || TilingFormat == dm_sw_64kb_s_t
1457 || TilingFormat == dm_sw_64kb_s_x))
1460 if (BytePerPixelC == 0) {
1461 swath_buf_size = DETBufferSize / 2 - 2 * 256;
1462 detile_buf_vp_horz_limit = (double) swath_buf_size
1463 / ((double) RequestHeight256ByteLuma * BytePerPixelY
1464 / (1 + horz_div_l));
1465 detile_buf_vp_vert_limit = (double) swath_buf_size
1466 / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l));
1468 swath_buf_size = DETBufferSize / 2 - 2 * 2 * 256;
1469 detile_buf_vp_horz_limit = (double) swath_buf_size
1470 / ((double) RequestHeight256ByteLuma * BytePerPixelY
1472 + (double) RequestHeight256ByteChroma
1473 * BytePerPixelC / (1 + horz_div_c)
1475 detile_buf_vp_vert_limit = (double) swath_buf_size
1476 / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l)
1477 + 256.0 / RequestHeight256ByteChroma
1478 / (1 + vert_div_c) / (1 + yuv420));
1481 if (SourcePixelFormat == dm_420_10) {
1482 detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit;
1483 detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit;
1486 detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16);
1487 detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16);
1489 MAS_vp_horz_limit = 5760;
1490 MAS_vp_vert_limit = (BytePerPixelC > 0 ? 2880 : 5760);
1491 max_vp_horz_width = dml_min((double) MAS_vp_horz_limit, detile_buf_vp_horz_limit);
1492 max_vp_vert_height = dml_min((double) MAS_vp_vert_limit, detile_buf_vp_vert_limit);
1494 (SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma);
1495 eff_surf_width_c = eff_surf_width_l / (1 + yuv420);
1496 eff_surf_height_l = (
1497 SurfaceHeightLuma > max_vp_vert_height ?
1498 max_vp_vert_height : SurfaceHeightLuma);
1499 eff_surf_height_c = eff_surf_height_l / (1 + yuv420);
1501 full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY;
1502 full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma;
1503 if (BytePerPixelC > 0) {
1504 full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma
1506 full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma;
1508 full_swath_bytes_horz_wc_c = 0;
1509 full_swath_bytes_vert_wc_c = 0;
1512 if (SourcePixelFormat == dm_420_10) {
1513 full_swath_bytes_horz_wc_l = dml_ceil(full_swath_bytes_horz_wc_l * 2 / 3, 256);
1514 full_swath_bytes_horz_wc_c = dml_ceil(full_swath_bytes_horz_wc_c * 2 / 3, 256);
1515 full_swath_bytes_vert_wc_l = dml_ceil(full_swath_bytes_vert_wc_l * 2 / 3, 256);
1516 full_swath_bytes_vert_wc_c = dml_ceil(full_swath_bytes_vert_wc_c * 2 / 3, 256);
1519 if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSize) {
1520 req128_horz_wc_l = 0;
1521 req128_horz_wc_c = 0;
1522 } else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c
1523 && 2 * full_swath_bytes_horz_wc_l + full_swath_bytes_horz_wc_c
1525 req128_horz_wc_l = 0;
1526 req128_horz_wc_c = 1;
1527 } else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c
1528 && full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c
1530 req128_horz_wc_l = 1;
1531 req128_horz_wc_c = 0;
1533 req128_horz_wc_l = 1;
1534 req128_horz_wc_c = 1;
1537 if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSize) {
1538 req128_vert_wc_l = 0;
1539 req128_vert_wc_c = 0;
1540 } else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c
1541 && 2 * full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c
1543 req128_vert_wc_l = 0;
1544 req128_vert_wc_c = 1;
1545 } else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c
1546 && full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c
1548 req128_vert_wc_l = 1;
1549 req128_vert_wc_c = 0;
1551 req128_vert_wc_l = 1;
1552 req128_vert_wc_c = 1;
1555 if (BytePerPixelY == 2 || (BytePerPixelY == 4 && TilingFormat != dm_sw_64kb_r_x)) {
1556 segment_order_horz_contiguous_luma = 0;
1558 segment_order_horz_contiguous_luma = 1;
1560 if ((BytePerPixelY == 8
1561 && (TilingFormat == dm_sw_64kb_d || TilingFormat == dm_sw_64kb_d_x
1562 || TilingFormat == dm_sw_64kb_d_t
1563 || TilingFormat == dm_sw_64kb_r_x))
1564 || (BytePerPixelY == 4 && TilingFormat == dm_sw_64kb_r_x)) {
1565 segment_order_vert_contiguous_luma = 0;
1567 segment_order_vert_contiguous_luma = 1;
1569 if (BytePerPixelC == 2 || (BytePerPixelC == 4 && TilingFormat != dm_sw_64kb_r_x)) {
1570 segment_order_horz_contiguous_chroma = 0;
1572 segment_order_horz_contiguous_chroma = 1;
1574 if ((BytePerPixelC == 8
1575 && (TilingFormat == dm_sw_64kb_d || TilingFormat == dm_sw_64kb_d_x
1576 || TilingFormat == dm_sw_64kb_d_t
1577 || TilingFormat == dm_sw_64kb_r_x))
1578 || (BytePerPixelC == 4 && TilingFormat == dm_sw_64kb_r_x)) {
1579 segment_order_vert_contiguous_chroma = 0;
1581 segment_order_vert_contiguous_chroma = 1;
1584 if (DCCProgrammingAssumesScanDirectionUnknown == true) {
1585 if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0) {
1586 RequestLuma = REQ_256Bytes;
1587 } else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0)
1588 || (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0)) {
1589 RequestLuma = REQ_128BytesNonContiguous;
1591 RequestLuma = REQ_128BytesContiguous;
1593 if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0) {
1594 RequestChroma = REQ_256Bytes;
1595 } else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0)
1596 || (req128_vert_wc_c == 1
1597 && segment_order_vert_contiguous_chroma == 0)) {
1598 RequestChroma = REQ_128BytesNonContiguous;
1600 RequestChroma = REQ_128BytesContiguous;
1602 } else if (ScanOrientation != dm_vert) {
1603 if (req128_horz_wc_l == 0) {
1604 RequestLuma = REQ_256Bytes;
1605 } else if (segment_order_horz_contiguous_luma == 0) {
1606 RequestLuma = REQ_128BytesNonContiguous;
1608 RequestLuma = REQ_128BytesContiguous;
1610 if (req128_horz_wc_c == 0) {
1611 RequestChroma = REQ_256Bytes;
1612 } else if (segment_order_horz_contiguous_chroma == 0) {
1613 RequestChroma = REQ_128BytesNonContiguous;
1615 RequestChroma = REQ_128BytesContiguous;
1618 if (req128_vert_wc_l == 0) {
1619 RequestLuma = REQ_256Bytes;
1620 } else if (segment_order_vert_contiguous_luma == 0) {
1621 RequestLuma = REQ_128BytesNonContiguous;
1623 RequestLuma = REQ_128BytesContiguous;
1625 if (req128_vert_wc_c == 0) {
1626 RequestChroma = REQ_256Bytes;
1627 } else if (segment_order_vert_contiguous_chroma == 0) {
1628 RequestChroma = REQ_128BytesNonContiguous;
1630 RequestChroma = REQ_128BytesContiguous;
1634 if (RequestLuma == REQ_256Bytes) {
1635 *MaxUncompressedBlockLuma = 256;
1636 *MaxCompressedBlockLuma = 256;
1637 *IndependentBlockLuma = 0;
1638 } else if (RequestLuma == REQ_128BytesContiguous) {
1639 *MaxUncompressedBlockLuma = 256;
1640 *MaxCompressedBlockLuma = 128;
1641 *IndependentBlockLuma = 128;
1643 *MaxUncompressedBlockLuma = 256;
1644 *MaxCompressedBlockLuma = 64;
1645 *IndependentBlockLuma = 64;
1648 if (RequestChroma == REQ_256Bytes) {
1649 *MaxUncompressedBlockChroma = 256;
1650 *MaxCompressedBlockChroma = 256;
1651 *IndependentBlockChroma = 0;
1652 } else if (RequestChroma == REQ_128BytesContiguous) {
1653 *MaxUncompressedBlockChroma = 256;
1654 *MaxCompressedBlockChroma = 128;
1655 *IndependentBlockChroma = 128;
1657 *MaxUncompressedBlockChroma = 256;
1658 *MaxCompressedBlockChroma = 64;
1659 *IndependentBlockChroma = 64;
1662 if (DCCEnabled != true || BytePerPixelC == 0) {
1663 *MaxUncompressedBlockChroma = 0;
1664 *MaxCompressedBlockChroma = 0;
1665 *IndependentBlockChroma = 0;
1668 if (DCCEnabled != true) {
1669 *MaxUncompressedBlockLuma = 0;
1670 *MaxCompressedBlockLuma = 0;
1671 *IndependentBlockLuma = 0;
1676 static double CalculatePrefetchSourceLines(
1677 struct display_mode_lib *mode_lib,
1681 bool ProgressiveToInterlaceUnitInOPP,
1682 unsigned int SwathHeight,
1683 unsigned int ViewportYStart,
1684 double *VInitPreFill,
1685 unsigned int *MaxNumSwath)
1687 unsigned int MaxPartialSwath = 0;
1689 if (ProgressiveToInterlaceUnitInOPP)
1690 *VInitPreFill = dml_floor((VRatio + vtaps + 1) / 2.0, 1);
1692 *VInitPreFill = dml_floor((VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1);
1694 if (!mode_lib->vba.IgnoreViewportPositioning) {
1696 *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0;
1698 if (*VInitPreFill > 1.0)
1699 MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight;
1701 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2)
1703 MaxPartialSwath = dml_max(1U, MaxPartialSwath);
1707 if (ViewportYStart != 0)
1709 "WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n");
1711 *MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1);
1713 if (*VInitPreFill > 1.0)
1714 MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight;
1716 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1)
1720 return *MaxNumSwath * SwathHeight + MaxPartialSwath;
1723 static unsigned int CalculateVMAndRowBytes(
1724 struct display_mode_lib *mode_lib,
1726 unsigned int BlockHeight256Bytes,
1727 unsigned int BlockWidth256Bytes,
1728 enum source_format_class SourcePixelFormat,
1729 unsigned int SurfaceTiling,
1730 unsigned int BytePerPixel,
1731 enum scan_direction_class ScanDirection,
1732 unsigned int SwathWidth,
1733 unsigned int ViewportHeight,
1736 unsigned int HostVMMaxNonCachedPageTableLevels,
1737 unsigned int GPUVMMinPageSize,
1738 unsigned int HostVMMinPageSize,
1739 unsigned int PTEBufferSizeInRequests,
1741 unsigned int DCCMetaPitch,
1742 unsigned int *MacroTileWidth,
1743 unsigned int *MetaRowByte,
1744 unsigned int *PixelPTEBytesPerRow,
1745 bool *PTEBufferSizeNotExceeded,
1746 unsigned int *dpte_row_width_ub,
1747 unsigned int *dpte_row_height,
1748 unsigned int *MetaRequestWidth,
1749 unsigned int *MetaRequestHeight,
1750 unsigned int *meta_row_width,
1751 unsigned int *meta_row_height,
1752 unsigned int *vm_group_bytes,
1753 unsigned int *dpte_group_bytes,
1754 unsigned int *PixelPTEReqWidth,
1755 unsigned int *PixelPTEReqHeight,
1756 unsigned int *PTERequestSize,
1757 unsigned int *DPDE0BytesFrame,
1758 unsigned int *MetaPTEBytesFrame)
1760 unsigned int MPDEBytesFrame = 0;
1761 unsigned int DCCMetaSurfaceBytes = 0;
1762 unsigned int MacroTileSizeBytes = 0;
1763 unsigned int MacroTileHeight = 0;
1764 unsigned int ExtraDPDEBytesFrame = 0;
1765 unsigned int PDEAndMetaPTEBytesFrame = 0;
1766 unsigned int PixelPTEReqHeightPTEs = 0;
1767 unsigned int HostVMDynamicLevels = 0;
1769 double FractionOfPTEReturnDrop;
1771 if (GPUVMEnable == true && HostVMEnable == true) {
1772 if (HostVMMinPageSize < 2048) {
1773 HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
1774 } else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) {
1775 HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
1777 HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
1781 *MetaRequestHeight = 8 * BlockHeight256Bytes;
1782 *MetaRequestWidth = 8 * BlockWidth256Bytes;
1783 if (ScanDirection != dm_vert) {
1784 *meta_row_height = *MetaRequestHeight;
1785 *meta_row_width = dml_ceil((double) SwathWidth - 1, *MetaRequestWidth)
1786 + *MetaRequestWidth;
1787 *MetaRowByte = *meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0;
1789 *meta_row_height = *MetaRequestWidth;
1790 *meta_row_width = dml_ceil((double) SwathWidth - 1, *MetaRequestHeight)
1791 + *MetaRequestHeight;
1792 *MetaRowByte = *meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0;
1794 DCCMetaSurfaceBytes = DCCMetaPitch * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes)
1795 + 64 * BlockHeight256Bytes) * BytePerPixel / 256;
1796 if (GPUVMEnable == true) {
1797 *MetaPTEBytesFrame = (dml_ceil((double) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / (8 * 4.0 * 1024), 1) + 1) * 64;
1798 MPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 1);
1800 *MetaPTEBytesFrame = 0;
1804 if (DCCEnable != true) {
1805 *MetaPTEBytesFrame = 0;
1810 if (SurfaceTiling == dm_sw_linear) {
1811 MacroTileSizeBytes = 256;
1812 MacroTileHeight = BlockHeight256Bytes;
1814 MacroTileSizeBytes = 65536;
1815 MacroTileHeight = 16 * BlockHeight256Bytes;
1817 *MacroTileWidth = MacroTileSizeBytes / BytePerPixel / MacroTileHeight;
1819 if (GPUVMEnable == true && mode_lib->vba.GPUVMMaxPageTableLevels > 1) {
1820 if (ScanDirection != dm_vert) {
1821 *DPDE0BytesFrame = 64 * (dml_ceil(((Pitch * (dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), 1) + 1);
1823 *DPDE0BytesFrame = 64 * (dml_ceil(((Pitch * (dml_ceil((double) SwathWidth - 1, MacroTileHeight) + MacroTileHeight) * BytePerPixel) - MacroTileSizeBytes) / (8 * 2097152), 1) + 1);
1825 ExtraDPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 2);
1827 *DPDE0BytesFrame = 0;
1828 ExtraDPDEBytesFrame = 0;
1831 PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame
1832 + ExtraDPDEBytesFrame;
1834 if (HostVMEnable == true) {
1835 PDEAndMetaPTEBytesFrame = PDEAndMetaPTEBytesFrame * (1 + 8 * HostVMDynamicLevels);
1838 if (SurfaceTiling == dm_sw_linear) {
1839 PixelPTEReqHeightPTEs = 1;
1840 *PixelPTEReqHeight = 1;
1841 *PixelPTEReqWidth = 32768.0 / BytePerPixel;
1842 *PTERequestSize = 64;
1843 FractionOfPTEReturnDrop = 0;
1844 } else if (MacroTileSizeBytes == 4096) {
1845 PixelPTEReqHeightPTEs = 1;
1846 *PixelPTEReqHeight = MacroTileHeight;
1847 *PixelPTEReqWidth = 8 * *MacroTileWidth;
1848 *PTERequestSize = 64;
1849 if (ScanDirection != dm_vert)
1850 FractionOfPTEReturnDrop = 0;
1852 FractionOfPTEReturnDrop = 7 / 8;
1853 } else if (GPUVMMinPageSize == 4 && MacroTileSizeBytes > 4096) {
1854 PixelPTEReqHeightPTEs = 16;
1855 *PixelPTEReqHeight = 16 * BlockHeight256Bytes;
1856 *PixelPTEReqWidth = 16 * BlockWidth256Bytes;
1857 *PTERequestSize = 128;
1858 FractionOfPTEReturnDrop = 0;
1860 PixelPTEReqHeightPTEs = 1;
1861 *PixelPTEReqHeight = MacroTileHeight;
1862 *PixelPTEReqWidth = 8 * *MacroTileWidth;
1863 *PTERequestSize = 64;
1864 FractionOfPTEReturnDrop = 0;
1867 if (SurfaceTiling == dm_sw_linear) {
1868 *dpte_row_height = dml_min(128, 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
1869 *dpte_row_width_ub = (dml_ceil(((double) SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth;
1870 *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
1871 } else if (ScanDirection != dm_vert) {
1872 *dpte_row_height = *PixelPTEReqHeight;
1873 *dpte_row_width_ub = (dml_ceil((double) (SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth;
1874 *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
1876 *dpte_row_height = dml_min(*PixelPTEReqWidth, *MacroTileWidth);
1877 *dpte_row_width_ub = (dml_ceil((double) (SwathWidth - 1) / *PixelPTEReqHeight, 1) + 1) * *PixelPTEReqHeight;
1878 *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqHeight * *PTERequestSize;
1880 if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop)
1881 <= 64 * PTEBufferSizeInRequests) {
1882 *PTEBufferSizeNotExceeded = true;
1884 *PTEBufferSizeNotExceeded = false;
1887 if (GPUVMEnable != true) {
1888 *PixelPTEBytesPerRow = 0;
1889 *PTEBufferSizeNotExceeded = true;
1891 dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n", *MetaPTEBytesFrame);
1893 if (HostVMEnable == true) {
1894 *PixelPTEBytesPerRow = *PixelPTEBytesPerRow * (1 + 8 * HostVMDynamicLevels);
1897 if (HostVMEnable == true) {
1898 *vm_group_bytes = 512;
1899 *dpte_group_bytes = 512;
1900 } else if (GPUVMEnable == true) {
1901 *vm_group_bytes = 2048;
1902 if (SurfaceTiling != dm_sw_linear && PixelPTEReqHeightPTEs == 1 && ScanDirection == dm_vert) {
1903 *dpte_group_bytes = 512;
1905 *dpte_group_bytes = 2048;
1908 *vm_group_bytes = 0;
1909 *dpte_group_bytes = 0;
1912 return PDEAndMetaPTEBytesFrame;
1915 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
1916 struct display_mode_lib *mode_lib)
1918 struct vba_vars_st *v = &mode_lib->vba;
1920 long ReorderBytes = 0;
1921 unsigned int PrefetchMode = v->PrefetchModePerState[v->VoltageLevel][v->maxMpcComb];
1922 double MaxTotalRDBandwidth = 0;
1923 double MaxTotalRDBandwidthNoUrgentBurst = 0;
1924 bool DestinationLineTimesForPrefetchLessThan2 = false;
1925 bool VRatioPrefetchMoreThan4 = false;
1928 v->WritebackDISPCLK = 0.0;
1929 v->DISPCLKWithRamping = 0;
1930 v->DISPCLKWithoutRamping = 0;
1931 v->GlobalDPPCLK = 0.0;
1932 /* DAL custom code: need to update ReturnBW in case min dcfclk is overriden */
1933 v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] = dml_min3(
1934 v->ReturnBusWidth * v->DCFCLK,
1935 v->DRAMSpeedPerState[v->VoltageLevel] * v->NumberOfChannels * v->DRAMChannelWidth,
1936 v->FabricClockPerState[v->VoltageLevel] * v->FabricDatapathToDCNDataReturn);
1937 if (v->HostVMEnable != true) {
1938 v->ReturnBW = v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
1940 v->ReturnBW = v->IdealSDPPortBandwidthPerState[v->VoltageLevel][v->maxMpcComb] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / 100;
1942 /* End DAL custom code */
1944 // DISPCLK and DPPCLK Calculation
1946 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
1947 if (v->WritebackEnable[k]) {
1948 v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
1949 dml30_CalculateWriteBackDISPCLK(
1950 v->WritebackPixelFormat[k],
1952 v->WritebackHRatio[k],
1953 v->WritebackVRatio[k],
1954 v->WritebackHTaps[k],
1955 v->WritebackVTaps[k],
1956 v->WritebackSourceWidth[k],
1957 v->WritebackDestinationWidth[k],
1959 v->WritebackLineBufferSize));
1963 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
1964 if (v->HRatio[k] > 1) {
1965 v->PSCL_THROUGHPUT_LUMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
1966 v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(v->htaps[k] / 6.0, 1));
1968 v->PSCL_THROUGHPUT_LUMA[k] = dml_min(
1969 v->MaxDCHUBToPSCLThroughput,
1970 v->MaxPSCLToLBThroughput);
1973 v->DPPCLKUsingSingleDPPLuma = v->PixelClock[k]
1974 * dml_max(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]),
1975 dml_max(v->HRatio[k] * v->VRatio[k] / v->PSCL_THROUGHPUT_LUMA[k], 1.0));
1977 if ((v->htaps[k] > 6 || v->vtaps[k] > 6)
1978 && v->DPPCLKUsingSingleDPPLuma < 2 * v->PixelClock[k]) {
1979 v->DPPCLKUsingSingleDPPLuma = 2 * v->PixelClock[k];
1982 if ((v->SourcePixelFormat[k] != dm_420_8
1983 && v->SourcePixelFormat[k] != dm_420_10
1984 && v->SourcePixelFormat[k] != dm_420_12
1985 && v->SourcePixelFormat[k] != dm_rgbe_alpha)) {
1986 v->PSCL_THROUGHPUT_CHROMA[k] = 0.0;
1987 v->DPPCLKUsingSingleDPP[k] = v->DPPCLKUsingSingleDPPLuma;
1989 if (v->HRatioChroma[k] > 1) {
1990 v->PSCL_THROUGHPUT_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
1991 v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(v->HTAPsChroma[k] / 6.0, 1.0));
1993 v->PSCL_THROUGHPUT_CHROMA[k] = dml_min(
1994 v->MaxDCHUBToPSCLThroughput,
1995 v->MaxPSCLToLBThroughput);
1997 v->DPPCLKUsingSingleDPPChroma = v->PixelClock[k]
1998 * dml_max3(v->VTAPsChroma[k] / 6.0 * dml_min(1.0, v->HRatioChroma[k]),
1999 v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_THROUGHPUT_CHROMA[k], 1.0);
2001 if ((v->HTAPsChroma[k] > 6 || v->VTAPsChroma[k] > 6)
2002 && v->DPPCLKUsingSingleDPPChroma
2003 < 2 * v->PixelClock[k]) {
2004 v->DPPCLKUsingSingleDPPChroma = 2
2008 v->DPPCLKUsingSingleDPP[k] = dml_max(
2009 v->DPPCLKUsingSingleDPPLuma,
2010 v->DPPCLKUsingSingleDPPChroma);
2014 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2015 if (v->BlendingAndTiming[k] != k)
2017 if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_4to1) {
2018 v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
2019 v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
2020 * (1 + v->DISPCLKRampingMargin / 100));
2021 v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
2022 v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
2023 } else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2024 v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
2025 v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
2026 * (1 + v->DISPCLKRampingMargin / 100));
2027 v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
2028 v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
2030 v->DISPCLKWithRamping = dml_max(v->DISPCLKWithRamping,
2031 v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100)
2032 * (1 + v->DISPCLKRampingMargin / 100));
2033 v->DISPCLKWithoutRamping = dml_max(v->DISPCLKWithoutRamping,
2034 v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100));
2038 v->DISPCLKWithRamping = dml_max(
2039 v->DISPCLKWithRamping,
2040 v->WritebackDISPCLK);
2041 v->DISPCLKWithoutRamping = dml_max(
2042 v->DISPCLKWithoutRamping,
2043 v->WritebackDISPCLK);
2045 ASSERT(v->DISPCLKDPPCLKVCOSpeed != 0);
2046 v->DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
2047 v->DISPCLKWithRamping,
2048 v->DISPCLKDPPCLKVCOSpeed);
2049 v->DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
2050 v->DISPCLKWithoutRamping,
2051 v->DISPCLKDPPCLKVCOSpeed);
2052 v->MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown(
2053 v->soc.clock_limits[mode_lib->soc.num_states].dispclk_mhz,
2054 v->DISPCLKDPPCLKVCOSpeed);
2055 if (v->DISPCLKWithoutRampingRoundedToDFSGranularity
2056 > v->MaxDispclkRoundedToDFSGranularity) {
2057 v->DISPCLK_calculated =
2058 v->DISPCLKWithoutRampingRoundedToDFSGranularity;
2059 } else if (v->DISPCLKWithRampingRoundedToDFSGranularity
2060 > v->MaxDispclkRoundedToDFSGranularity) {
2061 v->DISPCLK_calculated = v->MaxDispclkRoundedToDFSGranularity;
2063 v->DISPCLK_calculated =
2064 v->DISPCLKWithRampingRoundedToDFSGranularity;
2066 v->DISPCLK = v->DISPCLK_calculated;
2067 DTRACE(" dispclk_mhz (calculated) = %f", v->DISPCLK_calculated);
2069 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2070 v->DPPCLK_calculated[k] = v->DPPCLKUsingSingleDPP[k]
2072 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2073 v->GlobalDPPCLK = dml_max(
2075 v->DPPCLK_calculated[k]);
2077 v->GlobalDPPCLK = RoundToDFSGranularityUp(
2079 v->DISPCLKDPPCLKVCOSpeed);
2080 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2081 v->DPPCLK_calculated[k] = v->GlobalDPPCLK / 255
2083 v->DPPCLK_calculated[k] * 255.0
2086 DTRACE(" dppclk_mhz[%i] (calculated) = %f", k, v->DPPCLK_calculated[k]);
2087 v->DPPCLK[k] = v->DPPCLK_calculated[k];
2090 // Urgent and B P-State/DRAM Clock Change Watermark
2091 DTRACE(" dcfclk_mhz = %f", v->DCFCLK);
2092 DTRACE(" return_bus_bw = %f", v->ReturnBW);
2094 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2095 CalculateBytePerPixelAnd256BBlockSizes(
2096 v->SourcePixelFormat[k],
2097 v->SurfaceTiling[k],
2098 &v->BytePerPixelY[k],
2099 &v->BytePerPixelC[k],
2100 &v->BytePerPixelDETY[k],
2101 &v->BytePerPixelDETC[k],
2102 &v->BlockHeight256BytesY[k],
2103 &v->BlockHeight256BytesC[k],
2104 &v->BlockWidth256BytesY[k],
2105 &v->BlockWidth256BytesC[k]);
2108 CalculateSwathWidth(
2110 v->NumberOfActivePlanes,
2111 v->SourcePixelFormat,
2119 v->ODMCombineEnabled,
2122 v->BlockHeight256BytesY,
2123 v->BlockHeight256BytesC,
2124 v->BlockWidth256BytesY,
2125 v->BlockWidth256BytesC,
2126 v->BlendingAndTiming,
2130 v->SwathWidthSingleDPPY,
2131 v->SwathWidthSingleDPPC,
2136 v->swath_width_luma_ub,
2137 v->swath_width_chroma_ub);
2140 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2141 v->ReadBandwidthPlaneLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k] / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
2142 v->ReadBandwidthPlaneChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k] / (v->HTotal[k] / v->PixelClock[k]) * v->VRatioChroma[k];
2143 DTRACE("read_bw[%i] = %fBps", k, v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k]);
2147 // DCFCLK Deep Sleep
2148 CalculateDCFCLKDeepSleep(
2150 v->NumberOfActivePlanes,
2161 v->PSCL_THROUGHPUT_LUMA,
2162 v->PSCL_THROUGHPUT_CHROMA,
2164 v->ReadBandwidthPlaneLuma,
2165 v->ReadBandwidthPlaneChroma,
2167 &v->DCFCLKDeepSleep);
2170 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2171 if ((v->BlendingAndTiming[k] != k) || !v->DSCEnabled[k]) {
2172 v->DSCCLK_calculated[k] = 0.0;
2174 if (v->OutputFormat[k] == dm_420)
2175 v->DSCFormatFactor = 2;
2176 else if (v->OutputFormat[k] == dm_444)
2177 v->DSCFormatFactor = 1;
2178 else if (v->OutputFormat[k] == dm_n422)
2179 v->DSCFormatFactor = 2;
2181 v->DSCFormatFactor = 1;
2182 if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
2183 v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 12
2184 / v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2185 else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
2186 v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 6
2187 / v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2189 v->DSCCLK_calculated[k] = v->PixelClockBackEnd[k] / 3
2190 / v->DSCFormatFactor / (1 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100);
2195 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2196 double BPP = v->OutputBppPerState[k][v->VoltageLevel];
2198 if (v->DSCEnabled[k] && BPP != 0) {
2199 if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_disabled) {
2200 v->DSCDelay[k] = dscceComputeDelay(v->DSCInputBitPerComponent[k],
2202 dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2203 v->NumberOfDSCSlices[k],
2206 + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2207 } else if (v->ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2208 v->DSCDelay[k] = 2 * dscceComputeDelay(v->DSCInputBitPerComponent[k],
2210 dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2211 v->NumberOfDSCSlices[k] / 2.0,
2214 + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2216 v->DSCDelay[k] = 4 * dscceComputeDelay(v->DSCInputBitPerComponent[k],
2218 dml_ceil((double) v->HActive[k] / v->NumberOfDSCSlices[k], 1),
2219 v->NumberOfDSCSlices[k] / 4.0,
2222 + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
2224 v->DSCDelay[k] = v->DSCDelay[k] * v->PixelClock[k] / v->PixelClockBackEnd[k];
2230 for (k = 0; k < v->NumberOfActivePlanes; ++k)
2231 for (j = 0; j < v->NumberOfActivePlanes; ++j) // NumberOfPlanes
2232 if (j != k && v->BlendingAndTiming[k] == j
2233 && v->DSCEnabled[j])
2234 v->DSCDelay[k] = v->DSCDelay[j];
2237 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2238 unsigned int PDEAndMetaPTEBytesFrameY = 0;
2239 unsigned int PixelPTEBytesPerRowY = 0;
2240 unsigned int MetaRowByteY = 0;
2241 unsigned int MetaRowByteC = 0;
2242 unsigned int PDEAndMetaPTEBytesFrameC = 0;
2243 unsigned int PixelPTEBytesPerRowC = 0;
2244 bool PTEBufferSizeNotExceededY = 0;
2245 bool PTEBufferSizeNotExceededC = 0;
2248 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) {
2249 if ((v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) && v->SourceScan[k] != dm_vert) {
2250 v->PTEBufferSizeInRequestsForLuma = (v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma) / 2;
2251 v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsForLuma;
2253 v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma;
2254 v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsChroma;
2257 PDEAndMetaPTEBytesFrameC = CalculateVMAndRowBytes(
2260 v->BlockHeight256BytesC[k],
2261 v->BlockWidth256BytesC[k],
2262 v->SourcePixelFormat[k],
2263 v->SurfaceTiling[k],
2264 v->BytePerPixelC[k],
2267 v->ViewportHeightChroma[k],
2270 v->HostVMMaxNonCachedPageTableLevels,
2271 v->GPUVMMinPageSize,
2272 v->HostVMMinPageSize,
2273 v->PTEBufferSizeInRequestsForChroma,
2275 v->DCCMetaPitchC[k],
2276 &v->MacroTileWidthC[k],
2278 &PixelPTEBytesPerRowC,
2279 &PTEBufferSizeNotExceededC,
2280 &v->dpte_row_width_chroma_ub[k],
2281 &v->dpte_row_height_chroma[k],
2282 &v->meta_req_width_chroma[k],
2283 &v->meta_req_height_chroma[k],
2284 &v->meta_row_width_chroma[k],
2285 &v->meta_row_height_chroma[k],
2288 &v->PixelPTEReqWidthC[k],
2289 &v->PixelPTEReqHeightC[k],
2290 &v->PTERequestSizeC[k],
2291 &v->dpde0_bytes_per_frame_ub_c[k],
2292 &v->meta_pte_bytes_per_frame_ub_c[k]);
2294 v->PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(
2299 v->ProgressiveToInterlaceUnitInOPP,
2301 v->ViewportYStartC[k],
2302 &v->VInitPreFillC[k],
2303 &v->MaxNumSwathC[k]);
2305 v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma;
2306 v->PTEBufferSizeInRequestsForChroma = 0;
2307 PixelPTEBytesPerRowC = 0;
2308 PDEAndMetaPTEBytesFrameC = 0;
2310 v->MaxNumSwathC[k] = 0;
2311 v->PrefetchSourceLinesC[k] = 0;
2314 PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
2317 v->BlockHeight256BytesY[k],
2318 v->BlockWidth256BytesY[k],
2319 v->SourcePixelFormat[k],
2320 v->SurfaceTiling[k],
2321 v->BytePerPixelY[k],
2324 v->ViewportHeight[k],
2327 v->HostVMMaxNonCachedPageTableLevels,
2328 v->GPUVMMinPageSize,
2329 v->HostVMMinPageSize,
2330 v->PTEBufferSizeInRequestsForLuma,
2332 v->DCCMetaPitchY[k],
2333 &v->MacroTileWidthY[k],
2335 &PixelPTEBytesPerRowY,
2336 &PTEBufferSizeNotExceededY,
2337 &v->dpte_row_width_luma_ub[k],
2338 &v->dpte_row_height[k],
2339 &v->meta_req_width[k],
2340 &v->meta_req_height[k],
2341 &v->meta_row_width[k],
2342 &v->meta_row_height[k],
2343 &v->vm_group_bytes[k],
2344 &v->dpte_group_bytes[k],
2345 &v->PixelPTEReqWidthY[k],
2346 &v->PixelPTEReqHeightY[k],
2347 &v->PTERequestSizeY[k],
2348 &v->dpde0_bytes_per_frame_ub_l[k],
2349 &v->meta_pte_bytes_per_frame_ub_l[k]);
2351 v->PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
2356 v->ProgressiveToInterlaceUnitInOPP,
2358 v->ViewportYStartY[k],
2359 &v->VInitPreFillY[k],
2360 &v->MaxNumSwathY[k]);
2361 v->PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC;
2362 v->PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY
2363 + PDEAndMetaPTEBytesFrameC;
2364 v->MetaRowByte[k] = MetaRowByteY + MetaRowByteC;
2366 CalculateRowBandwidth(
2368 v->SourcePixelFormat[k],
2372 v->HTotal[k] / v->PixelClock[k],
2375 v->meta_row_height[k],
2376 v->meta_row_height_chroma[k],
2377 PixelPTEBytesPerRowY,
2378 PixelPTEBytesPerRowC,
2379 v->dpte_row_height[k],
2380 v->dpte_row_height_chroma[k],
2382 &v->dpte_row_bw[k]);
2385 v->TotalDCCActiveDPP = 0;
2386 v->TotalActiveDPP = 0;
2387 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2388 v->TotalActiveDPP = v->TotalActiveDPP
2389 + v->DPPPerPlane[k];
2390 if (v->DCCEnable[k])
2391 v->TotalDCCActiveDPP = v->TotalDCCActiveDPP
2392 + v->DPPPerPlane[k];
2396 ReorderBytes = v->NumberOfChannels * dml_max3(
2397 v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2398 v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2399 v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
2401 v->UrgentExtraLatency = CalculateExtraLatency(
2402 v->RoundTripPingLatencyCycles,
2406 v->PixelChunkSizeInKByte,
2407 v->TotalDCCActiveDPP,
2412 v->NumberOfActivePlanes,
2414 v->dpte_group_bytes,
2415 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2416 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2417 v->HostVMMinPageSize,
2418 v->HostVMMaxNonCachedPageTableLevels);
2420 v->TCalc = 24.0 / v->DCFCLKDeepSleep;
2422 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2423 if (v->BlendingAndTiming[k] == k) {
2424 if (v->WritebackEnable[k] == true) {
2425 v->WritebackDelay[v->VoltageLevel][k] = v->WritebackLatency +
2426 CalculateWriteBackDelay(v->WritebackPixelFormat[k],
2427 v->WritebackHRatio[k],
2428 v->WritebackVRatio[k],
2429 v->WritebackVTaps[k],
2430 v->WritebackDestinationWidth[k],
2431 v->WritebackDestinationHeight[k],
2432 v->WritebackSourceHeight[k],
2433 v->HTotal[k]) / v->DISPCLK;
2435 v->WritebackDelay[v->VoltageLevel][k] = 0;
2436 for (j = 0; j < v->NumberOfActivePlanes; ++j) {
2437 if (v->BlendingAndTiming[j] == k
2438 && v->WritebackEnable[j] == true) {
2439 v->WritebackDelay[v->VoltageLevel][k] = dml_max(v->WritebackDelay[v->VoltageLevel][k],
2440 v->WritebackLatency + CalculateWriteBackDelay(
2441 v->WritebackPixelFormat[j],
2442 v->WritebackHRatio[j],
2443 v->WritebackVRatio[j],
2444 v->WritebackVTaps[j],
2445 v->WritebackDestinationWidth[j],
2446 v->WritebackDestinationHeight[j],
2447 v->WritebackSourceHeight[j],
2448 v->HTotal[k]) / v->DISPCLK);
2454 for (k = 0; k < v->NumberOfActivePlanes; ++k)
2455 for (j = 0; j < v->NumberOfActivePlanes; ++j)
2456 if (v->BlendingAndTiming[k] == j)
2457 v->WritebackDelay[v->VoltageLevel][k] = v->WritebackDelay[v->VoltageLevel][j];
2459 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2460 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));
2463 v->MaximumMaxVStartupLines = 0;
2464 for (k = 0; k < v->NumberOfActivePlanes; ++k)
2465 v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);
2467 if (v->DRAMClockChangeLatencyOverride > 0.0) {
2468 v->FinalDRAMClockChangeLatency = v->DRAMClockChangeLatencyOverride;
2470 v->FinalDRAMClockChangeLatency = v->DRAMClockChangeLatency;
2472 v->UrgentLatency = CalculateUrgentLatency(v->UrgentLatencyPixelDataOnly, v->UrgentLatencyPixelMixedWithVMData, v->UrgentLatencyVMDataOnly, v->DoUrgentLatencyAdjustment, v->UrgentLatencyAdjustmentFabricClockComponent, v->UrgentLatencyAdjustmentFabricClockReference, v->FabricClock);
2475 v->FractionOfUrgentBandwidth = 0.0;
2476 v->FractionOfUrgentBandwidthImmediateFlip = 0.0;
2478 v->VStartupLines = 13;
2481 MaxTotalRDBandwidth = 0;
2482 MaxTotalRDBandwidthNoUrgentBurst = 0;
2483 DestinationLineTimesForPrefetchLessThan2 = false;
2484 VRatioPrefetchMoreThan4 = false;
2485 TWait = CalculateTWait(
2487 v->FinalDRAMClockChangeLatency,
2489 v->SREnterPlusExitTime);
2491 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2492 Pipe myPipe = { 0 };
2494 myPipe.DPPCLK = v->DPPCLK[k];
2495 myPipe.DISPCLK = v->DISPCLK;
2496 myPipe.PixelClock = v->PixelClock[k];
2497 myPipe.DCFCLKDeepSleep = v->DCFCLKDeepSleep;
2498 myPipe.DPPPerPlane = v->DPPPerPlane[k];
2499 myPipe.ScalerEnabled = v->ScalerEnabled[k];
2500 myPipe.SourceScan = v->SourceScan[k];
2501 myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
2502 myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
2503 myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
2504 myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
2505 myPipe.InterlaceEnable = v->Interlace[k];
2506 myPipe.NumberOfCursors = v->NumberOfCursors[k];
2507 myPipe.VBlank = v->VTotal[k] - v->VActive[k];
2508 myPipe.HTotal = v->HTotal[k];
2509 myPipe.DCCEnable = v->DCCEnable[k];
2510 myPipe.ODMCombineEnabled = !!v->ODMCombineEnabled[k];
2512 v->ErrorResult[k] = CalculatePrefetchSchedule(
2514 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2515 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2518 v->DPPCLKDelaySubtotal
2519 + v->DPPCLKDelayCNVCFormater,
2521 v->DPPCLKDelaySCLLBOnly,
2522 v->DPPCLKDelayCNVCCursor,
2523 v->DISPCLKDelaySubtotal,
2524 (unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
2526 v->MaxInterDCNTileRepeaters,
2527 dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
2528 v->MaxVStartupLines[k],
2529 v->GPUVMMaxPageTableLevels,
2532 v->HostVMMaxNonCachedPageTableLevels,
2533 v->HostVMMinPageSize,
2534 v->DynamicMetadataEnable[k],
2535 v->DynamicMetadataVMEnabled,
2536 v->DynamicMetadataLinesBeforeActiveRequired[k],
2537 v->DynamicMetadataTransmittedBytes[k],
2539 v->UrgentExtraLatency,
2541 v->PDEAndMetaPTEBytesFrame[k],
2543 v->PixelPTEBytesPerRow[k],
2544 v->PrefetchSourceLinesY[k],
2546 v->BytePerPixelY[k],
2547 v->VInitPreFillY[k],
2549 v->PrefetchSourceLinesC[k],
2551 v->BytePerPixelC[k],
2552 v->VInitPreFillC[k],
2554 v->swath_width_luma_ub[k],
2555 v->swath_width_chroma_ub[k],
2559 v->ProgressiveToInterlaceUnitInOPP,
2560 &v->DSTXAfterScaler[k],
2561 &v->DSTYAfterScaler[k],
2562 &v->DestinationLinesForPrefetch[k],
2563 &v->PrefetchBandwidth[k],
2564 &v->DestinationLinesToRequestVMInVBlank[k],
2565 &v->DestinationLinesToRequestRowInVBlank[k],
2566 &v->VRatioPrefetchY[k],
2567 &v->VRatioPrefetchC[k],
2568 &v->RequiredPrefetchPixDataBWLuma[k],
2569 &v->RequiredPrefetchPixDataBWChroma[k],
2570 &v->NotEnoughTimeForDynamicMetadata[k],
2572 &v->prefetch_vmrow_bw[k],
2575 &v->VUpdateOffsetPix[k],
2576 &v->VUpdateWidthPix[k],
2577 &v->VReadyOffsetPix[k]);
2578 if (v->BlendingAndTiming[k] == k) {
2579 double TotalRepeaterDelayTime = v->MaxInterDCNTileRepeaters * (2 / v->DPPCLK[k] + 3 / v->DISPCLK);
2580 v->VUpdateWidthPix[k] = (14 / v->DCFCLKDeepSleep + 12 / v->DPPCLK[k] + TotalRepeaterDelayTime) * v->PixelClock[k];
2581 v->VReadyOffsetPix[k] = dml_max(150.0 / v->DPPCLK[k], TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[k];
2582 v->VUpdateOffsetPix[k] = dml_ceil(v->HTotal[k] / 4.0, 1);
2583 v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
2585 int x = v->BlendingAndTiming[k];
2586 double TotalRepeaterDelayTime = v->MaxInterDCNTileRepeaters * (2 / v->DPPCLK[k] + 3 / v->DISPCLK);
2587 v->VUpdateWidthPix[k] = (14 / v->DCFCLKDeepSleep + 12 / v->DPPCLK[k] + TotalRepeaterDelayTime) * v->PixelClock[x];
2588 v->VReadyOffsetPix[k] = dml_max(150.0 / v->DPPCLK[k], TotalRepeaterDelayTime + 20 / v->DCFCLKDeepSleep + 10 / v->DPPCLK[k]) * v->PixelClock[x];
2589 v->VUpdateOffsetPix[k] = dml_ceil(v->HTotal[x] / 4.0, 1);
2590 if (!v->MaxVStartupLines[x])
2591 v->MaxVStartupLines[x] = v->MaxVStartupLines[k];
2592 v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[x]);
2596 v->NotEnoughUrgentLatencyHiding = false;
2597 v->NotEnoughUrgentLatencyHidingPre = false;
2599 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2600 v->cursor_bw[k] = v->NumberOfCursors[k]
2601 * v->CursorWidth[k][0] * v->CursorBPP[k][0]
2603 / (v->HTotal[k] / v->PixelClock[k])
2605 v->cursor_bw_pre[k] = v->NumberOfCursors[k]
2606 * v->CursorWidth[k][0] * v->CursorBPP[k][0]
2608 / (v->HTotal[k] / v->PixelClock[k])
2609 * v->VRatioPrefetchY[k];
2611 CalculateUrgentBurstFactor(
2612 v->swath_width_luma_ub[k],
2613 v->swath_width_chroma_ub[k],
2614 v->DETBufferSizeInKByte,
2617 v->HTotal[k] / v->PixelClock[k],
2619 v->CursorBufferSize,
2620 v->CursorWidth[k][0],
2624 v->BytePerPixelDETY[k],
2625 v->BytePerPixelDETC[k],
2626 v->DETBufferSizeY[k],
2627 v->DETBufferSizeC[k],
2628 &v->UrgentBurstFactorCursor[k],
2629 &v->UrgentBurstFactorLuma[k],
2630 &v->UrgentBurstFactorChroma[k],
2631 &v->NoUrgentLatencyHiding[k]);
2633 CalculateUrgentBurstFactor(
2634 v->swath_width_luma_ub[k],
2635 v->swath_width_chroma_ub[k],
2636 v->DETBufferSizeInKByte,
2639 v->HTotal[k] / v->PixelClock[k],
2641 v->CursorBufferSize,
2642 v->CursorWidth[k][0],
2644 v->VRatioPrefetchY[k],
2645 v->VRatioPrefetchC[k],
2646 v->BytePerPixelDETY[k],
2647 v->BytePerPixelDETC[k],
2648 v->DETBufferSizeY[k],
2649 v->DETBufferSizeC[k],
2650 &v->UrgentBurstFactorCursorPre[k],
2651 &v->UrgentBurstFactorLumaPre[k],
2652 &v->UrgentBurstFactorChromaPre[k],
2653 &v->NoUrgentLatencyHidingPre[k]);
2655 MaxTotalRDBandwidth = MaxTotalRDBandwidth +
2656 dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2657 v->ReadBandwidthPlaneLuma[k] *
2658 v->UrgentBurstFactorLuma[k] +
2659 v->ReadBandwidthPlaneChroma[k] *
2660 v->UrgentBurstFactorChroma[k] +
2662 v->UrgentBurstFactorCursor[k] +
2663 v->DPPPerPlane[k] * (v->meta_row_bw[k] + v->dpte_row_bw[k]),
2664 v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2665 v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) + v->cursor_bw_pre[k] *
2666 v->UrgentBurstFactorCursorPre[k]);
2668 MaxTotalRDBandwidthNoUrgentBurst = MaxTotalRDBandwidthNoUrgentBurst +
2669 dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2670 v->ReadBandwidthPlaneLuma[k] +
2671 v->ReadBandwidthPlaneChroma[k] +
2673 v->DPPPerPlane[k] * (v->meta_row_bw[k] + v->dpte_row_bw[k]),
2674 v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] + v->RequiredPrefetchPixDataBWChroma[k]) + v->cursor_bw_pre[k]);
2676 if (v->DestinationLinesForPrefetch[k] < 2)
2677 DestinationLineTimesForPrefetchLessThan2 = true;
2678 if (v->VRatioPrefetchY[k] > 4 || v->VRatioPrefetchC[k] > 4)
2679 VRatioPrefetchMoreThan4 = true;
2680 if (v->NoUrgentLatencyHiding[k] == true)
2681 v->NotEnoughUrgentLatencyHiding = true;
2683 if (v->NoUrgentLatencyHidingPre[k] == true)
2684 v->NotEnoughUrgentLatencyHidingPre = true;
2686 v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / v->ReturnBW;
2689 if (MaxTotalRDBandwidth <= v->ReturnBW && v->NotEnoughUrgentLatencyHiding == 0 && v->NotEnoughUrgentLatencyHidingPre == 0 && !VRatioPrefetchMoreThan4
2690 && !DestinationLineTimesForPrefetchLessThan2)
2691 v->PrefetchModeSupported = true;
2693 v->PrefetchModeSupported = false;
2694 dml_print("DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n");
2695 dml_print("DML: MaxTotalRDBandwidth:%f AvailReturnBandwidth:%f\n", MaxTotalRDBandwidth, v->ReturnBW);
2696 dml_print("DML: VRatioPrefetch %s more than 4\n", (VRatioPrefetchMoreThan4) ? "is" : "is not");
2697 dml_print("DML: DestinationLines for Prefetch %s less than 2\n", (DestinationLineTimesForPrefetchLessThan2) ? "is" : "is not");
2700 if (v->PrefetchModeSupported == true && v->ImmediateFlipSupport == true) {
2701 v->BandwidthAvailableForImmediateFlip = v->ReturnBW;
2702 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2703 v->BandwidthAvailableForImmediateFlip =
2704 v->BandwidthAvailableForImmediateFlip
2706 v->ReadBandwidthPlaneLuma[k] * v->UrgentBurstFactorLuma[k]
2707 + v->ReadBandwidthPlaneChroma[k] * v->UrgentBurstFactorChroma[k]
2708 + v->cursor_bw[k] * v->UrgentBurstFactorCursor[k],
2709 v->DPPPerPlane[k] * (v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2710 v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) +
2711 v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
2714 v->TotImmediateFlipBytes = 0;
2715 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2716 v->TotImmediateFlipBytes = v->TotImmediateFlipBytes + v->DPPPerPlane[k] * (v->PDEAndMetaPTEBytesFrame[k] + v->MetaRowByte[k] + v->PixelPTEBytesPerRow[k]);
2718 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2719 CalculateFlipSchedule(
2721 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
2722 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
2723 v->UrgentExtraLatency,
2725 v->GPUVMMaxPageTableLevels,
2727 v->HostVMMaxNonCachedPageTableLevels,
2729 v->HostVMMinPageSize,
2730 v->PDEAndMetaPTEBytesFrame[k],
2732 v->PixelPTEBytesPerRow[k],
2733 v->BandwidthAvailableForImmediateFlip,
2734 v->TotImmediateFlipBytes,
2735 v->SourcePixelFormat[k],
2736 v->HTotal[k] / v->PixelClock[k],
2741 v->dpte_row_height[k],
2742 v->meta_row_height[k],
2743 v->dpte_row_height_chroma[k],
2744 v->meta_row_height_chroma[k],
2745 &v->DestinationLinesToRequestVMInImmediateFlip[k],
2746 &v->DestinationLinesToRequestRowInImmediateFlip[k],
2747 &v->final_flip_bw[k],
2748 &v->ImmediateFlipSupportedForPipe[k]);
2750 v->total_dcn_read_bw_with_flip = 0.0;
2751 v->total_dcn_read_bw_with_flip_no_urgent_burst = 0.0;
2752 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2753 v->total_dcn_read_bw_with_flip = v->total_dcn_read_bw_with_flip + dml_max3(
2754 v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2755 v->DPPPerPlane[k] * v->final_flip_bw[k] +
2756 v->ReadBandwidthLuma[k] * v->UrgentBurstFactorLuma[k] +
2757 v->ReadBandwidthChroma[k] * v->UrgentBurstFactorChroma[k] +
2758 v->cursor_bw[k] * v->UrgentBurstFactorCursor[k],
2759 v->DPPPerPlane[k] * (v->final_flip_bw[k] +
2760 v->RequiredPrefetchPixDataBWLuma[k] * v->UrgentBurstFactorLumaPre[k] +
2761 v->RequiredPrefetchPixDataBWChroma[k] * v->UrgentBurstFactorChromaPre[k]) +
2762 v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
2763 v->total_dcn_read_bw_with_flip_no_urgent_burst =
2764 v->total_dcn_read_bw_with_flip_no_urgent_burst +
2765 dml_max3(v->DPPPerPlane[k] * v->prefetch_vmrow_bw[k],
2766 v->DPPPerPlane[k] * v->final_flip_bw[k] + v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k] + v->cursor_bw[k],
2767 v->DPPPerPlane[k] * (v->final_flip_bw[k] + v->RequiredPrefetchPixDataBWLuma[k] + v->RequiredPrefetchPixDataBWChroma[k]) + v->cursor_bw_pre[k]);
2770 v->FractionOfUrgentBandwidthImmediateFlip = v->total_dcn_read_bw_with_flip_no_urgent_burst / v->ReturnBW;
2772 v->ImmediateFlipSupported = true;
2773 if (v->total_dcn_read_bw_with_flip > v->ReturnBW) {
2774 v->ImmediateFlipSupported = false;
2775 v->total_dcn_read_bw_with_flip = MaxTotalRDBandwidth;
2777 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2778 if (v->ImmediateFlipSupportedForPipe[k] == false) {
2779 v->ImmediateFlipSupported = false;
2783 v->ImmediateFlipSupported = false;
2786 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2787 if (v->ErrorResult[k] || v->NotEnoughTimeForDynamicMetadata[k]) {
2788 v->PrefetchModeSupported = false;
2789 dml_print("DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n");
2793 v->VStartupLines = v->VStartupLines + 1;
2794 v->PrefetchAndImmediateFlipSupported = (v->PrefetchModeSupported == true && ((!v->ImmediateFlipSupport && !v->HostVMEnable && v->ImmediateFlipRequirement != dm_immediate_flip_required) || v->ImmediateFlipSupported)) ? true : false;
2796 } while (!v->PrefetchModeSupported && v->VStartupLines <= v->MaximumMaxVStartupLines);
2797 ASSERT(v->PrefetchModeSupported);
2799 //Watermarks and NB P-State/DRAM Clock Change Support
2801 enum clock_change_support DRAMClockChangeSupport = 0; // dummy
2802 CalculateWatermarksAndDRAMSpeedChangeSupport(
2805 v->NumberOfActivePlanes,
2806 v->MaxLineBufferLines,
2808 v->DPPOutputBufferPixels,
2809 v->DETBufferSizeInKByte,
2810 v->WritebackInterfaceBufferSize,
2814 v->dpte_group_bytes,
2817 v->UrgentExtraLatency,
2818 v->WritebackLatency,
2819 v->WritebackChunkSize,
2821 v->FinalDRAMClockChangeLatency,
2823 v->SREnterPlusExitTime,
2843 v->BlendingAndTiming,
2844 v->BytePerPixelDETY,
2845 v->BytePerPixelDETC,
2849 v->WritebackPixelFormat,
2850 v->WritebackDestinationWidth,
2851 v->WritebackDestinationHeight,
2852 v->WritebackSourceHeight,
2853 &DRAMClockChangeSupport,
2854 &v->UrgentWatermark,
2855 &v->WritebackUrgentWatermark,
2856 &v->DRAMClockChangeWatermark,
2857 &v->WritebackDRAMClockChangeWatermark,
2858 &v->StutterExitWatermark,
2859 &v->StutterEnterPlusExitWatermark,
2860 &v->MinActiveDRAMClockChangeLatencySupported);
2862 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2863 if (v->WritebackEnable[k] == true) {
2864 if (v->BlendingAndTiming[k] == k) {
2865 v->ThisVStartup = v->VStartup[k];
2867 for (j = 0; j < v->NumberOfActivePlanes; ++j) {
2868 if (v->BlendingAndTiming[k] == j) {
2869 v->ThisVStartup = v->VStartup[j];
2873 v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
2874 v->ThisVStartup * v->HTotal[k] / v->PixelClock[k] - v->WritebackDRAMClockChangeWatermark);
2876 v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
2883 //Display Pipeline Delivery Time in Prefetch, Groups
2884 CalculatePixelDeliveryTimes(
2885 v->NumberOfActivePlanes,
2890 v->swath_width_luma_ub,
2891 v->swath_width_chroma_ub,
2896 v->PSCL_THROUGHPUT_LUMA,
2897 v->PSCL_THROUGHPUT_CHROMA,
2904 v->BlockWidth256BytesY,
2905 v->BlockHeight256BytesY,
2906 v->BlockWidth256BytesC,
2907 v->BlockHeight256BytesC,
2908 v->DisplayPipeLineDeliveryTimeLuma,
2909 v->DisplayPipeLineDeliveryTimeChroma,
2910 v->DisplayPipeLineDeliveryTimeLumaPrefetch,
2911 v->DisplayPipeLineDeliveryTimeChromaPrefetch,
2912 v->DisplayPipeRequestDeliveryTimeLuma,
2913 v->DisplayPipeRequestDeliveryTimeChroma,
2914 v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
2915 v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
2916 v->CursorRequestDeliveryTime,
2917 v->CursorRequestDeliveryTimePrefetch);
2919 CalculateMetaAndPTETimes(
2920 v->NumberOfActivePlanes,
2923 v->MinMetaChunkSizeBytes,
2927 v->DestinationLinesToRequestRowInVBlank,
2928 v->DestinationLinesToRequestRowInImmediateFlip,
2935 v->dpte_row_height_chroma,
2937 v->meta_row_width_chroma,
2939 v->meta_row_height_chroma,
2941 v->meta_req_width_chroma,
2943 v->meta_req_height_chroma,
2944 v->dpte_group_bytes,
2947 v->PixelPTEReqWidthY,
2948 v->PixelPTEReqHeightY,
2949 v->PixelPTEReqWidthC,
2950 v->PixelPTEReqHeightC,
2951 v->dpte_row_width_luma_ub,
2952 v->dpte_row_width_chroma_ub,
2953 v->DST_Y_PER_PTE_ROW_NOM_L,
2954 v->DST_Y_PER_PTE_ROW_NOM_C,
2955 v->DST_Y_PER_META_ROW_NOM_L,
2956 v->DST_Y_PER_META_ROW_NOM_C,
2957 v->TimePerMetaChunkNominal,
2958 v->TimePerChromaMetaChunkNominal,
2959 v->TimePerMetaChunkVBlank,
2960 v->TimePerChromaMetaChunkVBlank,
2961 v->TimePerMetaChunkFlip,
2962 v->TimePerChromaMetaChunkFlip,
2963 v->time_per_pte_group_nom_luma,
2964 v->time_per_pte_group_vblank_luma,
2965 v->time_per_pte_group_flip_luma,
2966 v->time_per_pte_group_nom_chroma,
2967 v->time_per_pte_group_vblank_chroma,
2968 v->time_per_pte_group_flip_chroma);
2970 CalculateVMGroupAndRequestTimes(
2971 v->NumberOfActivePlanes,
2973 v->GPUVMMaxPageTableLevels,
2976 v->DestinationLinesToRequestVMInVBlank,
2977 v->DestinationLinesToRequestVMInImmediateFlip,
2980 v->dpte_row_width_luma_ub,
2981 v->dpte_row_width_chroma_ub,
2983 v->dpde0_bytes_per_frame_ub_l,
2984 v->dpde0_bytes_per_frame_ub_c,
2985 v->meta_pte_bytes_per_frame_ub_l,
2986 v->meta_pte_bytes_per_frame_ub_c,
2987 v->TimePerVMGroupVBlank,
2988 v->TimePerVMGroupFlip,
2989 v->TimePerVMRequestVBlank,
2990 v->TimePerVMRequestFlip);
2994 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
2995 if (PrefetchMode == 0) {
2996 v->AllowDRAMClockChangeDuringVBlank[k] = true;
2997 v->AllowDRAMSelfRefreshDuringVBlank[k] = true;
2998 v->MinTTUVBlank[k] = dml_max(
2999 v->DRAMClockChangeWatermark,
3001 v->StutterEnterPlusExitWatermark,
3002 v->UrgentWatermark));
3003 } else if (PrefetchMode == 1) {
3004 v->AllowDRAMClockChangeDuringVBlank[k] = false;
3005 v->AllowDRAMSelfRefreshDuringVBlank[k] = true;
3006 v->MinTTUVBlank[k] = dml_max(
3007 v->StutterEnterPlusExitWatermark,
3008 v->UrgentWatermark);
3010 v->AllowDRAMClockChangeDuringVBlank[k] = false;
3011 v->AllowDRAMSelfRefreshDuringVBlank[k] = false;
3012 v->MinTTUVBlank[k] = v->UrgentWatermark;
3014 if (!v->DynamicMetadataEnable[k])
3015 v->MinTTUVBlank[k] = v->TCalc
3016 + v->MinTTUVBlank[k];
3019 // DCC Configuration
3021 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3022 CalculateDCCConfiguration(v->DCCEnable[k], false, // We should always know the direction DCCProgrammingAssumesScanDirectionUnknown,
3023 v->SourcePixelFormat[k],
3024 v->SurfaceWidthY[k],
3025 v->SurfaceWidthC[k],
3026 v->SurfaceHeightY[k],
3027 v->SurfaceHeightC[k],
3028 v->DETBufferSizeInKByte * 1024,
3029 v->BlockHeight256BytesY[k],
3030 v->BlockHeight256BytesC[k],
3031 v->SurfaceTiling[k],
3032 v->BytePerPixelY[k],
3033 v->BytePerPixelC[k],
3034 v->BytePerPixelDETY[k],
3035 v->BytePerPixelDETC[k],
3037 &v->DCCYMaxUncompressedBlock[k],
3038 &v->DCCCMaxUncompressedBlock[k],
3039 &v->DCCYMaxCompressedBlock[k],
3040 &v->DCCCMaxCompressedBlock[k],
3041 &v->DCCYIndependentBlock[k],
3042 &v->DCCCIndependentBlock[k]);
3046 //Maximum Bandwidth Used
3047 double TotalWRBandwidth = 0;
3048 double MaxPerPlaneVActiveWRBandwidth = 0;
3049 double WRBandwidth = 0;
3050 double MaxUsedBW = 0;
3051 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3052 if (v->WritebackEnable[k] == true
3053 && v->WritebackPixelFormat[k] == dm_444_32) {
3054 WRBandwidth = v->WritebackDestinationWidth[k] * v->WritebackDestinationHeight[k]
3055 / (v->HTotal[k] * v->WritebackSourceHeight[k] / v->PixelClock[k]) * 4;
3056 } else if (v->WritebackEnable[k] == true) {
3057 WRBandwidth = v->WritebackDestinationWidth[k] * v->WritebackDestinationHeight[k]
3058 / (v->HTotal[k] * v->WritebackSourceHeight[k] / v->PixelClock[k]) * 8;
3060 TotalWRBandwidth = TotalWRBandwidth + WRBandwidth;
3061 MaxPerPlaneVActiveWRBandwidth = dml_max(MaxPerPlaneVActiveWRBandwidth, WRBandwidth);
3064 v->TotalDataReadBandwidth = 0;
3065 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3066 v->TotalDataReadBandwidth = v->TotalDataReadBandwidth
3067 + v->ReadBandwidthPlaneLuma[k]
3068 + v->ReadBandwidthPlaneChroma[k];
3072 double MaxPerPlaneVActiveRDBandwidth = 0;
3073 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3074 MaxPerPlaneVActiveRDBandwidth = dml_max(MaxPerPlaneVActiveRDBandwidth,
3075 v->ReadBandwidthPlaneLuma[k] + v->ReadBandwidthPlaneChroma[k]);
3080 MaxUsedBW = MaxTotalRDBandwidth + TotalWRBandwidth;
3084 v->VStartupMargin = 0;
3085 v->FirstMainPlane = true;
3086 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
3087 if (v->BlendingAndTiming[k] == k) {
3088 double margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * v->HTotal[k]
3090 if (v->FirstMainPlane == true) {
3091 v->VStartupMargin = margin;
3092 v->FirstMainPlane = false;
3094 v->VStartupMargin = dml_min(v->VStartupMargin, margin);
3099 // Stutter Efficiency
3100 CalculateStutterEfficiency(
3101 v->NumberOfActivePlanes,
3102 v->ROBBufferSizeInKByte,
3103 v->TotalDataReadBandwidth,
3107 v->SynchronizedVBlank,
3111 v->BytePerPixelDETY,
3122 v->BlockHeight256BytesY,
3123 v->BlockWidth256BytesY,
3124 v->BlockHeight256BytesC,
3125 v->BlockWidth256BytesC,
3126 v->DCCYMaxUncompressedBlock,
3127 v->DCCCMaxUncompressedBlock,
3131 v->ReadBandwidthPlaneLuma,
3132 v->ReadBandwidthPlaneChroma,
3135 &v->StutterEfficiencyNotIncludingVBlank,
3136 &v->StutterEfficiency);
3139 static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib)
3141 // Display Pipe Configuration
3142 double BytePerPixDETY[DC__NUM_DPP__MAX] = { 0 };
3143 double BytePerPixDETC[DC__NUM_DPP__MAX] = { 0 };
3144 int BytePerPixY[DC__NUM_DPP__MAX] = { 0 };
3145 int BytePerPixC[DC__NUM_DPP__MAX] = { 0 };
3146 int Read256BytesBlockHeightY[DC__NUM_DPP__MAX] = { 0 };
3147 int Read256BytesBlockHeightC[DC__NUM_DPP__MAX] = { 0 };
3148 int Read256BytesBlockWidthY[DC__NUM_DPP__MAX] = { 0 };
3149 int Read256BytesBlockWidthC[DC__NUM_DPP__MAX] = { 0 };
3150 double dummy1[DC__NUM_DPP__MAX] = { 0 };
3151 double dummy2[DC__NUM_DPP__MAX] = { 0 };
3152 double dummy3[DC__NUM_DPP__MAX] = { 0 };
3153 double dummy4[DC__NUM_DPP__MAX] = { 0 };
3154 int dummy5[DC__NUM_DPP__MAX] = { 0 };
3155 int dummy6[DC__NUM_DPP__MAX] = { 0 };
3156 bool dummy7[DC__NUM_DPP__MAX] = { 0 };
3157 bool dummysinglestring = 0;
3160 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
3162 CalculateBytePerPixelAnd256BBlockSizes(
3163 mode_lib->vba.SourcePixelFormat[k],
3164 mode_lib->vba.SurfaceTiling[k],
3169 &Read256BytesBlockHeightY[k],
3170 &Read256BytesBlockHeightC[k],
3171 &Read256BytesBlockWidthY[k],
3172 &Read256BytesBlockWidthC[k]);
3174 CalculateSwathAndDETConfiguration(
3176 mode_lib->vba.NumberOfActivePlanes,
3177 mode_lib->vba.DETBufferSizeInKByte,
3180 mode_lib->vba.SourceScan,
3181 mode_lib->vba.SourcePixelFormat,
3182 mode_lib->vba.SurfaceTiling,
3183 mode_lib->vba.ViewportWidth,
3184 mode_lib->vba.ViewportHeight,
3185 mode_lib->vba.SurfaceWidthY,
3186 mode_lib->vba.SurfaceWidthC,
3187 mode_lib->vba.SurfaceHeightY,
3188 mode_lib->vba.SurfaceHeightC,
3189 Read256BytesBlockHeightY,
3190 Read256BytesBlockHeightC,
3191 Read256BytesBlockWidthY,
3192 Read256BytesBlockWidthC,
3193 mode_lib->vba.ODMCombineEnabled,
3194 mode_lib->vba.BlendingAndTiming,
3199 mode_lib->vba.HActive,
3200 mode_lib->vba.HRatio,
3201 mode_lib->vba.HRatioChroma,
3202 mode_lib->vba.DPPPerPlane,
3207 mode_lib->vba.SwathHeightY,
3208 mode_lib->vba.SwathHeightC,
3209 mode_lib->vba.DETBufferSizeY,
3210 mode_lib->vba.DETBufferSizeC,
3212 &dummysinglestring);
3215 static bool CalculateBytePerPixelAnd256BBlockSizes(
3216 enum source_format_class SourcePixelFormat,
3217 enum dm_swizzle_mode SurfaceTiling,
3218 unsigned int *BytePerPixelY,
3219 unsigned int *BytePerPixelC,
3220 double *BytePerPixelDETY,
3221 double *BytePerPixelDETC,
3222 unsigned int *BlockHeight256BytesY,
3223 unsigned int *BlockHeight256BytesC,
3224 unsigned int *BlockWidth256BytesY,
3225 unsigned int *BlockWidth256BytesC)
3227 if (SourcePixelFormat == dm_444_64) {
3228 *BytePerPixelDETY = 8;
3229 *BytePerPixelDETC = 0;
3232 } else if (SourcePixelFormat == dm_444_32 || SourcePixelFormat == dm_rgbe) {
3233 *BytePerPixelDETY = 4;
3234 *BytePerPixelDETC = 0;
3237 } else if (SourcePixelFormat == dm_444_16 || SourcePixelFormat == dm_444_16) {
3238 *BytePerPixelDETY = 2;
3239 *BytePerPixelDETC = 0;
3242 } else if (SourcePixelFormat == dm_444_8) {
3243 *BytePerPixelDETY = 1;
3244 *BytePerPixelDETC = 0;
3247 } else if (SourcePixelFormat == dm_rgbe_alpha) {
3248 *BytePerPixelDETY = 4;
3249 *BytePerPixelDETC = 1;
3252 } else if (SourcePixelFormat == dm_420_8) {
3253 *BytePerPixelDETY = 1;
3254 *BytePerPixelDETC = 2;
3257 } else if (SourcePixelFormat == dm_420_12) {
3258 *BytePerPixelDETY = 2;
3259 *BytePerPixelDETC = 4;
3263 *BytePerPixelDETY = 4.0 / 3;
3264 *BytePerPixelDETC = 8.0 / 3;
3269 if ((SourcePixelFormat == dm_444_64 || SourcePixelFormat == dm_444_32
3270 || SourcePixelFormat == dm_444_16 || SourcePixelFormat == dm_444_8
3271 || SourcePixelFormat == dm_mono_16 || SourcePixelFormat == dm_mono_8
3272 || SourcePixelFormat == dm_rgbe)) {
3273 if (SurfaceTiling == dm_sw_linear) {
3274 *BlockHeight256BytesY = 1;
3275 } else if (SourcePixelFormat == dm_444_64) {
3276 *BlockHeight256BytesY = 4;
3277 } else if (SourcePixelFormat == dm_444_8) {
3278 *BlockHeight256BytesY = 16;
3280 *BlockHeight256BytesY = 8;
3282 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
3283 *BlockHeight256BytesC = 0;
3284 *BlockWidth256BytesC = 0;
3286 if (SurfaceTiling == dm_sw_linear) {
3287 *BlockHeight256BytesY = 1;
3288 *BlockHeight256BytesC = 1;
3289 } else if (SourcePixelFormat == dm_rgbe_alpha) {
3290 *BlockHeight256BytesY = 8;
3291 *BlockHeight256BytesC = 16;
3292 } else if (SourcePixelFormat == dm_420_8) {
3293 *BlockHeight256BytesY = 16;
3294 *BlockHeight256BytesC = 8;
3296 *BlockHeight256BytesY = 8;
3297 *BlockHeight256BytesC = 8;
3299 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
3300 *BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC;
3305 static double CalculateTWait(
3306 unsigned int PrefetchMode,
3307 double DRAMClockChangeLatency,
3308 double UrgentLatency,
3309 double SREnterPlusExitTime)
3311 if (PrefetchMode == 0) {
3312 return dml_max(DRAMClockChangeLatency + UrgentLatency,
3313 dml_max(SREnterPlusExitTime, UrgentLatency));
3314 } else if (PrefetchMode == 1) {
3315 return dml_max(SREnterPlusExitTime, UrgentLatency);
3317 return UrgentLatency;
3321 double dml30_CalculateWriteBackDISPCLK(
3322 enum source_format_class WritebackPixelFormat,
3324 double WritebackHRatio,
3325 double WritebackVRatio,
3326 unsigned int WritebackHTaps,
3327 unsigned int WritebackVTaps,
3328 long WritebackSourceWidth,
3329 long WritebackDestinationWidth,
3330 unsigned int HTotal,
3331 unsigned int WritebackLineBufferSize)
3333 double DISPCLK_H = 0, DISPCLK_V = 0, DISPCLK_HB = 0;
3335 DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio;
3336 DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / HTotal;
3337 DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / WritebackSourceWidth;
3338 return dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB);
3341 static double CalculateWriteBackDelay(
3342 enum source_format_class WritebackPixelFormat,
3343 double WritebackHRatio,
3344 double WritebackVRatio,
3345 unsigned int WritebackVTaps,
3346 long WritebackDestinationWidth,
3347 long WritebackDestinationHeight,
3348 long WritebackSourceHeight,
3349 unsigned int HTotal)
3351 double CalculateWriteBackDelay = 0;
3352 double Line_length = 0;
3353 double Output_lines_last_notclamped = 0;
3354 double WritebackVInit = 0;
3356 WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2;
3357 Line_length = dml_max((double) WritebackDestinationWidth, dml_ceil(WritebackDestinationWidth / 6.0, 1) * WritebackVTaps);
3358 Output_lines_last_notclamped = WritebackDestinationHeight - 1 - dml_ceil((WritebackSourceHeight - WritebackVInit) / WritebackVRatio, 1);
3359 if (Output_lines_last_notclamped < 0) {
3360 CalculateWriteBackDelay = 0;
3362 CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length + (HTotal - WritebackDestinationWidth) + 80;
3364 return CalculateWriteBackDelay;
3368 static void CalculateDynamicMetadataParameters(int MaxInterDCNTileRepeaters, double DPPCLK, double DISPCLK,
3369 double DCFClkDeepSleep, double PixelClock, long HTotal, long VBlank, long DynamicMetadataTransmittedBytes,
3370 long DynamicMetadataLinesBeforeActiveRequired, int InterlaceEnable, bool ProgressiveToInterlaceUnitInOPP,
3371 double *Tsetup, double *Tdmbf, double *Tdmec, double *Tdmsks)
3373 double TotalRepeaterDelayTime = 0;
3374 double VUpdateWidthPix = 0;
3375 double VReadyOffsetPix = 0;
3376 double VUpdateOffsetPix = 0;
3377 TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / DPPCLK + 3 / DISPCLK);
3378 VUpdateWidthPix = (14 / DCFClkDeepSleep + 12 / DPPCLK + TotalRepeaterDelayTime) * PixelClock;
3379 VReadyOffsetPix = dml_max(150.0 / DPPCLK, TotalRepeaterDelayTime + 20 / DCFClkDeepSleep + 10 / DPPCLK) * PixelClock;
3380 VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1);
3381 *Tsetup = (VUpdateOffsetPix + VUpdateWidthPix + VReadyOffsetPix) / PixelClock;
3382 *Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / DISPCLK;
3383 *Tdmec = HTotal / PixelClock;
3384 if (DynamicMetadataLinesBeforeActiveRequired == 0) {
3385 *Tdmsks = VBlank * HTotal / PixelClock / 2.0;
3387 *Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock;
3389 if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false) {
3390 *Tdmsks = *Tdmsks / 2;
3394 static void CalculateRowBandwidth(
3396 enum source_format_class SourcePixelFormat,
3398 double VRatioChroma,
3401 unsigned int MetaRowByteLuma,
3402 unsigned int MetaRowByteChroma,
3403 unsigned int meta_row_height_luma,
3404 unsigned int meta_row_height_chroma,
3405 unsigned int PixelPTEBytesPerRowLuma,
3406 unsigned int PixelPTEBytesPerRowChroma,
3407 unsigned int dpte_row_height_luma,
3408 unsigned int dpte_row_height_chroma,
3409 double *meta_row_bw,
3410 double *dpte_row_bw)
3412 if (DCCEnable != true) {
3414 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || SourcePixelFormat == dm_rgbe_alpha) {
3415 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
3416 + VRatioChroma * MetaRowByteChroma
3417 / (meta_row_height_chroma * LineTime);
3419 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
3422 if (GPUVMEnable != true) {
3424 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || SourcePixelFormat == dm_rgbe_alpha) {
3425 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
3426 + VRatioChroma * PixelPTEBytesPerRowChroma
3427 / (dpte_row_height_chroma * LineTime);
3429 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
3433 static void CalculateFlipSchedule(
3434 struct display_mode_lib *mode_lib,
3435 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
3436 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
3437 double UrgentExtraLatency,
3438 double UrgentLatency,
3439 unsigned int GPUVMMaxPageTableLevels,
3441 unsigned int HostVMMaxNonCachedPageTableLevels,
3443 double HostVMMinPageSize,
3444 double PDEAndMetaPTEBytesPerFrame,
3445 double MetaRowBytes,
3446 double DPTEBytesPerRow,
3447 double BandwidthAvailableForImmediateFlip,
3448 unsigned int TotImmediateFlipBytes,
3449 enum source_format_class SourcePixelFormat,
3452 double VRatioChroma,
3455 unsigned int dpte_row_height,
3456 unsigned int meta_row_height,
3457 unsigned int dpte_row_height_chroma,
3458 unsigned int meta_row_height_chroma,
3459 double *DestinationLinesToRequestVMInImmediateFlip,
3460 double *DestinationLinesToRequestRowInImmediateFlip,
3461 double *final_flip_bw,
3462 bool *ImmediateFlipSupportedForPipe)
3464 double min_row_time = 0.0;
3465 unsigned int HostVMDynamicLevelsTrips = 0;
3466 double TimeForFetchingMetaPTEImmediateFlip = 0;
3467 double TimeForFetchingRowInVBlankImmediateFlip = 0;
3468 double ImmediateFlipBW = 0;
3469 double HostVMInefficiencyFactor = 0;
3471 if (GPUVMEnable == true && HostVMEnable == true) {
3472 HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
3473 HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
3475 HostVMInefficiencyFactor = 1;
3476 HostVMDynamicLevelsTrips = 0;
3479 if (GPUVMEnable == true || DCCEnable == true) {
3480 ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes;
3483 if (GPUVMEnable == true) {
3484 TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / ImmediateFlipBW,
3485 UrgentExtraLatency + UrgentLatency * (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1), LineTime / 4.0);
3487 TimeForFetchingMetaPTEImmediateFlip = 0;
3490 *DestinationLinesToRequestVMInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1) / 4.0;
3491 if ((GPUVMEnable == true || DCCEnable == true)) {
3492 TimeForFetchingRowInVBlankImmediateFlip = dml_max3((MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW,
3493 UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4);
3495 TimeForFetchingRowInVBlankImmediateFlip = 0;
3498 *DestinationLinesToRequestRowInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1) / 4.0;
3500 if (GPUVMEnable == true) {
3501 *final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
3502 (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime));
3503 } else if ((GPUVMEnable == true || DCCEnable == true)) {
3504 *final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime);
3510 if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_rgbe_alpha) {
3511 if (GPUVMEnable == true && DCCEnable != true) {
3512 min_row_time = dml_min(dpte_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma);
3513 } else if (GPUVMEnable != true && DCCEnable == true) {
3514 min_row_time = dml_min(meta_row_height * LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma);
3516 min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio,
3517 dpte_row_height_chroma * LineTime / VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma);
3520 if (GPUVMEnable == true && DCCEnable != true) {
3521 min_row_time = dpte_row_height * LineTime / VRatio;
3522 } else if (GPUVMEnable != true && DCCEnable == true) {
3523 min_row_time = meta_row_height * LineTime / VRatio;
3525 min_row_time = dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio);
3529 if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16
3530 || TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip > min_row_time) {
3531 *ImmediateFlipSupportedForPipe = false;
3533 *ImmediateFlipSupportedForPipe = true;
3537 static double TruncToValidBPP(
3545 enum output_encoder_class Output,
3546 enum output_format_class Format,
3547 unsigned int DSCInputBitPerComponent,
3551 enum odm_combine_mode ODMCombine)
3553 double MaxLinkBPP = 0;
3555 double MaxDSCBPP = 0;
3560 if (Format == dm_420) {
3565 MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1.0 / 16;
3566 } else if (Format == dm_444) {
3571 MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16;
3573 if (Output == dm_hdmi) {
3584 if (Format == dm_n422) {
3586 MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0;
3590 MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0;
3594 if (DSCEnable && Output == dm_dp) {
3595 MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock * (1 - 2.4 / 100);
3597 MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock;
3600 if (ODMCombine == dm_odm_combine_mode_4to1 && MaxLinkBPP > 16) {
3602 } else if (ODMCombine == dm_odm_combine_mode_2to1 && MaxLinkBPP > 32) {
3607 if (DesiredBPP == 0) {
3609 if (MaxLinkBPP < MinDSCBPP) {
3611 } else if (MaxLinkBPP >= MaxDSCBPP) {
3614 return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0;
3617 if (MaxLinkBPP >= NonDSCBPP2) {
3619 } else if (MaxLinkBPP >= NonDSCBPP1) {
3621 } else if (MaxLinkBPP >= NonDSCBPP0) {
3628 if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 || DesiredBPP == NonDSCBPP0)) ||
3629 (DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP))) {
3638 void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
3640 struct vba_vars_st *v = &mode_lib->vba;
3641 int MinPrefetchMode = 0;
3642 int MaxPrefetchMode = 2;
3644 unsigned int j, k, m;
3645 bool EnoughWritebackUnits = true;
3646 bool WritebackModeSupport = true;
3647 bool ViewportExceedsSurface = false;
3648 double MaxTotalVActiveRDBandwidth = 0;
3649 long ReorderingBytes = 0;
3650 bool NotUrgentLatencyHiding[DC__NUM_DPP__MAX] = { 0 };
3652 /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
3654 /*Scale Ratio, taps Support Check*/
3656 v->ScaleRatioAndTapsSupport = true;
3657 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3658 if (v->ScalerEnabled[k] == false
3659 && ((v->SourcePixelFormat[k] != dm_444_64
3660 && v->SourcePixelFormat[k] != dm_444_32
3661 && v->SourcePixelFormat[k] != dm_444_16
3662 && v->SourcePixelFormat[k] != dm_mono_16
3663 && v->SourcePixelFormat[k] != dm_mono_8
3664 && v->SourcePixelFormat[k] != dm_rgbe
3665 && v->SourcePixelFormat[k] != dm_rgbe_alpha)
3666 || v->HRatio[k] != 1.0
3667 || v->htaps[k] != 1.0
3668 || v->VRatio[k] != 1.0
3669 || v->vtaps[k] != 1.0)) {
3670 v->ScaleRatioAndTapsSupport = false;
3671 } else if (v->vtaps[k] < 1.0 || v->vtaps[k] > 8.0
3672 || v->htaps[k] < 1.0 || v->htaps[k] > 8.0
3673 || (v->htaps[k] > 1.0
3674 && (v->htaps[k] % 2) == 1)
3675 || v->HRatio[k] > v->MaxHSCLRatio
3676 || v->VRatio[k] > v->MaxVSCLRatio
3677 || v->HRatio[k] > v->htaps[k]
3678 || v->VRatio[k] > v->vtaps[k]
3679 || (v->SourcePixelFormat[k] != dm_444_64
3680 && v->SourcePixelFormat[k] != dm_444_32
3681 && v->SourcePixelFormat[k] != dm_444_16
3682 && v->SourcePixelFormat[k] != dm_mono_16
3683 && v->SourcePixelFormat[k] != dm_mono_8
3684 && v->SourcePixelFormat[k] != dm_rgbe
3685 && (v->VTAPsChroma[k] < 1
3686 || v->VTAPsChroma[k] > 8
3687 || v->HTAPsChroma[k] < 1
3688 || v->HTAPsChroma[k] > 8
3689 || (v->HTAPsChroma[k] > 1 && v->HTAPsChroma[k] % 2 == 1)
3690 || v->HRatioChroma[k] > v->MaxHSCLRatio
3691 || v->VRatioChroma[k] > v->MaxVSCLRatio
3692 || v->HRatioChroma[k] > v->HTAPsChroma[k]
3693 || v->VRatioChroma[k] > v->VTAPsChroma[k]))) {
3694 v->ScaleRatioAndTapsSupport = false;
3697 /*Source Format, Pixel Format and Scan Support Check*/
3699 v->SourceFormatPixelAndScanSupport = true;
3700 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3701 if ((v->SurfaceTiling[k] == dm_sw_linear && (!(v->SourceScan[k] != dm_vert) || v->DCCEnable[k] == true))
3702 || ((v->SurfaceTiling[k] == dm_sw_64kb_d || v->SurfaceTiling[k] == dm_sw_64kb_d_t || v->SurfaceTiling[k] == dm_sw_64kb_d_x)
3703 && !(v->SourcePixelFormat[k] == dm_444_64))) {
3704 v->SourceFormatPixelAndScanSupport = false;
3707 /*Bandwidth Support Check*/
3709 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3710 CalculateBytePerPixelAnd256BBlockSizes(
3711 v->SourcePixelFormat[k],
3712 v->SurfaceTiling[k],
3713 &v->BytePerPixelY[k],
3714 &v->BytePerPixelC[k],
3715 &v->BytePerPixelInDETY[k],
3716 &v->BytePerPixelInDETC[k],
3717 &v->Read256BlockHeightY[k],
3718 &v->Read256BlockHeightC[k],
3719 &v->Read256BlockWidthY[k],
3720 &v->Read256BlockWidthC[k]);
3722 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3723 if (v->SourceScan[k] != dm_vert) {
3724 v->SwathWidthYSingleDPP[k] = v->ViewportWidth[k];
3725 v->SwathWidthCSingleDPP[k] = v->ViewportWidthChroma[k];
3727 v->SwathWidthYSingleDPP[k] = v->ViewportHeight[k];
3728 v->SwathWidthCSingleDPP[k] = v->ViewportHeightChroma[k];
3731 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3732 v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
3733 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;
3735 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3736 if (v->WritebackEnable[k] == true
3737 && v->WritebackPixelFormat[k] == dm_444_64) {
3738 v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
3739 * v->WritebackDestinationHeight[k]
3740 / (v->WritebackSourceHeight[k]
3742 / v->PixelClock[k]) * 8.0;
3743 } else if (v->WritebackEnable[k] == true) {
3744 v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
3745 * v->WritebackDestinationHeight[k]
3746 / (v->WritebackSourceHeight[k]
3748 / v->PixelClock[k]) * 4.0;
3750 v->WriteBandwidth[k] = 0.0;
3754 /*Writeback Latency support check*/
3756 v->WritebackLatencySupport = true;
3757 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3758 if (v->WritebackEnable[k] == true) {
3759 if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave ||
3760 v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave) {
3761 if (v->WriteBandwidth[k]
3762 > 2.0 * v->WritebackInterfaceBufferSize * 1024
3763 / v->WritebackLatency) {
3764 v->WritebackLatencySupport = false;
3767 if (v->WriteBandwidth[k]
3768 > v->WritebackInterfaceBufferSize * 1024
3769 / v->WritebackLatency) {
3770 v->WritebackLatencySupport = false;
3776 /*Writeback Mode Support Check*/
3778 v->TotalNumberOfActiveWriteback = 0;
3779 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3780 if (v->WritebackEnable[k] == true) {
3781 v->TotalNumberOfActiveWriteback =
3782 v->TotalNumberOfActiveWriteback + 1;
3786 if (v->TotalNumberOfActiveWriteback > v->MaxNumWriteback) {
3787 EnoughWritebackUnits = false;
3789 if (!v->WritebackSupportInterleaveAndUsingWholeBufferForASingleStream
3790 && (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave
3791 || v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave)) {
3793 WritebackModeSupport = false;
3795 if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave && v->TotalNumberOfActiveWriteback > 1) {
3796 WritebackModeSupport = false;
3799 /*Writeback Scale Ratio and Taps Support Check*/
3801 v->WritebackScaleRatioAndTapsSupport = true;
3802 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3803 if (v->WritebackEnable[k] == true) {
3804 if (v->WritebackHRatio[k] > v->WritebackMaxHSCLRatio
3805 || v->WritebackVRatio[k]
3806 > v->WritebackMaxVSCLRatio
3807 || v->WritebackHRatio[k]
3808 < v->WritebackMinHSCLRatio
3809 || v->WritebackVRatio[k]
3810 < v->WritebackMinVSCLRatio
3811 || v->WritebackHTaps[k]
3812 > v->WritebackMaxHSCLTaps
3813 || v->WritebackVTaps[k]
3814 > v->WritebackMaxVSCLTaps
3815 || v->WritebackHRatio[k]
3816 > v->WritebackHTaps[k]
3817 || v->WritebackVRatio[k]
3818 > v->WritebackVTaps[k]
3819 || (v->WritebackHTaps[k] > 2.0
3820 && ((v->WritebackHTaps[k] % 2)
3822 v->WritebackScaleRatioAndTapsSupport = false;
3824 if (2.0 * v->WritebackDestinationWidth[k] * (v->WritebackVTaps[k] - 1) * 57 > v->WritebackLineBufferSize) {
3825 v->WritebackScaleRatioAndTapsSupport = false;
3829 /*Maximum DISPCLK/DPPCLK Support check*/
3831 v->WritebackRequiredDISPCLK = 0.0;
3832 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3833 if (v->WritebackEnable[k] == true) {
3834 v->WritebackRequiredDISPCLK = dml_max(v->WritebackRequiredDISPCLK,
3835 dml30_CalculateWriteBackDISPCLK(
3836 v->WritebackPixelFormat[k],
3838 v->WritebackHRatio[k],
3839 v->WritebackVRatio[k],
3840 v->WritebackHTaps[k],
3841 v->WritebackVTaps[k],
3842 v->WritebackSourceWidth[k],
3843 v->WritebackDestinationWidth[k],
3845 v->WritebackLineBufferSize));
3848 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3849 if (v->HRatio[k] > 1.0) {
3850 v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(v->htaps[k] / 6.0, 1.0));
3852 v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
3854 if (v->BytePerPixelC[k] == 0.0) {
3855 v->PSCL_FACTOR_CHROMA[k] = 0.0;
3856 v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k]
3857 * 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);
3858 if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0) && v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
3859 v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
3862 if (v->HRatioChroma[k] > 1.0) {
3863 v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
3864 v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(v->HTAPsChroma[k] / 6.0, 1.0));
3866 v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
3868 v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k] * dml_max5(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]),
3869 v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k],
3870 v->VTAPsChroma[k] / 6.0 * dml_min(1.0, v->HRatioChroma[k]),
3871 v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_FACTOR_CHROMA[k],
3873 if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0 || v->HTAPsChroma[k] > 6.0 || v->VTAPsChroma[k] > 6.0)
3874 && v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
3875 v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
3879 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3880 int MaximumSwathWidthSupportLuma = 0;
3881 int MaximumSwathWidthSupportChroma = 0;
3883 if (v->SurfaceTiling[k] == dm_sw_linear) {
3884 MaximumSwathWidthSupportLuma = 8192.0;
3885 } else if (v->SourceScan[k] == dm_vert && v->BytePerPixelC[k] > 0) {
3886 MaximumSwathWidthSupportLuma = 2880.0;
3888 MaximumSwathWidthSupportLuma = 5760.0;
3891 if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) {
3892 MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma / 2.0;
3894 MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma;
3896 v->MaximumSwathWidthInLineBufferLuma = v->LineBufferSize * dml_max(v->HRatio[k], 1.0) / v->LBBitPerPixel[k]
3897 / (v->vtaps[k] + dml_max(dml_ceil(v->VRatio[k], 1.0) - 2, 0.0));
3898 if (v->BytePerPixelC[k] == 0.0) {
3899 v->MaximumSwathWidthInLineBufferChroma = 0;
3901 v->MaximumSwathWidthInLineBufferChroma = v->LineBufferSize * dml_max(v->HRatioChroma[k], 1.0) / v->LBBitPerPixel[k]
3902 / (v->VTAPsChroma[k] + dml_max(dml_ceil(v->VRatioChroma[k], 1.0) - 2, 0.0));
3904 v->MaximumSwathWidthLuma[k] = dml_min(MaximumSwathWidthSupportLuma, v->MaximumSwathWidthInLineBufferLuma);
3905 v->MaximumSwathWidthChroma[k] = dml_min(MaximumSwathWidthSupportChroma, v->MaximumSwathWidthInLineBufferChroma);
3908 CalculateSwathAndDETConfiguration(
3910 v->NumberOfActivePlanes,
3911 v->DETBufferSizeInKByte,
3912 v->MaximumSwathWidthLuma,
3913 v->MaximumSwathWidthChroma,
3915 v->SourcePixelFormat,
3923 v->Read256BlockHeightY,
3924 v->Read256BlockHeightC,
3925 v->Read256BlockWidthY,
3926 v->Read256BlockWidthC,
3927 v->odm_combine_dummy,
3928 v->BlendingAndTiming,
3931 v->BytePerPixelInDETY,
3932 v->BytePerPixelInDETC,
3937 v->swath_width_luma_ub,
3938 v->swath_width_chroma_ub,
3945 v->SingleDPPViewportSizeSupportPerPlane,
3946 &v->ViewportSizeSupport[0][0]);
3948 for (i = 0; i < v->soc.num_states; i++) {
3949 for (j = 0; j < 2; j++) {
3950 v->MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDispclk[i], v->DISPCLKDPPCLKVCOSpeed);
3951 v->MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDppclk[i], v->DISPCLKDPPCLKVCOSpeed);
3952 v->RequiredDISPCLK[i][j] = 0.0;
3953 v->DISPCLK_DPPCLK_Support[i][j] = true;
3954 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
3955 v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3956 * (1.0 + v->DISPCLKRampingMargin / 100.0);
3957 if ((v->PlaneRequiredDISPCLKWithoutODMCombine >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states]
3958 && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) {
3959 v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3961 v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3962 * (1 + v->DISPCLKRampingMargin / 100.0);
3963 if ((v->PlaneRequiredDISPCLKWithODMCombine2To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states]
3964 && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) {
3965 v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3967 v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3968 * (1 + v->DISPCLKRampingMargin / 100.0);
3969 if ((v->PlaneRequiredDISPCLKWithODMCombine4To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states]
3970 && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) {
3971 v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3974 if (v->ODMCombinePolicy == dm_odm_combine_policy_none) {
3975 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
3976 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
3977 } else if (v->ODMCombinePolicy == dm_odm_combine_policy_2to1) {
3978 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3979 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3980 } else if (v->ODMCombinePolicy == dm_odm_combine_policy_4to1
3981 || v->PlaneRequiredDISPCLKWithODMCombine2To1 > v->MaxDispclkRoundedDownToDFSGranularity) {
3982 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
3983 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
3984 } else if (v->PlaneRequiredDISPCLKWithoutODMCombine > v->MaxDispclkRoundedDownToDFSGranularity) {
3985 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3986 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3988 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
3989 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
3990 /*420 format workaround*/
3991 if (v->HActive[k] > 4096 && v->OutputFormat[k] == dm_420) {
3992 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
3993 v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
3997 if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
3998 v->MPCCombine[i][j][k] = false;
3999 v->NoOfDPP[i][j][k] = 4;
4000 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 4;
4001 } else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4002 v->MPCCombine[i][j][k] = false;
4003 v->NoOfDPP[i][j][k] = 2;
4004 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2;
4005 } else if ((v->WhenToDoMPCCombine == dm_mpc_never
4006 || (v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= v->MaxDppclkRoundedDownToDFSGranularity
4007 && v->SingleDPPViewportSizeSupportPerPlane[k] == true))) {
4008 v->MPCCombine[i][j][k] = false;
4009 v->NoOfDPP[i][j][k] = 1;
4010 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4012 v->MPCCombine[i][j][k] = true;
4013 v->NoOfDPP[i][j][k] = 2;
4014 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
4016 v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
4017 if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4018 > v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
4019 v->DISPCLK_DPPCLK_Support[i][j] = false;
4022 v->TotalNumberOfActiveDPP[i][j] = 0;
4023 v->TotalNumberOfSingleDPPPlanes[i][j] = 0;
4024 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4025 v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
4026 if (v->NoOfDPP[i][j][k] == 1)
4027 v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] + 1;
4029 if (j == 1 && v->WhenToDoMPCCombine != dm_mpc_never) {
4030 while (!(v->TotalNumberOfActiveDPP[i][j] >= v->MaxNumDPP || v->TotalNumberOfSingleDPPPlanes[i][j] == 0)) {
4031 double BWOfNonSplitPlaneOfMaximumBandwidth = 0;
4032 unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
4033 BWOfNonSplitPlaneOfMaximumBandwidth = 0;
4034 NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
4035 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4036 if (v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k] > BWOfNonSplitPlaneOfMaximumBandwidth
4037 && v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled && v->MPCCombine[i][j][k] == false) {
4038 BWOfNonSplitPlaneOfMaximumBandwidth = v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
4039 NumberOfNonSplitPlaneOfMaximumBandwidth = k;
4042 v->MPCCombine[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = true;
4043 v->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
4044 v->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = v->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
4045 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
4046 v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + 1;
4047 v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] + 1;
4050 if (v->TotalNumberOfActiveDPP[i][j] > v->MaxNumDPP) {
4051 v->RequiredDISPCLK[i][j] = 0.0;
4052 v->DISPCLK_DPPCLK_Support[i][j] = true;
4053 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4054 v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
4055 if (v->SingleDPPViewportSizeSupportPerPlane[k] == false && v->WhenToDoMPCCombine != dm_mpc_never) {
4056 v->MPCCombine[i][j][k] = true;
4057 v->NoOfDPP[i][j][k] = 2;
4058 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
4060 v->MPCCombine[i][j][k] = false;
4061 v->NoOfDPP[i][j][k] = 1;
4062 v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4064 if (!(v->MaxDispclk[i] == v->MaxDispclk[v->soc.num_states - 1] && v->MaxDppclk[i] == v->MaxDppclk[v->soc.num_states - 1])) {
4065 v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4066 * (1.0 + v->DISPCLKRampingMargin / 100.0);
4068 v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4070 v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
4071 if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4072 > v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
4073 v->DISPCLK_DPPCLK_Support[i][j] = false;
4076 v->TotalNumberOfActiveDPP[i][j] = 0.0;
4077 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4078 v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
4081 v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->WritebackRequiredDISPCLK);
4082 if (v->MaxDispclkRoundedDownToDFSGranularity < v->WritebackRequiredDISPCLK) {
4083 v->DISPCLK_DPPCLK_Support[i][j] = false;
4088 /*Total Available Pipes Support Check*/
4090 for (i = 0; i < v->soc.num_states; i++) {
4091 for (j = 0; j < 2; j++) {
4092 if (v->TotalNumberOfActiveDPP[i][j] <= v->MaxNumDPP) {
4093 v->TotalAvailablePipesSupport[i][j] = true;
4095 v->TotalAvailablePipesSupport[i][j] = false;
4099 /*Display IO and DSC Support Check*/
4101 v->NonsupportedDSCInputBPC = false;
4102 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4103 if (!(v->DSCInputBitPerComponent[k] == 12.0
4104 || v->DSCInputBitPerComponent[k] == 10.0
4105 || v->DSCInputBitPerComponent[k] == 8.0)) {
4106 v->NonsupportedDSCInputBPC = true;
4110 /*Number Of DSC Slices*/
4111 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4112 if (v->BlendingAndTiming[k] == k) {
4113 if (v->PixelClockBackEnd[k] > 3200) {
4114 v->NumberOfDSCSlices[k] = dml_ceil(v->PixelClockBackEnd[k] / 400.0, 4.0);
4115 } else if (v->PixelClockBackEnd[k] > 1360) {
4116 v->NumberOfDSCSlices[k] = 8;
4117 } else if (v->PixelClockBackEnd[k] > 680) {
4118 v->NumberOfDSCSlices[k] = 4;
4119 } else if (v->PixelClockBackEnd[k] > 340) {
4120 v->NumberOfDSCSlices[k] = 2;
4122 v->NumberOfDSCSlices[k] = 1;
4125 v->NumberOfDSCSlices[k] = 0;
4129 for (i = 0; i < v->soc.num_states; i++) {
4130 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4131 v->RequiresDSC[i][k] = false;
4132 v->RequiresFEC[i][k] = false;
4133 if (v->BlendingAndTiming[k] == k) {
4134 if (v->Output[k] == dm_hdmi) {
4135 v->RequiresDSC[i][k] = false;
4136 v->RequiresFEC[i][k] = false;
4137 v->OutputBppPerState[i][k] = TruncToValidBPP(
4138 dml_min(600.0, v->PHYCLKPerState[i]) * 10,
4142 v->PixelClockBackEnd[k],
4143 v->ForcedOutputLinkBPP[k],
4147 v->DSCInputBitPerComponent[k],
4148 v->NumberOfDSCSlices[k],
4149 v->AudioSampleRate[k],
4150 v->AudioSampleLayout[k],
4151 v->ODMCombineEnablePerState[i][k]);
4152 } else if (v->Output[k] == dm_dp || v->Output[k] == dm_edp) {
4153 if (v->DSCEnable[k] == true) {
4154 v->RequiresDSC[i][k] = true;
4155 v->LinkDSCEnable = true;
4156 if (v->Output[k] == dm_dp) {
4157 v->RequiresFEC[i][k] = true;
4159 v->RequiresFEC[i][k] = false;
4162 v->RequiresDSC[i][k] = false;
4163 v->LinkDSCEnable = false;
4164 v->RequiresFEC[i][k] = false;
4167 v->Outbpp = BPP_INVALID;
4168 if (v->PHYCLKPerState[i] >= 270.0) {
4169 v->Outbpp = TruncToValidBPP(
4170 (1.0 - v->Downspreading / 100.0) * 2700,
4171 v->OutputLinkDPLanes[k],
4174 v->PixelClockBackEnd[k],
4175 v->ForcedOutputLinkBPP[k],
4179 v->DSCInputBitPerComponent[k],
4180 v->NumberOfDSCSlices[k],
4181 v->AudioSampleRate[k],
4182 v->AudioSampleLayout[k],
4183 v->ODMCombineEnablePerState[i][k]);
4184 v->OutputBppPerState[i][k] = v->Outbpp;
4185 // TODO: Need some other way to handle this nonsense
4186 // v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
4188 if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 540.0) {
4189 v->Outbpp = TruncToValidBPP(
4190 (1.0 - v->Downspreading / 100.0) * 5400,
4191 v->OutputLinkDPLanes[k],
4194 v->PixelClockBackEnd[k],
4195 v->ForcedOutputLinkBPP[k],
4199 v->DSCInputBitPerComponent[k],
4200 v->NumberOfDSCSlices[k],
4201 v->AudioSampleRate[k],
4202 v->AudioSampleLayout[k],
4203 v->ODMCombineEnablePerState[i][k]);
4204 v->OutputBppPerState[i][k] = v->Outbpp;
4205 // TODO: Need some other way to handle this nonsense
4206 // v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
4208 if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 810.0) {
4209 v->Outbpp = TruncToValidBPP(
4210 (1.0 - v->Downspreading / 100.0) * 8100,
4211 v->OutputLinkDPLanes[k],
4214 v->PixelClockBackEnd[k],
4215 v->ForcedOutputLinkBPP[k],
4219 v->DSCInputBitPerComponent[k],
4220 v->NumberOfDSCSlices[k],
4221 v->AudioSampleRate[k],
4222 v->AudioSampleLayout[k],
4223 v->ODMCombineEnablePerState[i][k]);
4224 if (v->Outbpp == BPP_INVALID && v->ForcedOutputLinkBPP[k] == 0) {
4225 //if (v->Outbpp == BPP_INVALID && v->DSCEnabled[k] == dm_dsc_enable_only_if_necessary && v->ForcedOutputLinkBPP[k] == 0) {
4226 v->RequiresDSC[i][k] = true;
4227 v->LinkDSCEnable = true;
4228 if (v->Output[k] == dm_dp) {
4229 v->RequiresFEC[i][k] = true;
4231 v->Outbpp = TruncToValidBPP(
4232 (1.0 - v->Downspreading / 100.0) * 8100,
4233 v->OutputLinkDPLanes[k],
4236 v->PixelClockBackEnd[k],
4237 v->ForcedOutputLinkBPP[k],
4241 v->DSCInputBitPerComponent[k],
4242 v->NumberOfDSCSlices[k],
4243 v->AudioSampleRate[k],
4244 v->AudioSampleLayout[k],
4245 v->ODMCombineEnablePerState[i][k]);
4247 v->OutputBppPerState[i][k] = v->Outbpp;
4248 // TODO: Need some other way to handle this nonsense
4249 // v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
4253 v->OutputBppPerState[i][k] = 0;
4257 for (i = 0; i < v->soc.num_states; i++) {
4258 v->DIOSupport[i] = true;
4259 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4260 if (v->BlendingAndTiming[k] == k && (v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)
4261 && (v->OutputBppPerState[i][k] == 0
4262 || (v->OutputFormat[k] == dm_420 && v->Interlace[k] == true && v->ProgressiveToInterlaceUnitInOPP == true))) {
4263 v->DIOSupport[i] = false;
4268 for (i = 0; i < v->soc.num_states; ++i) {
4269 v->ODMCombine4To1SupportCheckOK[i] = true;
4270 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4271 if (v->BlendingAndTiming[k] == k && v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
4272 && (v->ODMCombine4To1Supported == false || v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)) {
4273 v->ODMCombine4To1SupportCheckOK[i] = false;
4278 for (i = 0; i < v->soc.num_states; i++) {
4279 v->DSCCLKRequiredMoreThanSupported[i] = false;
4280 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4281 if (v->BlendingAndTiming[k] == k) {
4282 if (v->Output[k] == dm_dp || v->Output[k] == dm_edp) {
4283 if (v->OutputFormat[k] == dm_420) {
4284 v->DSCFormatFactor = 2;
4285 } else if (v->OutputFormat[k] == dm_444) {
4286 v->DSCFormatFactor = 1;
4287 } else if (v->OutputFormat[k] == dm_n422) {
4288 v->DSCFormatFactor = 2;
4290 v->DSCFormatFactor = 1;
4292 if (v->RequiresDSC[i][k] == true) {
4293 if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
4294 if (v->PixelClockBackEnd[k] / 12.0 / v->DSCFormatFactor
4295 > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) {
4296 v->DSCCLKRequiredMoreThanSupported[i] = true;
4298 } else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4299 if (v->PixelClockBackEnd[k] / 6.0 / v->DSCFormatFactor
4300 > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) {
4301 v->DSCCLKRequiredMoreThanSupported[i] = true;
4304 if (v->PixelClockBackEnd[k] / 3.0 / v->DSCFormatFactor
4305 > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) {
4306 v->DSCCLKRequiredMoreThanSupported[i] = true;
4314 for (i = 0; i < v->soc.num_states; i++) {
4315 v->NotEnoughDSCUnits[i] = false;
4316 v->TotalDSCUnitsRequired = 0.0;
4317 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4318 if (v->RequiresDSC[i][k] == true) {
4319 if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
4320 v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 4.0;
4321 } else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4322 v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 2.0;
4324 v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 1.0;
4328 if (v->TotalDSCUnitsRequired > v->NumberOfDSC) {
4329 v->NotEnoughDSCUnits[i] = true;
4332 /*DSC Delay per state*/
4334 for (i = 0; i < v->soc.num_states; i++) {
4335 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4336 if (v->OutputBppPerState[i][k] == BPP_INVALID) {
4339 v->BPP = v->OutputBppPerState[i][k];
4341 if (v->RequiresDSC[i][k] == true && v->BPP != 0.0) {
4342 if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
4343 v->DSCDelayPerState[i][k] = dscceComputeDelay(
4344 v->DSCInputBitPerComponent[k],
4346 dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4347 v->NumberOfDSCSlices[k],
4349 v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
4350 } else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4351 v->DSCDelayPerState[i][k] = 2.0
4352 * dscceComputeDelay(
4353 v->DSCInputBitPerComponent[k],
4355 dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4356 v->NumberOfDSCSlices[k] / 2,
4358 v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
4360 v->DSCDelayPerState[i][k] = 4.0
4361 * (dscceComputeDelay(
4362 v->DSCInputBitPerComponent[k],
4364 dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
4365 v->NumberOfDSCSlices[k] / 4,
4367 v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]));
4369 v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][k] * v->PixelClock[k] / v->PixelClockBackEnd[k];
4371 v->DSCDelayPerState[i][k] = 0.0;
4374 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4375 for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4376 if (v->BlendingAndTiming[k] == m && v->RequiresDSC[i][m] == true) {
4377 v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][m];
4383 //Calculate Swath, DET Configuration, DCFCLKDeepSleep
4385 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4386 for (j = 0; j <= 1; ++j) {
4387 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4388 v->RequiredDPPCLKThisState[k] = v->RequiredDPPCLK[i][j][k];
4389 v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
4390 v->ODMCombineEnableThisState[k] = v->ODMCombineEnablePerState[i][k];
4393 CalculateSwathAndDETConfiguration(
4395 v->NumberOfActivePlanes,
4396 v->DETBufferSizeInKByte,
4397 v->MaximumSwathWidthLuma,
4398 v->MaximumSwathWidthChroma,
4400 v->SourcePixelFormat,
4408 v->Read256BlockHeightY,
4409 v->Read256BlockHeightC,
4410 v->Read256BlockWidthY,
4411 v->Read256BlockWidthC,
4412 v->ODMCombineEnableThisState,
4413 v->BlendingAndTiming,
4416 v->BytePerPixelInDETY,
4417 v->BytePerPixelInDETC,
4421 v->NoOfDPPThisState,
4422 v->swath_width_luma_ub_this_state,
4423 v->swath_width_chroma_ub_this_state,
4424 v->SwathWidthYThisState,
4425 v->SwathWidthCThisState,
4426 v->SwathHeightYThisState,
4427 v->SwathHeightCThisState,
4428 v->DETBufferSizeYThisState,
4429 v->DETBufferSizeCThisState,
4431 &v->ViewportSizeSupport[i][j]);
4433 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4434 v->swath_width_luma_ub_all_states[i][j][k] = v->swath_width_luma_ub_this_state[k];
4435 v->swath_width_chroma_ub_all_states[i][j][k] = v->swath_width_chroma_ub_this_state[k];
4436 v->SwathWidthYAllStates[i][j][k] = v->SwathWidthYThisState[k];
4437 v->SwathWidthCAllStates[i][j][k] = v->SwathWidthCThisState[k];
4438 v->SwathHeightYAllStates[i][j][k] = v->SwathHeightYThisState[k];
4439 v->SwathHeightCAllStates[i][j][k] = v->SwathHeightCThisState[k];
4440 v->DETBufferSizeYAllStates[i][j][k] = v->DETBufferSizeYThisState[k];
4441 v->DETBufferSizeCAllStates[i][j][k] = v->DETBufferSizeCThisState[k];
4446 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4447 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];
4450 for (i = 0; i < v->soc.num_states; i++) {
4451 for (j = 0; j < 2; j++) {
4452 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4453 v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
4454 v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
4455 v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
4456 v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
4457 v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
4458 v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
4459 v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
4460 v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
4463 v->TotalNumberOfDCCActiveDPP[i][j] = 0;
4464 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4465 if (v->DCCEnable[k] == true) {
4466 v->TotalNumberOfDCCActiveDPP[i][j] = v->TotalNumberOfDCCActiveDPP[i][j] + v->NoOfDPP[i][j][k];
4470 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4471 if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12
4472 || v->SourcePixelFormat[k] == dm_rgbe_alpha) {
4474 if ((v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) && v->SourceScan[k] != dm_vert) {
4475 v->PTEBufferSizeInRequestsForLuma = (v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma) / 2;
4476 v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsForLuma;
4478 v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma;
4479 v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsChroma;
4482 v->PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
4485 v->Read256BlockHeightC[k],
4486 v->Read256BlockWidthY[k],
4487 v->SourcePixelFormat[k],
4488 v->SurfaceTiling[k],
4489 v->BytePerPixelC[k],
4491 v->SwathWidthCThisState[k],
4492 v->ViewportHeightChroma[k],
4495 v->HostVMMaxNonCachedPageTableLevels,
4496 v->GPUVMMinPageSize,
4497 v->HostVMMinPageSize,
4498 v->PTEBufferSizeInRequestsForChroma,
4501 &v->MacroTileWidthC[k],
4503 &v->DPTEBytesPerRowC,
4504 &v->PTEBufferSizeNotExceededC[i][j][k],
4506 &v->dpte_row_height_chroma[k],
4510 &v->meta_row_height_chroma[k],
4517 &v->dummyinteger11);
4519 v->PrefetchLinesC[i][j][k] = CalculatePrefetchSourceLines(
4524 v->ProgressiveToInterlaceUnitInOPP,
4525 v->SwathHeightCThisState[k],
4526 v->ViewportYStartC[k],
4530 v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma;
4531 v->PTEBufferSizeInRequestsForChroma = 0;
4532 v->PDEAndMetaPTEBytesPerFrameC = 0.0;
4533 v->MetaRowBytesC = 0.0;
4534 v->DPTEBytesPerRowC = 0.0;
4535 v->PrefetchLinesC[i][j][k] = 0.0;
4536 v->PTEBufferSizeNotExceededC[i][j][k] = true;
4538 v->PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
4541 v->Read256BlockHeightY[k],
4542 v->Read256BlockWidthY[k],
4543 v->SourcePixelFormat[k],
4544 v->SurfaceTiling[k],
4545 v->BytePerPixelY[k],
4547 v->SwathWidthYThisState[k],
4548 v->ViewportHeight[k],
4551 v->HostVMMaxNonCachedPageTableLevels,
4552 v->GPUVMMinPageSize,
4553 v->HostVMMinPageSize,
4554 v->PTEBufferSizeInRequestsForLuma,
4556 v->DCCMetaPitchY[k],
4557 &v->MacroTileWidthY[k],
4559 &v->DPTEBytesPerRowY,
4560 &v->PTEBufferSizeNotExceededY[i][j][k],
4562 &v->dpte_row_height[k],
4566 &v->meta_row_height[k],
4568 &v->dpte_group_bytes[k],
4574 v->PrefetchLinesY[i][j][k] = CalculatePrefetchSourceLines(
4579 v->ProgressiveToInterlaceUnitInOPP,
4580 v->SwathHeightYThisState[k],
4581 v->ViewportYStartY[k],
4584 v->PDEAndMetaPTEBytesPerFrame[i][j][k] = v->PDEAndMetaPTEBytesPerFrameY + v->PDEAndMetaPTEBytesPerFrameC;
4585 v->MetaRowBytes[i][j][k] = v->MetaRowBytesY + v->MetaRowBytesC;
4586 v->DPTEBytesPerRow[i][j][k] = v->DPTEBytesPerRowY + v->DPTEBytesPerRowC;
4588 CalculateRowBandwidth(
4590 v->SourcePixelFormat[k],
4594 v->HTotal[k] / v->PixelClock[k],
4597 v->meta_row_height[k],
4598 v->meta_row_height_chroma[k],
4599 v->DPTEBytesPerRowY,
4600 v->DPTEBytesPerRowC,
4601 v->dpte_row_height[k],
4602 v->dpte_row_height_chroma[k],
4603 &v->meta_row_bandwidth[i][j][k],
4604 &v->dpte_row_bandwidth[i][j][k]);
4606 v->UrgLatency[i] = CalculateUrgentLatency(
4607 v->UrgentLatencyPixelDataOnly,
4608 v->UrgentLatencyPixelMixedWithVMData,
4609 v->UrgentLatencyVMDataOnly,
4610 v->DoUrgentLatencyAdjustment,
4611 v->UrgentLatencyAdjustmentFabricClockComponent,
4612 v->UrgentLatencyAdjustmentFabricClockReference,
4613 v->FabricClockPerState[i]);
4615 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4616 CalculateUrgentBurstFactor(
4617 v->swath_width_luma_ub_this_state[k],
4618 v->swath_width_chroma_ub_this_state[k],
4619 v->DETBufferSizeInKByte,
4620 v->SwathHeightYThisState[k],
4621 v->SwathHeightCThisState[k],
4622 v->HTotal[k] / v->PixelClock[k],
4624 v->CursorBufferSize,
4625 v->CursorWidth[k][0],
4629 v->BytePerPixelInDETY[k],
4630 v->BytePerPixelInDETC[k],
4631 v->DETBufferSizeYThisState[k],
4632 v->DETBufferSizeCThisState[k],
4633 &v->UrgentBurstFactorCursor[k],
4634 &v->UrgentBurstFactorLuma[k],
4635 &v->UrgentBurstFactorChroma[k],
4636 &NotUrgentLatencyHiding[k]);
4639 v->NotUrgentLatencyHiding[i][j] = false;
4640 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4641 if (NotUrgentLatencyHiding[k]) {
4642 v->NotUrgentLatencyHiding[i][j] = true;
4646 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4647 v->VActivePixelBandwidth[i][j][k] = v->ReadBandwidthLuma[k] * v->UrgentBurstFactorLuma[k]
4648 + v->ReadBandwidthChroma[k] * v->UrgentBurstFactorChroma[k];
4649 v->VActiveCursorBandwidth[i][j][k] = v->cursor_bw[k] * v->UrgentBurstFactorCursor[k];
4652 v->TotalVActivePixelBandwidth[i][j] = 0;
4653 v->TotalVActiveCursorBandwidth[i][j] = 0;
4654 v->TotalMetaRowBandwidth[i][j] = 0;
4655 v->TotalDPTERowBandwidth[i][j] = 0;
4656 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4657 v->TotalVActivePixelBandwidth[i][j] = v->TotalVActivePixelBandwidth[i][j] + v->VActivePixelBandwidth[i][j][k];
4658 v->TotalVActiveCursorBandwidth[i][j] = v->TotalVActiveCursorBandwidth[i][j] + v->VActiveCursorBandwidth[i][j][k];
4659 v->TotalMetaRowBandwidth[i][j] = v->TotalMetaRowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->meta_row_bandwidth[i][j][k];
4660 v->TotalDPTERowBandwidth[i][j] = v->TotalDPTERowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->dpte_row_bandwidth[i][j][k];
4663 CalculateDCFCLKDeepSleep(
4665 v->NumberOfActivePlanes,
4670 v->SwathWidthYThisState,
4671 v->SwathWidthCThisState,
4672 v->NoOfDPPThisState,
4677 v->PSCL_FACTOR_CHROMA,
4678 v->RequiredDPPCLKThisState,
4679 v->ReadBandwidthLuma,
4680 v->ReadBandwidthChroma,
4682 &v->ProjectedDCFCLKDeepSleep[i][j]);
4686 //Calculate Return BW
4688 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4689 for (j = 0; j <= 1; ++j) {
4690 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4691 if (v->BlendingAndTiming[k] == k) {
4692 if (v->WritebackEnable[k] == true) {
4693 v->WritebackDelayTime[k] = v->WritebackLatency
4694 + CalculateWriteBackDelay(
4695 v->WritebackPixelFormat[k],
4696 v->WritebackHRatio[k],
4697 v->WritebackVRatio[k],
4698 v->WritebackVTaps[k],
4699 v->WritebackDestinationWidth[k],
4700 v->WritebackDestinationHeight[k],
4701 v->WritebackSourceHeight[k],
4702 v->HTotal[k]) / v->RequiredDISPCLK[i][j];
4704 v->WritebackDelayTime[k] = 0.0;
4706 for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4707 if (v->BlendingAndTiming[m] == k && v->WritebackEnable[m] == true) {
4708 v->WritebackDelayTime[k] = dml_max(
4709 v->WritebackDelayTime[k],
4711 + CalculateWriteBackDelay(
4712 v->WritebackPixelFormat[m],
4713 v->WritebackHRatio[m],
4714 v->WritebackVRatio[m],
4715 v->WritebackVTaps[m],
4716 v->WritebackDestinationWidth[m],
4717 v->WritebackDestinationHeight[m],
4718 v->WritebackSourceHeight[m],
4719 v->HTotal[m]) / v->RequiredDISPCLK[i][j]);
4724 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4725 for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
4726 if (v->BlendingAndTiming[k] == m) {
4727 v->WritebackDelayTime[k] = v->WritebackDelayTime[m];
4731 v->MaxMaxVStartup[i][j] = 0;
4732 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4733 v->MaximumVStartup[i][j][k] = v->VTotal[k] - v->VActive[k]
4734 - dml_max(1.0, dml_ceil(1.0 * v->WritebackDelayTime[k] / (v->HTotal[k] / v->PixelClock[k]), 1.0));
4735 v->MaxMaxVStartup[i][j] = dml_max(v->MaxMaxVStartup[i][j], v->MaximumVStartup[i][j][k]);
4740 ReorderingBytes = v->NumberOfChannels
4742 v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
4743 v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
4744 v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
4745 v->FinalDRAMClockChangeLatency = (v->DRAMClockChangeLatencyOverride > 0 ? v->DRAMClockChangeLatencyOverride : v->DRAMClockChangeLatency);
4747 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4748 for (j = 0; j <= 1; ++j) {
4749 v->DCFCLKState[i][j] = v->DCFCLKPerState[i];
4753 if (v->UseMinimumRequiredDCFCLK == true) {
4756 v->MaxInterDCNTileRepeaters,
4758 v->FinalDRAMClockChangeLatency,
4759 v->SREnterPlusExitTime,
4761 v->RoundTripPingLatencyCycles,
4763 v->PixelChunkSizeInKByte,
4766 v->GPUVMMaxPageTableLevels,
4768 v->NumberOfActivePlanes,
4769 v->HostVMMinPageSize,
4770 v->HostVMMaxNonCachedPageTableLevels,
4771 v->DynamicMetadataVMEnabled,
4772 v->ImmediateFlipRequirement,
4773 v->ProgressiveToInterlaceUnitInOPP,
4774 v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
4775 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4776 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4777 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly,
4780 v->DynamicMetadataTransmittedBytes,
4781 v->DynamicMetadataLinesBeforeActiveRequired,
4787 v->ProjectedDCFCLKDeepSleep,
4789 v->TotalVActivePixelBandwidth,
4790 v->TotalVActiveCursorBandwidth,
4791 v->TotalMetaRowBandwidth,
4792 v->TotalDPTERowBandwidth,
4793 v->TotalNumberOfActiveDPP,
4794 v->TotalNumberOfDCCActiveDPP,
4795 v->dpte_group_bytes,
4798 v->swath_width_luma_ub_all_states,
4799 v->swath_width_chroma_ub_all_states,
4804 v->PDEAndMetaPTEBytesPerFrame,
4807 v->DynamicMetadataEnable,
4808 v->VActivePixelBandwidth,
4809 v->VActiveCursorBandwidth,
4810 v->ReadBandwidthLuma,
4811 v->ReadBandwidthChroma,
4815 if (v->ClampMinDCFCLK) {
4816 /* Clamp calculated values to actual minimum */
4817 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4818 for (j = 0; j <= 1; ++j) {
4819 if (v->DCFCLKState[i][j] < mode_lib->soc.min_dcfclk) {
4820 v->DCFCLKState[i][j] = mode_lib->soc.min_dcfclk;
4827 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4828 for (j = 0; j <= 1; ++j) {
4829 v->IdealSDPPortBandwidthPerState[i][j] = dml_min3(
4830 v->ReturnBusWidth * v->DCFCLKState[i][j],
4831 v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth,
4832 v->FabricClockPerState[i] * v->FabricDatapathToDCNDataReturn);
4833 if (v->HostVMEnable != true) {
4834 v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly
4837 v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j]
4838 * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / 100;
4843 //Re-ordering Buffer Support Check
4845 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4846 for (j = 0; j <= 1; ++j) {
4847 if ((v->ROBBufferSizeInKByte - v->PixelChunkSizeInKByte) * 1024 / v->ReturnBWPerState[i][j]
4848 > (v->RoundTripPingLatencyCycles + 32) / v->DCFCLKState[i][j] + ReorderingBytes / v->ReturnBWPerState[i][j]) {
4849 v->ROBSupport[i][j] = true;
4851 v->ROBSupport[i][j] = false;
4856 //Vertical Active BW support check
4858 MaxTotalVActiveRDBandwidth = 0;
4859 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4860 MaxTotalVActiveRDBandwidth = MaxTotalVActiveRDBandwidth + v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
4863 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4864 for (j = 0; j <= 1; ++j) {
4865 v->MaxTotalVerticalActiveAvailableBandwidth[i][j] = dml_min(
4866 v->IdealSDPPortBandwidthPerState[i][j] * v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
4867 v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth * v->MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation
4869 if (MaxTotalVActiveRDBandwidth <= v->MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
4870 v->TotalVerticalActiveBandwidthSupport[i][j] = true;
4872 v->TotalVerticalActiveBandwidthSupport[i][j] = false;
4879 for (i = 0; i < mode_lib->soc.num_states; ++i) {
4880 for (j = 0; j <= 1; ++j) {
4881 int NextPrefetchModeState = MinPrefetchMode;
4883 v->TimeCalc = 24 / v->ProjectedDCFCLKDeepSleep[i][j];
4885 v->BandwidthWithoutPrefetchSupported[i][j] = true;
4886 if (v->TotalVActivePixelBandwidth[i][j] + v->TotalVActiveCursorBandwidth[i][j] + v->TotalMetaRowBandwidth[i][j] + v->TotalDPTERowBandwidth[i][j]
4887 > v->ReturnBWPerState[i][j] || v->NotUrgentLatencyHiding[i][j]) {
4888 v->BandwidthWithoutPrefetchSupported[i][j] = false;
4891 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
4892 v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
4893 v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
4894 v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
4895 v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
4896 v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
4897 v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
4898 v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
4899 v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
4900 v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
4901 v->ODMCombineEnabled[k] = v->ODMCombineEnablePerState[i][k];
4904 v->ExtraLatency = CalculateExtraLatency(
4905 v->RoundTripPingLatencyCycles,
4907 v->DCFCLKState[i][j],
4908 v->TotalNumberOfActiveDPP[i][j],
4909 v->PixelChunkSizeInKByte,
4910 v->TotalNumberOfDCCActiveDPP[i][j],
4912 v->ReturnBWPerState[i][j],
4915 v->NumberOfActivePlanes,
4916 v->NoOfDPPThisState,
4917 v->dpte_group_bytes,
4918 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4919 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4920 v->HostVMMinPageSize,
4921 v->HostVMMaxNonCachedPageTableLevels);
4923 v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
4925 v->PrefetchModePerState[i][j] = NextPrefetchModeState;
4926 v->MaxVStartup = v->NextMaxVStartup;
4928 v->TWait = CalculateTWait(v->PrefetchModePerState[i][j], v->FinalDRAMClockChangeLatency, v->UrgLatency[i], v->SREnterPlusExitTime);
4930 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
4931 Pipe myPipe = { 0 };
4933 myPipe.DPPCLK = v->RequiredDPPCLK[i][j][k];
4934 myPipe.DISPCLK = v->RequiredDISPCLK[i][j];
4935 myPipe.PixelClock = v->PixelClock[k];
4936 myPipe.DCFCLKDeepSleep = v->ProjectedDCFCLKDeepSleep[i][j];
4937 myPipe.DPPPerPlane = v->NoOfDPP[i][j][k];
4938 myPipe.ScalerEnabled = v->ScalerEnabled[k];
4939 myPipe.SourceScan = v->SourceScan[k];
4940 myPipe.BlockWidth256BytesY = v->Read256BlockWidthY[k];
4941 myPipe.BlockHeight256BytesY = v->Read256BlockHeightY[k];
4942 myPipe.BlockWidth256BytesC = v->Read256BlockWidthC[k];
4943 myPipe.BlockHeight256BytesC = v->Read256BlockHeightC[k];
4944 myPipe.InterlaceEnable = v->Interlace[k];
4945 myPipe.NumberOfCursors = v->NumberOfCursors[k];
4946 myPipe.VBlank = v->VTotal[k] - v->VActive[k];
4947 myPipe.HTotal = v->HTotal[k];
4948 myPipe.DCCEnable = v->DCCEnable[k];
4949 myPipe.ODMCombineEnabled = !!v->ODMCombineEnabled[k];
4951 v->NoTimeForPrefetch[i][j][k] = CalculatePrefetchSchedule(
4953 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
4954 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
4956 v->DSCDelayPerState[i][k],
4957 v->DPPCLKDelaySubtotal + v->DPPCLKDelayCNVCFormater,
4959 v->DPPCLKDelaySCLLBOnly,
4960 v->DPPCLKDelayCNVCCursor,
4961 v->DISPCLKDelaySubtotal,
4962 v->SwathWidthYThisState[k] / v->HRatio[k],
4964 v->MaxInterDCNTileRepeaters,
4965 dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
4966 v->MaximumVStartup[i][j][k],
4967 v->GPUVMMaxPageTableLevels,
4970 v->HostVMMaxNonCachedPageTableLevels,
4971 v->HostVMMinPageSize,
4972 v->DynamicMetadataEnable[k],
4973 v->DynamicMetadataVMEnabled,
4974 v->DynamicMetadataLinesBeforeActiveRequired[k],
4975 v->DynamicMetadataTransmittedBytes[k],
4979 v->PDEAndMetaPTEBytesPerFrame[i][j][k],
4980 v->MetaRowBytes[i][j][k],
4981 v->DPTEBytesPerRow[i][j][k],
4982 v->PrefetchLinesY[i][j][k],
4983 v->SwathWidthYThisState[k],
4984 v->BytePerPixelY[k],
4987 v->PrefetchLinesC[i][j][k],
4988 v->SwathWidthCThisState[k],
4989 v->BytePerPixelC[k],
4992 v->swath_width_luma_ub_this_state[k],
4993 v->swath_width_chroma_ub_this_state[k],
4994 v->SwathHeightYThisState[k],
4995 v->SwathHeightCThisState[k],
4997 v->ProgressiveToInterlaceUnitInOPP,
4998 &v->DSTXAfterScaler[k],
4999 &v->DSTYAfterScaler[k],
5000 &v->LineTimesForPrefetch[k],
5002 &v->LinesForMetaPTE[k],
5003 &v->LinesForMetaAndDPTERow[k],
5004 &v->VRatioPreY[i][j][k],
5005 &v->VRatioPreC[i][j][k],
5006 &v->RequiredPrefetchPixelDataBWLuma[i][j][k],
5007 &v->RequiredPrefetchPixelDataBWChroma[i][j][k],
5008 &v->NoTimeForDynamicMetadata[i][j][k],
5010 &v->prefetch_vmrow_bw[k],
5013 &v->VUpdateOffsetPix[k],
5014 &v->VUpdateWidthPix[k],
5015 &v->VReadyOffsetPix[k]);
5018 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5019 CalculateUrgentBurstFactor(
5020 v->swath_width_luma_ub_this_state[k],
5021 v->swath_width_chroma_ub_this_state[k],
5022 v->DETBufferSizeInKByte,
5023 v->SwathHeightYThisState[k],
5024 v->SwathHeightCThisState[k],
5025 v->HTotal[k] / v->PixelClock[k],
5027 v->CursorBufferSize,
5028 v->CursorWidth[k][0],
5030 v->VRatioPreY[i][j][k],
5031 v->VRatioPreC[i][j][k],
5032 v->BytePerPixelInDETY[k],
5033 v->BytePerPixelInDETC[k],
5034 v->DETBufferSizeYThisState[k],
5035 v->DETBufferSizeCThisState[k],
5036 &v->UrgentBurstFactorCursorPre[k],
5037 &v->UrgentBurstFactorLumaPre[k],
5038 &v->UrgentBurstFactorChroma[k],
5039 &v->NoUrgentLatencyHidingPre[k]);
5042 v->MaximumReadBandwidthWithPrefetch = 0.0;
5043 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5044 v->cursor_bw_pre[k] = v->NumberOfCursors[k] * v->CursorWidth[k][0] * v->CursorBPP[k][0] / 8.0 / (v->HTotal[k] / v->PixelClock[k])
5045 * v->VRatioPreY[i][j][k];
5047 v->MaximumReadBandwidthWithPrefetch = v->MaximumReadBandwidthWithPrefetch
5049 v->VActivePixelBandwidth[i][j][k],
5050 v->VActiveCursorBandwidth[i][j][k]
5051 + v->NoOfDPP[i][j][k] * (v->meta_row_bandwidth[i][j][k] + v->dpte_row_bandwidth[i][j][k]),
5052 v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
5054 * (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
5055 + v->RequiredPrefetchPixelDataBWChroma[i][j][k]
5056 * v->UrgentBurstFactorChromaPre[k])
5057 + v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
5060 v->NotEnoughUrgentLatencyHidingPre = false;
5061 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5062 if (v->NoUrgentLatencyHidingPre[k] == true) {
5063 v->NotEnoughUrgentLatencyHidingPre = true;
5067 v->PrefetchSupported[i][j] = true;
5068 if (v->BandwidthWithoutPrefetchSupported[i][j] == false || v->MaximumReadBandwidthWithPrefetch > v->ReturnBWPerState[i][j]
5069 || v->NotEnoughUrgentLatencyHidingPre == 1) {
5070 v->PrefetchSupported[i][j] = false;
5072 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5073 if (v->LineTimesForPrefetch[k] < 2.0 || v->LinesForMetaPTE[k] >= 32.0 || v->LinesForMetaAndDPTERow[k] >= 16.0
5074 || v->NoTimeForPrefetch[i][j][k] == true) {
5075 v->PrefetchSupported[i][j] = false;
5079 v->DynamicMetadataSupported[i][j] = true;
5080 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
5081 if (v->NoTimeForDynamicMetadata[i][j][k] == true) {
5082 v->DynamicMetadataSupported[i][j] = false;
5086 v->VRatioInPrefetchSupported[i][j] = true;
5087 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5088 if (v->VRatioPreY[i][j][k] > 4.0 || v->VRatioPreC[i][j][k] > 4.0 || v->NoTimeForPrefetch[i][j][k] == true) {
5089 v->VRatioInPrefetchSupported[i][j] = false;
5092 v->AnyLinesForVMOrRowTooLarge = false;
5093 for (k = 0; k < v->NumberOfActivePlanes; ++k) {
5094 if (v->LinesForMetaAndDPTERow[k] >= 16 || v->LinesForMetaPTE[k] >= 32) {
5095 v->AnyLinesForVMOrRowTooLarge = true;
5099 if (v->PrefetchSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true) {
5100 v->BandwidthAvailableForImmediateFlip = v->ReturnBWPerState[i][j];
5101 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5102 v->BandwidthAvailableForImmediateFlip = v->BandwidthAvailableForImmediateFlip
5104 v->VActivePixelBandwidth[i][j][k] + v->VActiveCursorBandwidth[i][j][k],
5106 * (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
5107 + v->RequiredPrefetchPixelDataBWChroma[i][j][k]
5108 * v->UrgentBurstFactorChromaPre[k])
5109 + v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
5111 v->TotImmediateFlipBytes = 0.0;
5112 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5113 v->TotImmediateFlipBytes = v->TotImmediateFlipBytes + v->NoOfDPP[i][j][k] * v->PDEAndMetaPTEBytesPerFrame[i][j][k]
5114 + v->MetaRowBytes[i][j][k] + v->DPTEBytesPerRow[i][j][k];
5117 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5118 CalculateFlipSchedule(
5120 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
5121 v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
5124 v->GPUVMMaxPageTableLevels,
5126 v->HostVMMaxNonCachedPageTableLevels,
5128 v->HostVMMinPageSize,
5129 v->PDEAndMetaPTEBytesPerFrame[i][j][k],
5130 v->MetaRowBytes[i][j][k],
5131 v->DPTEBytesPerRow[i][j][k],
5132 v->BandwidthAvailableForImmediateFlip,
5133 v->TotImmediateFlipBytes,
5134 v->SourcePixelFormat[k],
5135 v->HTotal[k] / v->PixelClock[k],
5140 v->dpte_row_height[k],
5141 v->meta_row_height[k],
5142 v->dpte_row_height_chroma[k],
5143 v->meta_row_height_chroma[k],
5144 &v->DestinationLinesToRequestVMInImmediateFlip[k],
5145 &v->DestinationLinesToRequestRowInImmediateFlip[k],
5146 &v->final_flip_bw[k],
5147 &v->ImmediateFlipSupportedForPipe[k]);
5149 v->total_dcn_read_bw_with_flip = 0.0;
5150 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5151 v->total_dcn_read_bw_with_flip = v->total_dcn_read_bw_with_flip
5153 v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
5154 v->NoOfDPP[i][j][k] * v->final_flip_bw[k] + v->VActivePixelBandwidth[i][j][k]
5155 + v->VActiveCursorBandwidth[i][j][k],
5157 * (v->final_flip_bw[k]
5158 + v->RequiredPrefetchPixelDataBWLuma[i][j][k]
5159 * v->UrgentBurstFactorLumaPre[k]
5160 + v->RequiredPrefetchPixelDataBWChroma[i][j][k]
5161 * v->UrgentBurstFactorChromaPre[k])
5162 + v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
5164 v->ImmediateFlipSupportedForState[i][j] = true;
5165 if (v->total_dcn_read_bw_with_flip > v->ReturnBWPerState[i][j]) {
5166 v->ImmediateFlipSupportedForState[i][j] = false;
5168 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5169 if (v->ImmediateFlipSupportedForPipe[k] == false) {
5170 v->ImmediateFlipSupportedForState[i][j] = false;
5174 v->ImmediateFlipSupportedForState[i][j] = false;
5176 if (v->MaxVStartup <= 13 || v->AnyLinesForVMOrRowTooLarge == false) {
5177 v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
5178 NextPrefetchModeState = NextPrefetchModeState + 1;
5180 v->NextMaxVStartup = v->NextMaxVStartup - 1;
5182 } while (!((v->PrefetchSupported[i][j] == true && v->DynamicMetadataSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true
5183 && ((v->HostVMEnable == false && v->ImmediateFlipRequirement != dm_immediate_flip_required)
5184 || v->ImmediateFlipSupportedForState[i][j] == true))
5185 || (v->NextMaxVStartup == v->MaxMaxVStartup[i][j] && NextPrefetchModeState > MaxPrefetchMode)));
5187 CalculateWatermarksAndDRAMSpeedChangeSupport(
5189 v->PrefetchModePerState[i][j],
5190 v->NumberOfActivePlanes,
5191 v->MaxLineBufferLines,
5193 v->DPPOutputBufferPixels,
5194 v->DETBufferSizeInKByte,
5195 v->WritebackInterfaceBufferSize,
5196 v->DCFCLKState[i][j],
5197 v->ReturnBWPerState[i][j],
5199 v->dpte_group_bytes,
5203 v->WritebackLatency,
5204 v->WritebackChunkSize,
5205 v->SOCCLKPerState[i],
5206 v->FinalDRAMClockChangeLatency,
5208 v->SREnterPlusExitTime,
5209 v->ProjectedDCFCLKDeepSleep[i][j],
5210 v->NoOfDPPThisState,
5212 v->RequiredDPPCLKThisState,
5213 v->DETBufferSizeYThisState,
5214 v->DETBufferSizeCThisState,
5215 v->SwathHeightYThisState,
5216 v->SwathHeightCThisState,
5218 v->SwathWidthYThisState,
5219 v->SwathWidthCThisState,
5228 v->BlendingAndTiming,
5229 v->BytePerPixelInDETY,
5230 v->BytePerPixelInDETC,
5234 v->WritebackPixelFormat,
5235 v->WritebackDestinationWidth,
5236 v->WritebackDestinationHeight,
5237 v->WritebackSourceHeight,
5238 &v->DRAMClockChangeSupport[i][j],
5239 &v->UrgentWatermark,
5240 &v->WritebackUrgentWatermark,
5241 &v->DRAMClockChangeWatermark,
5242 &v->WritebackDRAMClockChangeWatermark,
5243 &v->StutterExitWatermark,
5244 &v->StutterEnterPlusExitWatermark,
5245 &v->MinActiveDRAMClockChangeLatencySupported);
5249 /*PTE Buffer Size Check*/
5251 for (i = 0; i < v->soc.num_states; i++) {
5252 for (j = 0; j < 2; j++) {
5253 v->PTEBufferSizeNotExceeded[i][j] = true;
5254 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5255 if (v->PTEBufferSizeNotExceededY[i][j][k] == false || v->PTEBufferSizeNotExceededC[i][j][k] == false) {
5256 v->PTEBufferSizeNotExceeded[i][j] = false;
5261 /*Cursor Support Check*/
5263 v->CursorSupport = true;
5264 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5265 if (v->CursorWidth[k][0] > 0.0) {
5266 if (v->CursorBPP[k][0] == 64 && v->Cursor64BppSupport == false) {
5267 v->CursorSupport = false;
5271 /*Valid Pitch Check*/
5273 v->PitchSupport = true;
5274 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5275 v->AlignedYPitch[k] = dml_ceil(dml_max(v->PitchY[k], v->SurfaceWidthY[k]), v->MacroTileWidthY[k]);
5276 if (v->DCCEnable[k] == true) {
5277 v->AlignedDCCMetaPitchY[k] = dml_ceil(dml_max(v->DCCMetaPitchY[k], v->SurfaceWidthY[k]), 64.0 * v->Read256BlockWidthY[k]);
5279 v->AlignedDCCMetaPitchY[k] = v->DCCMetaPitchY[k];
5281 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
5282 && v->SourcePixelFormat[k] != dm_rgbe && v->SourcePixelFormat[k] != dm_mono_8) {
5283 v->AlignedCPitch[k] = dml_ceil(dml_max(v->PitchC[k], v->SurfaceWidthC[k]), v->MacroTileWidthC[k]);
5284 if (v->DCCEnable[k] == true) {
5285 v->AlignedDCCMetaPitchC[k] = dml_ceil(dml_max(v->DCCMetaPitchC[k], v->SurfaceWidthC[k]), 64.0 * v->Read256BlockWidthC[k]);
5287 v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
5290 v->AlignedCPitch[k] = v->PitchC[k];
5291 v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
5293 if (v->AlignedYPitch[k] > v->PitchY[k] || v->AlignedCPitch[k] > v->PitchC[k] || v->AlignedDCCMetaPitchY[k] > v->DCCMetaPitchY[k]
5294 || v->AlignedDCCMetaPitchC[k] > v->DCCMetaPitchC[k]) {
5295 v->PitchSupport = false;
5299 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5300 if (v->ViewportWidth[k] > v->SurfaceWidthY[k] || v->ViewportHeight[k] > v->SurfaceHeightY[k])
5301 ViewportExceedsSurface = true;
5303 if (v->SourcePixelFormat[k] != dm_444_64 && v->SourcePixelFormat[k] != dm_444_32 && v->SourcePixelFormat[k] != dm_444_16
5304 && v->SourcePixelFormat[k] != dm_444_16 && v->SourcePixelFormat[k] != dm_444_8 && v->SourcePixelFormat[k] != dm_rgbe) {
5305 if (v->ViewportWidthChroma[k] > v->SurfaceWidthC[k] || v->ViewportHeightChroma[k] > v->SurfaceHeightC[k]) {
5306 ViewportExceedsSurface = true;
5310 /*Mode Support, Voltage State and SOC Configuration*/
5312 for (i = v->soc.num_states - 1; i >= 0; i--) {
5313 for (j = 0; j < 2; j++) {
5314 if (v->ScaleRatioAndTapsSupport == 1 && v->SourceFormatPixelAndScanSupport == 1 && v->ViewportSizeSupport[i][j] == 1
5315 && v->DIOSupport[i] == 1 && v->ODMCombine4To1SupportCheckOK[i] == 1
5316 && v->NotEnoughDSCUnits[i] == 0 && v->DSCCLKRequiredMoreThanSupported[i] == 0
5317 && v->DTBCLKRequiredMoreThanSupported[i] == 0
5318 && v->ROBSupport[i][j] == 1 && v->DISPCLK_DPPCLK_Support[i][j] == 1 && v->TotalAvailablePipesSupport[i][j] == 1
5319 && EnoughWritebackUnits == 1 && WritebackModeSupport == 1
5320 && v->WritebackLatencySupport == 1 && v->WritebackScaleRatioAndTapsSupport == 1 && v->CursorSupport == 1 && v->PitchSupport == 1
5321 && ViewportExceedsSurface == 0 && v->PrefetchSupported[i][j] == 1 && v->DynamicMetadataSupported[i][j] == 1
5322 && v->TotalVerticalActiveBandwidthSupport[i][j] == 1 && v->VRatioInPrefetchSupported[i][j] == 1
5323 && v->PTEBufferSizeNotExceeded[i][j] == 1 && v->NonsupportedDSCInputBPC == 0
5324 && ((v->HostVMEnable == 0 && v->ImmediateFlipRequirement != dm_immediate_flip_required)
5325 || v->ImmediateFlipSupportedForState[i][j] == true)) {
5326 v->ModeSupport[i][j] = true;
5328 v->ModeSupport[i][j] = false;
5333 unsigned int MaximumMPCCombine = 0;
5334 for (i = v->soc.num_states; i >= 0; i--) {
5335 if (i == v->soc.num_states || v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true) {
5336 v->VoltageLevel = i;
5337 v->ModeIsSupported = v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true;
5338 if (v->ModeSupport[i][1] == true) {
5339 MaximumMPCCombine = 1;
5341 MaximumMPCCombine = 0;
5345 v->ImmediateFlipSupport = v->ImmediateFlipSupportedForState[v->VoltageLevel][MaximumMPCCombine];
5346 for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
5347 v->MPCCombineEnable[k] = v->MPCCombine[v->VoltageLevel][MaximumMPCCombine][k];
5348 v->DPPPerPlane[k] = v->NoOfDPP[v->VoltageLevel][MaximumMPCCombine][k];
5350 v->DCFCLK = v->DCFCLKState[v->VoltageLevel][MaximumMPCCombine];
5351 v->DRAMSpeed = v->DRAMSpeedPerState[v->VoltageLevel];
5352 v->FabricClock = v->FabricClockPerState[v->VoltageLevel];
5353 v->SOCCLK = v->SOCCLKPerState[v->VoltageLevel];
5354 v->ReturnBW = v->ReturnBWPerState[v->VoltageLevel][MaximumMPCCombine];
5355 v->maxMpcComb = MaximumMPCCombine;
5359 static void CalculateWatermarksAndDRAMSpeedChangeSupport(
5360 struct display_mode_lib *mode_lib,
5361 unsigned int PrefetchMode,
5362 unsigned int NumberOfActivePlanes,
5363 unsigned int MaxLineBufferLines,
5364 unsigned int LineBufferSize,
5365 unsigned int DPPOutputBufferPixels,
5366 double DETBufferSizeInKByte,
5367 unsigned int WritebackInterfaceBufferSize,
5371 unsigned int dpte_group_bytes[],
5372 unsigned int MetaChunkSize,
5373 double UrgentLatency,
5374 double ExtraLatency,
5375 double WritebackLatency,
5376 double WritebackChunkSize,
5378 double DRAMClockChangeLatency,
5380 double SREnterPlusExitTime,
5381 double DCFCLKDeepSleep,
5382 unsigned int DPPPerPlane[],
5385 double DETBufferSizeY[],
5386 double DETBufferSizeC[],
5387 unsigned int SwathHeightY[],
5388 unsigned int SwathHeightC[],
5389 unsigned int LBBitPerPixel[],
5390 double SwathWidthY[],
5391 double SwathWidthC[],
5393 double HRatioChroma[],
5394 unsigned int vtaps[],
5395 unsigned int VTAPsChroma[],
5397 double VRatioChroma[],
5398 unsigned int HTotal[],
5399 double PixelClock[],
5400 unsigned int BlendingAndTiming[],
5401 double BytePerPixelDETY[],
5402 double BytePerPixelDETC[],
5403 double DSTXAfterScaler[],
5404 double DSTYAfterScaler[],
5405 bool WritebackEnable[],
5406 enum source_format_class WritebackPixelFormat[],
5407 double WritebackDestinationWidth[],
5408 double WritebackDestinationHeight[],
5409 double WritebackSourceHeight[],
5410 enum clock_change_support *DRAMClockChangeSupport,
5411 double *UrgentWatermark,
5412 double *WritebackUrgentWatermark,
5413 double *DRAMClockChangeWatermark,
5414 double *WritebackDRAMClockChangeWatermark,
5415 double *StutterExitWatermark,
5416 double *StutterEnterPlusExitWatermark,
5417 double *MinActiveDRAMClockChangeLatencySupported)
5419 double EffectiveLBLatencyHidingY = 0;
5420 double EffectiveLBLatencyHidingC = 0;
5421 double LinesInDETY[DC__NUM_DPP__MAX] = { 0 };
5422 double LinesInDETC = 0;
5423 unsigned int LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX] = { 0 };
5424 unsigned int LinesInDETCRoundedDownToSwath = 0;
5425 double FullDETBufferingTimeY[DC__NUM_DPP__MAX] = { 0 };
5426 double FullDETBufferingTimeC = 0;
5427 double ActiveDRAMClockChangeLatencyMarginY = 0;
5428 double ActiveDRAMClockChangeLatencyMarginC = 0;
5429 double WritebackDRAMClockChangeLatencyMargin = 0;
5430 double PlaneWithMinActiveDRAMClockChangeMargin = 0;
5431 double SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = 0;
5432 double FullDETBufferingTimeYStutterCriticalPlane = 0;
5433 double TimeToFinishSwathTransferStutterCriticalPlane = 0;
5434 double WritebackDRAMClockChangeLatencyHiding = 0;
5437 mode_lib->vba.TotalActiveDPP = 0;
5438 mode_lib->vba.TotalDCCActiveDPP = 0;
5439 for (k = 0; k < NumberOfActivePlanes; ++k) {
5440 mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + DPPPerPlane[k];
5441 if (DCCEnable[k] == true) {
5442 mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP + DPPPerPlane[k];
5446 *UrgentWatermark = UrgentLatency + ExtraLatency;
5448 *DRAMClockChangeWatermark = DRAMClockChangeLatency + *UrgentWatermark;
5450 mode_lib->vba.TotalActiveWriteback = 0;
5451 for (k = 0; k < NumberOfActivePlanes; ++k) {
5452 if (WritebackEnable[k] == true) {
5453 mode_lib->vba.TotalActiveWriteback = mode_lib->vba.TotalActiveWriteback + 1;
5457 if (mode_lib->vba.TotalActiveWriteback <= 1) {
5458 *WritebackUrgentWatermark = WritebackLatency;
5460 *WritebackUrgentWatermark = WritebackLatency + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
5463 if (mode_lib->vba.TotalActiveWriteback <= 1) {
5464 *WritebackDRAMClockChangeWatermark = DRAMClockChangeLatency + WritebackLatency;
5466 *WritebackDRAMClockChangeWatermark = DRAMClockChangeLatency + WritebackLatency + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
5469 for (k = 0; k < NumberOfActivePlanes; ++k) {
5471 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);
5473 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);
5475 EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY / VRatio[k] * (HTotal[k] / PixelClock[k]);
5477 EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC / VRatioChroma[k] * (HTotal[k] / PixelClock[k]);
5479 LinesInDETY[k] = (double) DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k];
5480 LinesInDETYRoundedDownToSwath[k] = dml_floor(LinesInDETY[k], SwathHeightY[k]);
5481 FullDETBufferingTimeY[k] = LinesInDETYRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) / VRatio[k];
5482 if (BytePerPixelDETC[k] > 0) {
5483 LinesInDETC = mode_lib->vba.DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k];
5484 LinesInDETCRoundedDownToSwath = dml_floor(LinesInDETC, SwathHeightC[k]);
5485 FullDETBufferingTimeC = LinesInDETCRoundedDownToSwath * (HTotal[k] / PixelClock[k]) / VRatioChroma[k];
5488 FullDETBufferingTimeC = 999999;
5491 ActiveDRAMClockChangeLatencyMarginY = EffectiveLBLatencyHidingY + FullDETBufferingTimeY[k] - *UrgentWatermark - (HTotal[k] / PixelClock[k]) * (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) - *DRAMClockChangeWatermark;
5493 if (NumberOfActivePlanes > 1) {
5494 ActiveDRAMClockChangeLatencyMarginY = ActiveDRAMClockChangeLatencyMarginY - (1 - 1.0 / NumberOfActivePlanes) * SwathHeightY[k] * HTotal[k] / PixelClock[k] / VRatio[k];
5497 if (BytePerPixelDETC[k] > 0) {
5498 ActiveDRAMClockChangeLatencyMarginC = EffectiveLBLatencyHidingC + FullDETBufferingTimeC - *UrgentWatermark - (HTotal[k] / PixelClock[k]) * (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) - *DRAMClockChangeWatermark;
5500 if (NumberOfActivePlanes > 1) {
5501 ActiveDRAMClockChangeLatencyMarginC = ActiveDRAMClockChangeLatencyMarginC - (1 - 1.0 / NumberOfActivePlanes) * SwathHeightC[k] * HTotal[k] / PixelClock[k] / VRatioChroma[k];
5503 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(ActiveDRAMClockChangeLatencyMarginY, ActiveDRAMClockChangeLatencyMarginC);
5505 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = ActiveDRAMClockChangeLatencyMarginY;
5508 if (WritebackEnable[k] == true) {
5510 WritebackDRAMClockChangeLatencyHiding = WritebackInterfaceBufferSize * 1024 / (WritebackDestinationWidth[k] * WritebackDestinationHeight[k] / (WritebackSourceHeight[k] * HTotal[k] / PixelClock[k]) * 4);
5511 if (WritebackPixelFormat[k] == dm_444_64) {
5512 WritebackDRAMClockChangeLatencyHiding = WritebackDRAMClockChangeLatencyHiding / 2;
5514 if (mode_lib->vba.WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave || mode_lib->vba.WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave) {
5515 WritebackDRAMClockChangeLatencyHiding = WritebackDRAMClockChangeLatencyHiding * 2;
5517 WritebackDRAMClockChangeLatencyMargin = WritebackDRAMClockChangeLatencyHiding - mode_lib->vba.WritebackDRAMClockChangeWatermark;
5518 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], WritebackDRAMClockChangeLatencyMargin);
5522 mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999;
5523 PlaneWithMinActiveDRAMClockChangeMargin = 0;
5524 for (k = 0; k < NumberOfActivePlanes; ++k) {
5525 if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] < mode_lib->vba.MinActiveDRAMClockChangeMargin) {
5526 mode_lib->vba.MinActiveDRAMClockChangeMargin = mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
5527 if (BlendingAndTiming[k] == k) {
5528 PlaneWithMinActiveDRAMClockChangeMargin = k;
5530 for (j = 0; j < NumberOfActivePlanes; ++j) {
5531 if (BlendingAndTiming[k] == j) {
5532 PlaneWithMinActiveDRAMClockChangeMargin = j;
5539 *MinActiveDRAMClockChangeLatencySupported = mode_lib->vba.MinActiveDRAMClockChangeMargin + DRAMClockChangeLatency;
5541 SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = 999999;
5542 for (k = 0; k < NumberOfActivePlanes; ++k) {
5543 if (!((k == PlaneWithMinActiveDRAMClockChangeMargin) && (BlendingAndTiming[k] == k)) && !(BlendingAndTiming[k] == PlaneWithMinActiveDRAMClockChangeMargin) && mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] < SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank) {
5544 SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
5548 mode_lib->vba.TotalNumberOfActiveOTG = 0;
5549 for (k = 0; k < NumberOfActivePlanes; ++k) {
5550 if (BlendingAndTiming[k] == k) {
5551 mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG + 1;
5555 if (mode_lib->vba.MinActiveDRAMClockChangeMargin > 0) {
5556 *DRAMClockChangeSupport = dm_dram_clock_change_vactive;
5557 } else if (((mode_lib->vba.SynchronizedVBlank == true || mode_lib->vba.TotalNumberOfActiveOTG == 1 || SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank > 0) && PrefetchMode == 0)) {
5558 *DRAMClockChangeSupport = dm_dram_clock_change_vblank;
5560 *DRAMClockChangeSupport = dm_dram_clock_change_unsupported;
5563 FullDETBufferingTimeYStutterCriticalPlane = FullDETBufferingTimeY[0];
5564 for (k = 0; k < NumberOfActivePlanes; ++k) {
5565 if (FullDETBufferingTimeY[k] <= FullDETBufferingTimeYStutterCriticalPlane) {
5566 FullDETBufferingTimeYStutterCriticalPlane = FullDETBufferingTimeY[k];
5567 TimeToFinishSwathTransferStutterCriticalPlane = (SwathHeightY[k] - (LinesInDETY[k] - LinesInDETYRoundedDownToSwath[k])) * (HTotal[k] / PixelClock[k]) / VRatio[k];
5571 *StutterExitWatermark = SRExitTime + ExtraLatency + 10 / DCFCLKDeepSleep;
5572 *StutterEnterPlusExitWatermark = dml_max(SREnterPlusExitTime + ExtraLatency + 10 / DCFCLKDeepSleep, TimeToFinishSwathTransferStutterCriticalPlane);
5576 static void CalculateDCFCLKDeepSleep(
5577 struct display_mode_lib *mode_lib,
5578 unsigned int NumberOfActivePlanes,
5579 int BytePerPixelY[],
5580 int BytePerPixelC[],
5582 double VRatioChroma[],
5583 double SwathWidthY[],
5584 double SwathWidthC[],
5585 unsigned int DPPPerPlane[],
5587 double HRatioChroma[],
5588 double PixelClock[],
5589 double PSCL_THROUGHPUT[],
5590 double PSCL_THROUGHPUT_CHROMA[],
5592 double ReadBandwidthLuma[],
5593 double ReadBandwidthChroma[],
5595 double *DCFCLKDeepSleep)
5597 double DisplayPipeLineDeliveryTimeLuma = 0;
5598 double DisplayPipeLineDeliveryTimeChroma = 0;
5600 double ReadBandwidth = 0.0;
5602 //double DCFCLKDeepSleepPerPlane[DC__NUM_DPP__MAX];
5603 for (k = 0; k < NumberOfActivePlanes; ++k) {
5605 if (VRatio[k] <= 1) {
5606 DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5608 DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5610 if (BytePerPixelC[k] == 0) {
5611 DisplayPipeLineDeliveryTimeChroma = 0;
5613 if (VRatioChroma[k] <= 1) {
5614 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5616 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5620 if (BytePerPixelC[k] > 0) {
5621 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);
5623 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1.1 * SwathWidthY[k] * BytePerPixelY[k] / 64.0 / DisplayPipeLineDeliveryTimeLuma;
5625 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max(mode_lib->vba.DCFCLKDeepSleepPerPlane[k], PixelClock[k] / 16);
5629 for (k = 0; k < NumberOfActivePlanes; ++k) {
5630 ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
5633 *DCFCLKDeepSleep = dml_max(8.0, ReadBandwidth / ReturnBusWidth);
5635 for (k = 0; k < NumberOfActivePlanes; ++k) {
5636 *DCFCLKDeepSleep = dml_max(*DCFCLKDeepSleep, mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
5640 static void CalculateUrgentBurstFactor(
5641 long swath_width_luma_ub,
5642 long swath_width_chroma_ub,
5643 unsigned int DETBufferSizeInKByte,
5644 unsigned int SwathHeightY,
5645 unsigned int SwathHeightC,
5647 double UrgentLatency,
5648 double CursorBufferSize,
5649 unsigned int CursorWidth,
5650 unsigned int CursorBPP,
5653 double BytePerPixelInDETY,
5654 double BytePerPixelInDETC,
5655 double DETBufferSizeY,
5656 double DETBufferSizeC,
5657 double *UrgentBurstFactorCursor,
5658 double *UrgentBurstFactorLuma,
5659 double *UrgentBurstFactorChroma,
5660 bool *NotEnoughUrgentLatencyHiding)
5662 double LinesInDETLuma = 0;
5663 double LinesInDETChroma = 0;
5664 unsigned int LinesInCursorBuffer = 0;
5665 double CursorBufferSizeInTime = 0;
5666 double DETBufferSizeInTimeLuma = 0;
5667 double DETBufferSizeInTimeChroma = 0;
5669 *NotEnoughUrgentLatencyHiding = 0;
5671 if (CursorWidth > 0) {
5672 LinesInCursorBuffer = 1 << (unsigned int) dml_floor(dml_log2(CursorBufferSize * 1024.0 / (CursorWidth * CursorBPP / 8.0)), 1.0);
5674 CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio;
5675 if (CursorBufferSizeInTime - UrgentLatency <= 0) {
5676 *NotEnoughUrgentLatencyHiding = 1;
5677 *UrgentBurstFactorCursor = 0;
5679 *UrgentBurstFactorCursor = CursorBufferSizeInTime / (CursorBufferSizeInTime - UrgentLatency);
5682 *UrgentBurstFactorCursor = 1;
5686 LinesInDETLuma = DETBufferSizeY / BytePerPixelInDETY / swath_width_luma_ub;
5688 DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio;
5689 if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) {
5690 *NotEnoughUrgentLatencyHiding = 1;
5691 *UrgentBurstFactorLuma = 0;
5693 *UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency);
5696 *UrgentBurstFactorLuma = 1;
5699 if (BytePerPixelInDETC > 0) {
5700 LinesInDETChroma = DETBufferSizeC / BytePerPixelInDETC / swath_width_chroma_ub;
5702 DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatio;
5703 if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) {
5704 *NotEnoughUrgentLatencyHiding = 1;
5705 *UrgentBurstFactorChroma = 0;
5707 *UrgentBurstFactorChroma = DETBufferSizeInTimeChroma / (DETBufferSizeInTimeChroma - UrgentLatency);
5710 *UrgentBurstFactorChroma = 1;
5715 static void CalculatePixelDeliveryTimes(
5716 unsigned int NumberOfActivePlanes,
5718 double VRatioChroma[],
5719 double VRatioPrefetchY[],
5720 double VRatioPrefetchC[],
5721 unsigned int swath_width_luma_ub[],
5722 unsigned int swath_width_chroma_ub[],
5723 unsigned int DPPPerPlane[],
5725 double HRatioChroma[],
5726 double PixelClock[],
5727 double PSCL_THROUGHPUT[],
5728 double PSCL_THROUGHPUT_CHROMA[],
5730 int BytePerPixelC[],
5731 enum scan_direction_class SourceScan[],
5732 unsigned int NumberOfCursors[],
5733 unsigned int CursorWidth[][2],
5734 unsigned int CursorBPP[][2],
5735 unsigned int BlockWidth256BytesY[],
5736 unsigned int BlockHeight256BytesY[],
5737 unsigned int BlockWidth256BytesC[],
5738 unsigned int BlockHeight256BytesC[],
5739 double DisplayPipeLineDeliveryTimeLuma[],
5740 double DisplayPipeLineDeliveryTimeChroma[],
5741 double DisplayPipeLineDeliveryTimeLumaPrefetch[],
5742 double DisplayPipeLineDeliveryTimeChromaPrefetch[],
5743 double DisplayPipeRequestDeliveryTimeLuma[],
5744 double DisplayPipeRequestDeliveryTimeChroma[],
5745 double DisplayPipeRequestDeliveryTimeLumaPrefetch[],
5746 double DisplayPipeRequestDeliveryTimeChromaPrefetch[],
5747 double CursorRequestDeliveryTime[],
5748 double CursorRequestDeliveryTimePrefetch[])
5750 double req_per_swath_ub = 0;
5753 for (k = 0; k < NumberOfActivePlanes; ++k) {
5754 if (VRatio[k] <= 1) {
5755 DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5757 DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5760 if (BytePerPixelC[k] == 0) {
5761 DisplayPipeLineDeliveryTimeChroma[k] = 0;
5763 if (VRatioChroma[k] <= 1) {
5764 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5766 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5770 if (VRatioPrefetchY[k] <= 1) {
5771 DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] * DPPPerPlane[k] / HRatio[k] / PixelClock[k];
5773 DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / DPPCLK[k];
5776 if (BytePerPixelC[k] == 0) {
5777 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
5779 if (VRatioPrefetchC[k] <= 1) {
5780 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] * DPPPerPlane[k] / HRatioChroma[k] / PixelClock[k];
5782 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / DPPCLK[k];
5787 for (k = 0; k < NumberOfActivePlanes; ++k) {
5788 if (SourceScan[k] != dm_vert) {
5789 req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k];
5791 req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k];
5793 DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub;
5794 DisplayPipeRequestDeliveryTimeLumaPrefetch[k] = DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub;
5795 if (BytePerPixelC[k] == 0) {
5796 DisplayPipeRequestDeliveryTimeChroma[k] = 0;
5797 DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0;
5799 if (SourceScan[k] != dm_vert) {
5800 req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k];
5802 req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k];
5804 DisplayPipeRequestDeliveryTimeChroma[k] = DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub;
5805 DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub;
5809 for (k = 0; k < NumberOfActivePlanes; ++k) {
5810 int cursor_req_per_width = 0;
5811 cursor_req_per_width = dml_ceil(CursorWidth[k][0] * CursorBPP[k][0] / 256 / 8, 1);
5812 if (NumberOfCursors[k] > 0) {
5813 if (VRatio[k] <= 1) {
5814 CursorRequestDeliveryTime[k] = CursorWidth[k][0] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
5816 CursorRequestDeliveryTime[k] = CursorWidth[k][0] / PSCL_THROUGHPUT[k] / DPPCLK[k] / cursor_req_per_width;
5818 if (VRatioPrefetchY[k] <= 1) {
5819 CursorRequestDeliveryTimePrefetch[k] = CursorWidth[k][0] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
5821 CursorRequestDeliveryTimePrefetch[k] = CursorWidth[k][0] / PSCL_THROUGHPUT[k] / DPPCLK[k] / cursor_req_per_width;
5824 CursorRequestDeliveryTime[k] = 0;
5825 CursorRequestDeliveryTimePrefetch[k] = 0;
5830 static void CalculateMetaAndPTETimes(
5831 int NumberOfActivePlanes,
5834 int MinMetaChunkSizeBytes,
5837 double VRatioChroma[],
5838 double DestinationLinesToRequestRowInVBlank[],
5839 double DestinationLinesToRequestRowInImmediateFlip[],
5841 double PixelClock[],
5842 int BytePerPixelY[],
5843 int BytePerPixelC[],
5844 enum scan_direction_class SourceScan[],
5845 int dpte_row_height[],
5846 int dpte_row_height_chroma[],
5847 int meta_row_width[],
5848 int meta_row_width_chroma[],
5849 int meta_row_height[],
5850 int meta_row_height_chroma[],
5851 int meta_req_width[],
5852 int meta_req_width_chroma[],
5853 int meta_req_height[],
5854 int meta_req_height_chroma[],
5855 int dpte_group_bytes[],
5856 int PTERequestSizeY[],
5857 int PTERequestSizeC[],
5858 int PixelPTEReqWidthY[],
5859 int PixelPTEReqHeightY[],
5860 int PixelPTEReqWidthC[],
5861 int PixelPTEReqHeightC[],
5862 int dpte_row_width_luma_ub[],
5863 int dpte_row_width_chroma_ub[],
5864 double DST_Y_PER_PTE_ROW_NOM_L[],
5865 double DST_Y_PER_PTE_ROW_NOM_C[],
5866 double DST_Y_PER_META_ROW_NOM_L[],
5867 double DST_Y_PER_META_ROW_NOM_C[],
5868 double TimePerMetaChunkNominal[],
5869 double TimePerChromaMetaChunkNominal[],
5870 double TimePerMetaChunkVBlank[],
5871 double TimePerChromaMetaChunkVBlank[],
5872 double TimePerMetaChunkFlip[],
5873 double TimePerChromaMetaChunkFlip[],
5874 double time_per_pte_group_nom_luma[],
5875 double time_per_pte_group_vblank_luma[],
5876 double time_per_pte_group_flip_luma[],
5877 double time_per_pte_group_nom_chroma[],
5878 double time_per_pte_group_vblank_chroma[],
5879 double time_per_pte_group_flip_chroma[])
5881 unsigned int meta_chunk_width = 0;
5882 unsigned int min_meta_chunk_width = 0;
5883 unsigned int meta_chunk_per_row_int = 0;
5884 unsigned int meta_row_remainder = 0;
5885 unsigned int meta_chunk_threshold = 0;
5886 unsigned int meta_chunks_per_row_ub = 0;
5887 unsigned int meta_chunk_width_chroma = 0;
5888 unsigned int min_meta_chunk_width_chroma = 0;
5889 unsigned int meta_chunk_per_row_int_chroma = 0;
5890 unsigned int meta_row_remainder_chroma = 0;
5891 unsigned int meta_chunk_threshold_chroma = 0;
5892 unsigned int meta_chunks_per_row_ub_chroma = 0;
5893 unsigned int dpte_group_width_luma = 0;
5894 unsigned int dpte_groups_per_row_luma_ub = 0;
5895 unsigned int dpte_group_width_chroma = 0;
5896 unsigned int dpte_groups_per_row_chroma_ub = 0;
5899 for (k = 0; k < NumberOfActivePlanes; ++k) {
5900 DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k];
5901 if (BytePerPixelC[k] == 0) {
5902 DST_Y_PER_PTE_ROW_NOM_C[k] = 0;
5904 DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k];
5906 DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k];
5907 if (BytePerPixelC[k] == 0) {
5908 DST_Y_PER_META_ROW_NOM_C[k] = 0;
5910 DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k];
5914 for (k = 0; k < NumberOfActivePlanes; ++k) {
5915 if (DCCEnable[k] == true) {
5916 meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k];
5917 min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k];
5918 meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width;
5919 meta_row_remainder = meta_row_width[k] % meta_chunk_width;
5920 if (SourceScan[k] != dm_vert) {
5921 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k];
5923 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k];
5925 if (meta_row_remainder <= meta_chunk_threshold) {
5926 meta_chunks_per_row_ub = meta_chunk_per_row_int + 1;
5928 meta_chunks_per_row_ub = meta_chunk_per_row_int + 2;
5930 TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5931 TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5932 TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
5933 if (BytePerPixelC[k] == 0) {
5934 TimePerChromaMetaChunkNominal[k] = 0;
5935 TimePerChromaMetaChunkVBlank[k] = 0;
5936 TimePerChromaMetaChunkFlip[k] = 0;
5938 meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
5939 min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
5940 meta_chunk_per_row_int_chroma = (double) meta_row_width_chroma[k] / meta_chunk_width_chroma;
5941 meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma;
5942 if (SourceScan[k] != dm_vert) {
5943 meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_width_chroma[k];
5945 meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_height_chroma[k];
5947 if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma) {
5948 meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1;
5950 meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2;
5952 TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5953 TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5954 TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5957 TimePerMetaChunkNominal[k] = 0;
5958 TimePerMetaChunkVBlank[k] = 0;
5959 TimePerMetaChunkFlip[k] = 0;
5960 TimePerChromaMetaChunkNominal[k] = 0;
5961 TimePerChromaMetaChunkVBlank[k] = 0;
5962 TimePerChromaMetaChunkFlip[k] = 0;
5966 for (k = 0; k < NumberOfActivePlanes; ++k) {
5967 if (GPUVMEnable == true) {
5968 if (SourceScan[k] != dm_vert) {
5969 dpte_group_width_luma = dpte_group_bytes[k] / PTERequestSizeY[k] * PixelPTEReqWidthY[k];
5971 dpte_group_width_luma = dpte_group_bytes[k] / PTERequestSizeY[k] * PixelPTEReqHeightY[k];
5973 dpte_groups_per_row_luma_ub = dml_ceil(1.0 * dpte_row_width_luma_ub[k] / dpte_group_width_luma, 1);
5974 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;
5975 time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5976 time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5977 if (BytePerPixelC[k] == 0) {
5978 time_per_pte_group_nom_chroma[k] = 0;
5979 time_per_pte_group_vblank_chroma[k] = 0;
5980 time_per_pte_group_flip_chroma[k] = 0;
5982 if (SourceScan[k] != dm_vert) {
5983 dpte_group_width_chroma = dpte_group_bytes[k] / PTERequestSizeC[k] * PixelPTEReqWidthC[k];
5985 dpte_group_width_chroma = dpte_group_bytes[k] / PTERequestSizeC[k] * PixelPTEReqHeightC[k];
5987 dpte_groups_per_row_chroma_ub = dml_ceil(1.0 * dpte_row_width_chroma_ub[k] / dpte_group_width_chroma, 1);
5988 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;
5989 time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5990 time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5993 time_per_pte_group_nom_luma[k] = 0;
5994 time_per_pte_group_vblank_luma[k] = 0;
5995 time_per_pte_group_flip_luma[k] = 0;
5996 time_per_pte_group_nom_chroma[k] = 0;
5997 time_per_pte_group_vblank_chroma[k] = 0;
5998 time_per_pte_group_flip_chroma[k] = 0;
6003 static void CalculateVMGroupAndRequestTimes(
6004 unsigned int NumberOfActivePlanes,
6006 unsigned int GPUVMMaxPageTableLevels,
6007 unsigned int HTotal[],
6008 int BytePerPixelC[],
6009 double DestinationLinesToRequestVMInVBlank[],
6010 double DestinationLinesToRequestVMInImmediateFlip[],
6012 double PixelClock[],
6013 int dpte_row_width_luma_ub[],
6014 int dpte_row_width_chroma_ub[],
6015 int vm_group_bytes[],
6016 unsigned int dpde0_bytes_per_frame_ub_l[],
6017 unsigned int dpde0_bytes_per_frame_ub_c[],
6018 int meta_pte_bytes_per_frame_ub_l[],
6019 int meta_pte_bytes_per_frame_ub_c[],
6020 double TimePerVMGroupVBlank[],
6021 double TimePerVMGroupFlip[],
6022 double TimePerVMRequestVBlank[],
6023 double TimePerVMRequestFlip[])
6025 int num_group_per_lower_vm_stage = 0;
6026 int num_req_per_lower_vm_stage = 0;
6029 for (k = 0; k < NumberOfActivePlanes; ++k) {
6030 if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) {
6031 if (DCCEnable[k] == false) {
6032 if (BytePerPixelC[k] > 0) {
6033 num_group_per_lower_vm_stage = dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k])
6034 / (double) (vm_group_bytes[k]), 1) + dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k])
6035 / (double) (vm_group_bytes[k]), 1);
6037 num_group_per_lower_vm_stage = dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k])
6038 / (double) (vm_group_bytes[k]), 1);
6041 if (GPUVMMaxPageTableLevels == 1) {
6042 if (BytePerPixelC[k] > 0) {
6043 num_group_per_lower_vm_stage = dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k])
6044 / (double) (vm_group_bytes[k]), 1) + dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k])
6045 / (double) (vm_group_bytes[k]), 1);
6047 num_group_per_lower_vm_stage = dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k])
6048 / (double) (vm_group_bytes[k]), 1);
6051 if (BytePerPixelC[k] > 0) {
6052 num_group_per_lower_vm_stage = 2 + dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
6053 + dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), 1)
6054 + dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
6055 + dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) / (double) (vm_group_bytes[k]), 1);
6057 num_group_per_lower_vm_stage = 1 + dml_ceil((double) (dpde0_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1)
6058 + dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) / (double) (vm_group_bytes[k]), 1);
6063 if (DCCEnable[k] == false) {
6064 if (BytePerPixelC[k] > 0) {
6065 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64;
6067 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64;
6070 if (GPUVMMaxPageTableLevels == 1) {
6071 if (BytePerPixelC[k] > 0) {
6072 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64
6073 + meta_pte_bytes_per_frame_ub_c[k] / 64;
6075 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64;
6078 if (BytePerPixelC[k] > 0) {
6079 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64
6080 + dpde0_bytes_per_frame_ub_c[k] / 64 + meta_pte_bytes_per_frame_ub_l[k]
6081 / 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
6083 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64
6084 + meta_pte_bytes_per_frame_ub_l[k] / 64;
6089 TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k]
6090 / num_group_per_lower_vm_stage;
6091 TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k]
6092 / num_group_per_lower_vm_stage;
6093 TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k]
6094 / num_req_per_lower_vm_stage;
6095 TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k]
6096 / num_req_per_lower_vm_stage;
6098 if (GPUVMMaxPageTableLevels > 2) {
6099 TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2;
6100 TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2;
6101 TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2;
6102 TimePerVMRequestFlip[k] = TimePerVMRequestFlip[k] / 2;
6106 TimePerVMGroupVBlank[k] = 0;
6107 TimePerVMGroupFlip[k] = 0;
6108 TimePerVMRequestVBlank[k] = 0;
6109 TimePerVMRequestFlip[k] = 0;
6114 static void CalculateStutterEfficiency(
6115 int NumberOfActivePlanes,
6116 long ROBBufferSizeInKByte,
6117 double TotalDataReadBandwidth,
6121 bool SynchronizedVBlank,
6123 double DETBufferSizeY[],
6124 int BytePerPixelY[],
6125 double BytePerPixelDETY[],
6126 double SwathWidthY[],
6129 double DCCRateLuma[],
6130 double DCCRateChroma[],
6133 double PixelClock[],
6135 enum scan_direction_class SourceScan[],
6136 int BlockHeight256BytesY[],
6137 int BlockWidth256BytesY[],
6138 int BlockHeight256BytesC[],
6139 int BlockWidth256BytesC[],
6140 int DCCYMaxUncompressedBlock[],
6141 int DCCCMaxUncompressedBlock[],
6144 bool WritebackEnable[],
6145 double ReadBandwidthPlaneLuma[],
6146 double ReadBandwidthPlaneChroma[],
6147 double meta_row_bw[],
6148 double dpte_row_bw[],
6149 double *StutterEfficiencyNotIncludingVBlank,
6150 double *StutterEfficiency)
6152 double FullDETBufferingTimeY[DC__NUM_DPP__MAX] = { 0 };
6153 double FrameTimeForMinFullDETBufferingTime = 0;
6154 double StutterPeriod = 0;
6155 double AverageReadBandwidth = 0;
6156 double TotalRowReadBandwidth = 0;
6157 double AverageDCCCompressionRate = 0;
6158 double PartOfBurstThatFitsInROB = 0;
6159 double StutterBurstTime = 0;
6160 int TotalActiveWriteback = 0;
6161 double VBlankTime = 0;
6162 double SmallestVBlank = 0;
6163 int BytePerPixelYCriticalPlane = 0;
6164 double SwathWidthYCriticalPlane = 0;
6165 double LinesInDETY[DC__NUM_DPP__MAX] = { 0 };
6166 double LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX] = { 0 };
6167 double LinesToFinishSwathTransferStutterCriticalPlane = 0;
6168 double MaximumEffectiveCompressionLuma = 0;
6169 double MaximumEffectiveCompressionChroma = 0;
6172 for (k = 0; k < NumberOfActivePlanes; ++k) {
6173 LinesInDETY[k] = DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k];
6174 LinesInDETYRoundedDownToSwath[k] = dml_floor(LinesInDETY[k], SwathHeightY[k]);
6175 FullDETBufferingTimeY[k] = LinesInDETYRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) / VRatio[k];
6178 StutterPeriod = FullDETBufferingTimeY[0];
6179 FrameTimeForMinFullDETBufferingTime = VTotal[0] * HTotal[0] / PixelClock[0];
6180 BytePerPixelYCriticalPlane = BytePerPixelY[0];
6181 SwathWidthYCriticalPlane = SwathWidthY[0];
6182 LinesToFinishSwathTransferStutterCriticalPlane = SwathHeightY[0]
6183 - (LinesInDETY[0] - LinesInDETYRoundedDownToSwath[0]);
6185 for (k = 0; k < NumberOfActivePlanes; ++k) {
6186 if (FullDETBufferingTimeY[k] < StutterPeriod) {
6187 StutterPeriod = FullDETBufferingTimeY[k];
6188 FrameTimeForMinFullDETBufferingTime = VTotal[k] * HTotal[k] / PixelClock[k];
6189 BytePerPixelYCriticalPlane = BytePerPixelY[k];
6190 SwathWidthYCriticalPlane = SwathWidthY[k];
6191 LinesToFinishSwathTransferStutterCriticalPlane = SwathHeightY[k]
6192 - (LinesInDETY[k] - LinesInDETYRoundedDownToSwath[k]);
6196 AverageReadBandwidth = 0;
6197 TotalRowReadBandwidth = 0;
6198 for (k = 0; k < NumberOfActivePlanes; ++k) {
6199 if (DCCEnable[k] == true) {
6200 if ((SourceScan[k] == dm_vert && BlockWidth256BytesY[k] > SwathHeightY[k])
6201 || (SourceScan[k] != dm_vert
6202 && BlockHeight256BytesY[k] > SwathHeightY[k])
6203 || DCCYMaxUncompressedBlock[k] < 256) {
6204 MaximumEffectiveCompressionLuma = 2;
6206 MaximumEffectiveCompressionLuma = 4;
6208 AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneLuma[k] / dml_min(DCCRateLuma[k], MaximumEffectiveCompressionLuma);
6210 if (ReadBandwidthPlaneChroma[k] > 0) {
6211 if ((SourceScan[k] == dm_vert && BlockWidth256BytesC[k] > SwathHeightC[k])
6212 || (SourceScan[k] != dm_vert && BlockHeight256BytesC[k] > SwathHeightC[k])
6213 || DCCCMaxUncompressedBlock[k] < 256) {
6214 MaximumEffectiveCompressionChroma = 2;
6216 MaximumEffectiveCompressionChroma = 4;
6218 AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneChroma[k] / dml_min(DCCRateChroma[k], MaximumEffectiveCompressionChroma);
6221 AverageReadBandwidth = AverageReadBandwidth + ReadBandwidthPlaneLuma[k] + ReadBandwidthPlaneChroma[k];
6223 TotalRowReadBandwidth = TotalRowReadBandwidth + DPPPerPlane[k] * (meta_row_bw[k] + dpte_row_bw[k]);
6226 AverageDCCCompressionRate = TotalDataReadBandwidth / AverageReadBandwidth;
6227 PartOfBurstThatFitsInROB = dml_min(StutterPeriod * TotalDataReadBandwidth, ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate);
6228 StutterBurstTime = PartOfBurstThatFitsInROB / AverageDCCCompressionRate / ReturnBW + (StutterPeriod * TotalDataReadBandwidth
6229 - PartOfBurstThatFitsInROB) / (DCFCLK * 64) + StutterPeriod * TotalRowReadBandwidth / ReturnBW;
6230 StutterBurstTime = dml_max(StutterBurstTime, LinesToFinishSwathTransferStutterCriticalPlane * BytePerPixelYCriticalPlane * SwathWidthYCriticalPlane / ReturnBW);
6232 TotalActiveWriteback = 0;
6233 for (k = 0; k < NumberOfActivePlanes; ++k) {
6234 if (WritebackEnable[k] == true) {
6235 TotalActiveWriteback = TotalActiveWriteback + 1;
6239 if (TotalActiveWriteback == 0) {
6240 *StutterEfficiencyNotIncludingVBlank = (1
6241 - (SRExitTime + StutterBurstTime) / StutterPeriod) * 100;
6243 *StutterEfficiencyNotIncludingVBlank = 0;
6246 if (SynchronizedVBlank == true || NumberOfActivePlanes == 1) {
6247 SmallestVBlank = (VTotal[0] - VActive[0]) * HTotal[0] / PixelClock[0];
6251 for (k = 0; k < NumberOfActivePlanes; ++k) {
6252 if (SynchronizedVBlank == true || NumberOfActivePlanes == 1) {
6253 VBlankTime = (VTotal[k] - VActive[k]) * HTotal[k] / PixelClock[k];
6257 SmallestVBlank = dml_min(SmallestVBlank, VBlankTime);
6260 *StutterEfficiency = (*StutterEfficiencyNotIncludingVBlank / 100.0 * (FrameTimeForMinFullDETBufferingTime - SmallestVBlank) + SmallestVBlank) / FrameTimeForMinFullDETBufferingTime * 100;
6263 static void CalculateSwathAndDETConfiguration(
6264 bool ForceSingleDPP,
6265 int NumberOfActivePlanes,
6266 long DETBufferSizeInKByte,
6267 double MaximumSwathWidthLuma[],
6268 double MaximumSwathWidthChroma[],
6269 enum scan_direction_class SourceScan[],
6270 enum source_format_class SourcePixelFormat[],
6271 enum dm_swizzle_mode SurfaceTiling[],
6272 int ViewportWidth[],
6273 int ViewportHeight[],
6274 int SurfaceWidthY[],
6275 int SurfaceWidthC[],
6276 int SurfaceHeightY[],
6277 int SurfaceHeightC[],
6278 int Read256BytesBlockHeightY[],
6279 int Read256BytesBlockHeightC[],
6280 int Read256BytesBlockWidthY[],
6281 int Read256BytesBlockWidthC[],
6282 enum odm_combine_mode ODMCombineEnabled[],
6283 int BlendingAndTiming[],
6286 double BytePerPixDETY[],
6287 double BytePerPixDETC[],
6290 double HRatioChroma[],
6292 int swath_width_luma_ub[],
6293 int swath_width_chroma_ub[],
6294 double SwathWidth[],
6295 double SwathWidthChroma[],
6298 double DETBufferSizeY[],
6299 double DETBufferSizeC[],
6300 bool ViewportSizeSupportPerPlane[],
6301 bool *ViewportSizeSupport)
6303 int MaximumSwathHeightY[DC__NUM_DPP__MAX] = { 0 };
6304 int MaximumSwathHeightC[DC__NUM_DPP__MAX] = { 0 };
6305 int MinimumSwathHeightY = 0;
6306 int MinimumSwathHeightC = 0;
6307 long RoundedUpMaxSwathSizeBytesY = 0;
6308 long RoundedUpMaxSwathSizeBytesC = 0;
6309 long RoundedUpMinSwathSizeBytesY = 0;
6310 long RoundedUpMinSwathSizeBytesC = 0;
6311 long RoundedUpSwathSizeBytesY = 0;
6312 long RoundedUpSwathSizeBytesC = 0;
6313 double SwathWidthSingleDPP[DC__NUM_DPP__MAX] = { 0 };
6314 double SwathWidthSingleDPPChroma[DC__NUM_DPP__MAX] = { 0 };
6317 CalculateSwathWidth(
6319 NumberOfActivePlanes,
6331 Read256BytesBlockHeightY,
6332 Read256BytesBlockHeightC,
6333 Read256BytesBlockWidthY,
6334 Read256BytesBlockWidthC,
6339 SwathWidthSingleDPP,
6340 SwathWidthSingleDPPChroma,
6343 MaximumSwathHeightY,
6344 MaximumSwathHeightC,
6345 swath_width_luma_ub,
6346 swath_width_chroma_ub);
6348 *ViewportSizeSupport = true;
6349 for (k = 0; k < NumberOfActivePlanes; ++k) {
6350 if ((SourcePixelFormat[k] == dm_444_64 || SourcePixelFormat[k] == dm_444_32
6351 || SourcePixelFormat[k] == dm_444_16
6352 || SourcePixelFormat[k] == dm_mono_16
6353 || SourcePixelFormat[k] == dm_mono_8
6354 || SourcePixelFormat[k] == dm_rgbe)) {
6355 if (SurfaceTiling[k] == dm_sw_linear
6356 || (SourcePixelFormat[k] == dm_444_64
6357 && (SurfaceTiling[k] == dm_sw_64kb_s || SurfaceTiling[k] == dm_sw_64kb_s_t || SurfaceTiling[k] == dm_sw_64kb_s_x)
6358 && SourceScan[k] != dm_vert)) {
6359 MinimumSwathHeightY = MaximumSwathHeightY[k];
6360 } else if (SourcePixelFormat[k] == dm_444_8 && SourceScan[k] == dm_vert) {
6361 MinimumSwathHeightY = MaximumSwathHeightY[k];
6363 MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6365 MinimumSwathHeightC = MaximumSwathHeightC[k];
6367 if (SurfaceTiling[k] == dm_sw_linear) {
6368 MinimumSwathHeightY = MaximumSwathHeightY[k];
6369 MinimumSwathHeightC = MaximumSwathHeightC[k];
6370 } else if (SourcePixelFormat[k] == dm_rgbe_alpha
6371 && SourceScan[k] == dm_vert) {
6372 MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6373 MinimumSwathHeightC = MaximumSwathHeightC[k];
6374 } else if (SourcePixelFormat[k] == dm_rgbe_alpha) {
6375 MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6376 MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6377 } else if (SourcePixelFormat[k] == dm_420_8 && SourceScan[k] == dm_vert) {
6378 MinimumSwathHeightY = MaximumSwathHeightY[k];
6379 MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6381 MinimumSwathHeightC = MaximumSwathHeightC[k] / 2;
6382 MinimumSwathHeightY = MaximumSwathHeightY[k] / 2;
6386 RoundedUpMaxSwathSizeBytesY = swath_width_luma_ub[k] * BytePerPixDETY[k]
6387 * MaximumSwathHeightY[k];
6388 RoundedUpMinSwathSizeBytesY = swath_width_luma_ub[k] * BytePerPixDETY[k]
6389 * MinimumSwathHeightY;
6390 if (SourcePixelFormat[k] == dm_420_10) {
6391 RoundedUpMaxSwathSizeBytesY = dml_ceil((double) RoundedUpMaxSwathSizeBytesY, 256);
6392 RoundedUpMinSwathSizeBytesY = dml_ceil((double) RoundedUpMinSwathSizeBytesY, 256);
6394 RoundedUpMaxSwathSizeBytesC = swath_width_chroma_ub[k] * BytePerPixDETC[k]
6395 * MaximumSwathHeightC[k];
6396 RoundedUpMinSwathSizeBytesC = swath_width_chroma_ub[k] * BytePerPixDETC[k]
6397 * MinimumSwathHeightC;
6398 if (SourcePixelFormat[k] == dm_420_10) {
6399 RoundedUpMaxSwathSizeBytesC = dml_ceil(RoundedUpMaxSwathSizeBytesC, 256);
6400 RoundedUpMinSwathSizeBytesC = dml_ceil(RoundedUpMinSwathSizeBytesC, 256);
6403 if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
6404 <= DETBufferSizeInKByte * 1024 / 2) {
6405 SwathHeightY[k] = MaximumSwathHeightY[k];
6406 SwathHeightC[k] = MaximumSwathHeightC[k];
6407 RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY;
6408 RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC;
6409 } else if (RoundedUpMaxSwathSizeBytesY >= 1.5 * RoundedUpMaxSwathSizeBytesC
6410 && RoundedUpMinSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
6411 <= DETBufferSizeInKByte * 1024 / 2) {
6412 SwathHeightY[k] = MinimumSwathHeightY;
6413 SwathHeightC[k] = MaximumSwathHeightC[k];
6414 RoundedUpSwathSizeBytesY = RoundedUpMinSwathSizeBytesY;
6415 RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC;
6416 } else if (RoundedUpMaxSwathSizeBytesY < 1.5 * RoundedUpMaxSwathSizeBytesC
6417 && RoundedUpMaxSwathSizeBytesY + RoundedUpMinSwathSizeBytesC
6418 <= DETBufferSizeInKByte * 1024 / 2) {
6419 SwathHeightY[k] = MaximumSwathHeightY[k];
6420 SwathHeightC[k] = MinimumSwathHeightC;
6421 RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY;
6422 RoundedUpSwathSizeBytesC = RoundedUpMinSwathSizeBytesC;
6424 SwathHeightY[k] = MinimumSwathHeightY;
6425 SwathHeightC[k] = MinimumSwathHeightC;
6426 RoundedUpSwathSizeBytesY = RoundedUpMinSwathSizeBytesY;
6427 RoundedUpSwathSizeBytesC = RoundedUpMinSwathSizeBytesC;
6430 if (SwathHeightC[k] == 0) {
6431 DETBufferSizeY[k] = DETBufferSizeInKByte * 1024;
6432 DETBufferSizeC[k] = 0;
6433 } else if (RoundedUpSwathSizeBytesY <= 1.5 * RoundedUpSwathSizeBytesC) {
6434 DETBufferSizeY[k] = DETBufferSizeInKByte * 1024 / 2;
6435 DETBufferSizeC[k] = DETBufferSizeInKByte * 1024 / 2;
6437 DETBufferSizeY[k] = DETBufferSizeInKByte * 1024 * 2 / 3;
6438 DETBufferSizeC[k] = DETBufferSizeInKByte * 1024 / 3;
6441 if (RoundedUpMinSwathSizeBytesY + RoundedUpMinSwathSizeBytesC
6442 > DETBufferSizeInKByte * 1024 / 2
6443 || SwathWidth[k] > MaximumSwathWidthLuma[k]
6444 || (SwathHeightC[k] > 0
6445 && SwathWidthChroma[k] > MaximumSwathWidthChroma[k])) {
6446 *ViewportSizeSupport = false;
6447 ViewportSizeSupportPerPlane[k] = false;
6449 ViewportSizeSupportPerPlane[k] = true;
6454 static void CalculateSwathWidth(
6455 bool ForceSingleDPP,
6456 int NumberOfActivePlanes,
6457 enum source_format_class SourcePixelFormat[],
6458 enum scan_direction_class SourceScan[],
6459 unsigned int ViewportWidth[],
6460 unsigned int ViewportHeight[],
6461 unsigned int SurfaceWidthY[],
6462 unsigned int SurfaceWidthC[],
6463 unsigned int SurfaceHeightY[],
6464 unsigned int SurfaceHeightC[],
6465 enum odm_combine_mode ODMCombineEnabled[],
6468 int Read256BytesBlockHeightY[],
6469 int Read256BytesBlockHeightC[],
6470 int Read256BytesBlockWidthY[],
6471 int Read256BytesBlockWidthC[],
6472 int BlendingAndTiming[],
6473 unsigned int HActive[],
6476 double SwathWidthSingleDPPY[],
6477 double SwathWidthSingleDPPC[],
6478 double SwathWidthY[],
6479 double SwathWidthC[],
6480 int MaximumSwathHeightY[],
6481 int MaximumSwathHeightC[],
6482 unsigned int swath_width_luma_ub[],
6483 unsigned int swath_width_chroma_ub[])
6486 long surface_width_ub_l;
6487 long surface_height_ub_l;
6488 long surface_width_ub_c;
6489 long surface_height_ub_c;
6491 for (k = 0; k < NumberOfActivePlanes; ++k) {
6492 enum odm_combine_mode MainPlaneODMCombine = 0;
6493 surface_width_ub_l = dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
6494 surface_height_ub_l = dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
6495 surface_width_ub_c = dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
6496 surface_height_ub_c = dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
6498 if (SourceScan[k] != dm_vert) {
6499 SwathWidthSingleDPPY[k] = ViewportWidth[k];
6501 SwathWidthSingleDPPY[k] = ViewportHeight[k];
6504 MainPlaneODMCombine = ODMCombineEnabled[k];
6505 for (j = 0; j < NumberOfActivePlanes; ++j) {
6506 if (BlendingAndTiming[k] == j) {
6507 MainPlaneODMCombine = ODMCombineEnabled[j];
6511 if (MainPlaneODMCombine == dm_odm_combine_mode_4to1) {
6512 SwathWidthY[k] = dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 4.0 * HRatio[k]));
6513 } else if (MainPlaneODMCombine == dm_odm_combine_mode_2to1) {
6514 SwathWidthY[k] = dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 2.0 * HRatio[k]));
6515 } else if (DPPPerPlane[k] == 2) {
6516 SwathWidthY[k] = SwathWidthSingleDPPY[k] / 2;
6518 SwathWidthY[k] = SwathWidthSingleDPPY[k];
6521 if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 || SourcePixelFormat[k] == dm_420_12) {
6522 SwathWidthC[k] = SwathWidthY[k] / 2;
6523 SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k] / 2;
6525 SwathWidthC[k] = SwathWidthY[k];
6526 SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k];
6529 if (ForceSingleDPP == true) {
6530 SwathWidthY[k] = SwathWidthSingleDPPY[k];
6531 SwathWidthC[k] = SwathWidthSingleDPPC[k];
6534 surface_width_ub_l = dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
6535 surface_height_ub_l = dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
6536 surface_width_ub_c = dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
6537 surface_height_ub_c = dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
6539 if (SourceScan[k] != dm_vert) {
6540 MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k];
6541 MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k];
6542 swath_width_luma_ub[k] = dml_min(surface_width_ub_l, (long) dml_ceil(SwathWidthY[k] - 1,
6543 Read256BytesBlockWidthY[k]) + Read256BytesBlockWidthY[k]);
6544 if (BytePerPixC[k] > 0) {
6545 swath_width_chroma_ub[k] = dml_min(surface_width_ub_c, (long) dml_ceil(SwathWidthC[k] - 1,
6546 Read256BytesBlockWidthC[k]) + Read256BytesBlockWidthC[k]);
6548 swath_width_chroma_ub[k] = 0;
6551 MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k];
6552 MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k];
6553 swath_width_luma_ub[k] = dml_min(surface_height_ub_l, (long) dml_ceil(SwathWidthY[k] - 1,
6554 Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]);
6555 if (BytePerPixC[k] > 0) {
6556 swath_width_chroma_ub[k] = dml_min(surface_height_ub_c, (long) dml_ceil(SwathWidthC[k] - 1,
6557 Read256BytesBlockHeightC[k]) + Read256BytesBlockHeightC[k]);
6559 swath_width_chroma_ub[k] = 0;
6565 static double CalculateExtraLatency(
6566 long RoundTripPingLatencyCycles,
6567 long ReorderingBytes,
6569 int TotalNumberOfActiveDPP,
6570 int PixelChunkSizeInKByte,
6571 int TotalNumberOfDCCActiveDPP,
6576 int NumberOfActivePlanes,
6578 int dpte_group_bytes[],
6579 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6580 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6581 double HostVMMinPageSize,
6582 int HostVMMaxNonCachedPageTableLevels)
6584 double ExtraLatencyBytes = 0;
6585 ExtraLatencyBytes = CalculateExtraLatencyBytes(
6587 TotalNumberOfActiveDPP,
6588 PixelChunkSizeInKByte,
6589 TotalNumberOfDCCActiveDPP,
6593 NumberOfActivePlanes,
6596 PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6597 PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6599 HostVMMaxNonCachedPageTableLevels);
6601 return (RoundTripPingLatencyCycles + 32) / DCFCLK + ExtraLatencyBytes / ReturnBW;
6604 static double CalculateExtraLatencyBytes(
6605 long ReorderingBytes,
6606 int TotalNumberOfActiveDPP,
6607 int PixelChunkSizeInKByte,
6608 int TotalNumberOfDCCActiveDPP,
6612 int NumberOfActivePlanes,
6614 int dpte_group_bytes[],
6615 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6616 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6617 double HostVMMinPageSize,
6618 int HostVMMaxNonCachedPageTableLevels)
6621 double HostVMInefficiencyFactor = 0;
6622 int HostVMDynamicLevels = 0;
6625 if (GPUVMEnable == true && HostVMEnable == true) {
6626 HostVMInefficiencyFactor = PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly;
6627 if (HostVMMinPageSize < 2048) {
6628 HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
6629 } else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) {
6630 HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
6632 HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
6635 HostVMInefficiencyFactor = 1;
6636 HostVMDynamicLevels = 0;
6639 ret = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte + TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0;
6641 if (GPUVMEnable == true) {
6642 for (k = 0; k < NumberOfActivePlanes; ++k) {
6643 ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] * (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor;
6650 static double CalculateUrgentLatency(
6651 double UrgentLatencyPixelDataOnly,
6652 double UrgentLatencyPixelMixedWithVMData,
6653 double UrgentLatencyVMDataOnly,
6654 bool DoUrgentLatencyAdjustment,
6655 double UrgentLatencyAdjustmentFabricClockComponent,
6656 double UrgentLatencyAdjustmentFabricClockReference,
6661 ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly);
6662 if (DoUrgentLatencyAdjustment == true) {
6663 ret = ret + UrgentLatencyAdjustmentFabricClockComponent * (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
6669 static void UseMinimumDCFCLK(
6670 struct display_mode_lib *mode_lib,
6671 int MaxInterDCNTileRepeaters,
6672 int MaxPrefetchMode,
6673 double FinalDRAMClockChangeLatency,
6674 double SREnterPlusExitTime,
6676 int RoundTripPingLatencyCycles,
6677 int ReorderingBytes,
6678 int PixelChunkSizeInKByte,
6681 int GPUVMMaxPageTableLevels,
6683 int NumberOfActivePlanes,
6684 double HostVMMinPageSize,
6685 int HostVMMaxNonCachedPageTableLevels,
6686 bool DynamicMetadataVMEnabled,
6687 enum immediate_flip_requirement ImmediateFlipRequirement,
6688 bool ProgressiveToInterlaceUnitInOPP,
6689 double MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
6690 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
6691 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6692 double PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly,
6695 int DynamicMetadataTransmittedBytes[],
6696 int DynamicMetadataLinesBeforeActiveRequired[],
6698 double RequiredDPPCLK[][2][DC__NUM_DPP__MAX],
6699 double RequiredDISPCLK[][2],
6700 double UrgLatency[],
6701 unsigned int NoOfDPP[][2][DC__NUM_DPP__MAX],
6702 double ProjectedDCFCLKDeepSleep[][2],
6703 double MaximumVStartup[][2][DC__NUM_DPP__MAX],
6704 double TotalVActivePixelBandwidth[][2],
6705 double TotalVActiveCursorBandwidth[][2],
6706 double TotalMetaRowBandwidth[][2],
6707 double TotalDPTERowBandwidth[][2],
6708 unsigned int TotalNumberOfActiveDPP[][2],
6709 unsigned int TotalNumberOfDCCActiveDPP[][2],
6710 int dpte_group_bytes[],
6711 double PrefetchLinesY[][2][DC__NUM_DPP__MAX],
6712 double PrefetchLinesC[][2][DC__NUM_DPP__MAX],
6713 int swath_width_luma_ub_all_states[][2][DC__NUM_DPP__MAX],
6714 int swath_width_chroma_ub_all_states[][2][DC__NUM_DPP__MAX],
6715 int BytePerPixelY[],
6716 int BytePerPixelC[],
6718 double PixelClock[],
6719 double PDEAndMetaPTEBytesPerFrame[][2][DC__NUM_DPP__MAX],
6720 double DPTEBytesPerRow[][2][DC__NUM_DPP__MAX],
6721 double MetaRowBytes[][2][DC__NUM_DPP__MAX],
6722 bool DynamicMetadataEnable[],
6723 double VActivePixelBandwidth[][2][DC__NUM_DPP__MAX],
6724 double VActiveCursorBandwidth[][2][DC__NUM_DPP__MAX],
6725 double ReadBandwidthLuma[],
6726 double ReadBandwidthChroma[],
6727 double DCFCLKPerState[],
6728 double DCFCLKState[][2])
6730 double NormalEfficiency = 0;
6731 double PTEEfficiency = 0;
6732 double TotalMaxPrefetchFlipDPTERowBandwidth[DC__VOLTAGE_STATES][2] = { { 0 } };
6733 unsigned int i, j, k;
6735 NormalEfficiency = (HostVMEnable == true ? PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData
6736 : PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly) / 100.0;
6737 PTEEfficiency = (HostVMEnable == true ? PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly
6738 / PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData : 1.0);
6739 for (i = 0; i < mode_lib->soc.num_states; ++i) {
6740 for (j = 0; j <= 1; ++j) {
6741 double PixelDCFCLKCyclesRequiredInPrefetch[DC__NUM_DPP__MAX] = { 0 };
6742 double PrefetchPixelLinesTime[DC__NUM_DPP__MAX] = { 0 };
6743 double DCFCLKRequiredForPeakBandwidthPerPlane[DC__NUM_DPP__MAX] = { 0 };
6744 double DynamicMetadataVMExtraLatency[DC__NUM_DPP__MAX] = { 0 };
6745 double MinimumTWait = 0;
6746 double NonDPTEBandwidth = 0;
6747 double DPTEBandwidth = 0;
6748 double DCFCLKRequiredForAverageBandwidth = 0;
6749 double ExtraLatencyBytes = 0;
6750 double ExtraLatencyCycles = 0;
6751 double DCFCLKRequiredForPeakBandwidth = 0;
6752 int NoOfDPPState[DC__NUM_DPP__MAX] = { 0 };
6753 double MinimumTvmPlus2Tr0 = 0;
6755 TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = 0;
6756 for (k = 0; k < NumberOfActivePlanes; ++k) {
6757 TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = TotalMaxPrefetchFlipDPTERowBandwidth[i][j]
6758 + NoOfDPP[i][j][k] * DPTEBytesPerRow[i][j][k] / (15.75 * HTotal[k] / PixelClock[k]);
6761 for (k = 0; k <= NumberOfActivePlanes - 1; ++k) {
6762 NoOfDPPState[k] = NoOfDPP[i][j][k];
6765 MinimumTWait = CalculateTWait(MaxPrefetchMode, FinalDRAMClockChangeLatency, UrgLatency[i], SREnterPlusExitTime);
6766 NonDPTEBandwidth = TotalVActivePixelBandwidth[i][j] + TotalVActiveCursorBandwidth[i][j] + TotalMetaRowBandwidth[i][j];
6767 DPTEBandwidth = (HostVMEnable == true || ImmediateFlipRequirement == dm_immediate_flip_required) ?
6768 TotalMaxPrefetchFlipDPTERowBandwidth[i][j] : TotalDPTERowBandwidth[i][j];
6769 DCFCLKRequiredForAverageBandwidth = dml_max3(ProjectedDCFCLKDeepSleep[i][j],
6770 (NonDPTEBandwidth + TotalDPTERowBandwidth[i][j]) / ReturnBusWidth / (MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100),
6771 (NonDPTEBandwidth + DPTEBandwidth / PTEEfficiency) / NormalEfficiency / ReturnBusWidth);
6773 ExtraLatencyBytes = CalculateExtraLatencyBytes(ReorderingBytes, TotalNumberOfActiveDPP[i][j], PixelChunkSizeInKByte, TotalNumberOfDCCActiveDPP[i][j],
6774 MetaChunkSize, GPUVMEnable, HostVMEnable, NumberOfActivePlanes, NoOfDPPState, dpte_group_bytes,
6775 PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData, PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
6776 HostVMMinPageSize, HostVMMaxNonCachedPageTableLevels);
6777 ExtraLatencyCycles = RoundTripPingLatencyCycles + 32 + ExtraLatencyBytes / NormalEfficiency / ReturnBusWidth;
6778 for (k = 0; k < NumberOfActivePlanes; ++k) {
6779 double DCFCLKCyclesRequiredInPrefetch = { 0 };
6780 double ExpectedPrefetchBWAcceleration = { 0 };
6781 double PrefetchTime = { 0 };
6783 PixelDCFCLKCyclesRequiredInPrefetch[k] = (PrefetchLinesY[i][j][k] * swath_width_luma_ub_all_states[i][j][k] * BytePerPixelY[k]
6784 + PrefetchLinesC[i][j][k] * swath_width_chroma_ub_all_states[i][j][k] * BytePerPixelC[k]) / NormalEfficiency / ReturnBusWidth;
6785 DCFCLKCyclesRequiredInPrefetch = 2 * ExtraLatencyCycles / NoOfDPPState[k] + PDEAndMetaPTEBytesPerFrame[i][j][k] / PTEEfficiency
6786 / NormalEfficiency / ReturnBusWidth * (GPUVMMaxPageTableLevels > 2 ? 1 : 0) + 2 * DPTEBytesPerRow[i][j][k] / PTEEfficiency
6787 / NormalEfficiency / ReturnBusWidth + 2 * MetaRowBytes[i][j][k] / NormalEfficiency / ReturnBusWidth + PixelDCFCLKCyclesRequiredInPrefetch[k];
6788 PrefetchPixelLinesTime[k] = dml_max(PrefetchLinesY[i][j][k], PrefetchLinesC[i][j][k]) * HTotal[k] / PixelClock[k];
6789 ExpectedPrefetchBWAcceleration = (VActivePixelBandwidth[i][j][k] + VActiveCursorBandwidth[i][j][k]) / (ReadBandwidthLuma[k] + ReadBandwidthChroma[k]);
6790 DynamicMetadataVMExtraLatency[k] = (GPUVMEnable == true && DynamicMetadataEnable[k] == true && DynamicMetadataVMEnabled == true) ?
6791 UrgLatency[i] * GPUVMMaxPageTableLevels * (HostVMEnable == true ? HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0;
6792 PrefetchTime = (MaximumVStartup[i][j][k] - 1) * HTotal[k] / PixelClock[k] - MinimumTWait - UrgLatency[i] * ((GPUVMMaxPageTableLevels <= 2 ? GPUVMMaxPageTableLevels
6793 : GPUVMMaxPageTableLevels - 2) * (HostVMEnable == true ? HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) - DynamicMetadataVMExtraLatency[k];
6795 if (PrefetchTime > 0) {
6796 double ExpectedVRatioPrefetch = { 0 };
6797 ExpectedVRatioPrefetch = PrefetchPixelLinesTime[k] / (PrefetchTime * PixelDCFCLKCyclesRequiredInPrefetch[k] / DCFCLKCyclesRequiredInPrefetch);
6798 DCFCLKRequiredForPeakBandwidthPerPlane[k] = NoOfDPPState[k] * PixelDCFCLKCyclesRequiredInPrefetch[k] / PrefetchPixelLinesTime[k]
6799 * dml_max(1.0, ExpectedVRatioPrefetch) * dml_max(1.0, ExpectedVRatioPrefetch / 4) * ExpectedPrefetchBWAcceleration;
6800 if (HostVMEnable == true || ImmediateFlipRequirement == dm_immediate_flip_required) {
6801 DCFCLKRequiredForPeakBandwidthPerPlane[k] = DCFCLKRequiredForPeakBandwidthPerPlane[k]
6802 + NoOfDPPState[k] * DPTEBandwidth / PTEEfficiency / NormalEfficiency / ReturnBusWidth;
6805 DCFCLKRequiredForPeakBandwidthPerPlane[k] = DCFCLKPerState[i];
6807 if (DynamicMetadataEnable[k] == true) {
6808 double TsetupPipe = { 0 };
6809 double TdmbfPipe = { 0 };
6810 double TdmsksPipe = { 0 };
6811 double TdmecPipe = { 0 };
6812 double AllowedTimeForUrgentExtraLatency = { 0 };
6814 CalculateDynamicMetadataParameters(
6815 MaxInterDCNTileRepeaters,
6816 RequiredDPPCLK[i][j][k],
6817 RequiredDISPCLK[i][j],
6818 ProjectedDCFCLKDeepSleep[i][j],
6821 VTotal[k] - VActive[k],
6822 DynamicMetadataTransmittedBytes[k],
6823 DynamicMetadataLinesBeforeActiveRequired[k],
6825 ProgressiveToInterlaceUnitInOPP,
6830 AllowedTimeForUrgentExtraLatency = MaximumVStartup[i][j][k] * HTotal[k] / PixelClock[k] - MinimumTWait - TsetupPipe
6831 - TdmbfPipe - TdmecPipe - TdmsksPipe - DynamicMetadataVMExtraLatency[k];
6832 if (AllowedTimeForUrgentExtraLatency > 0) {
6833 DCFCLKRequiredForPeakBandwidthPerPlane[k] = dml_max(DCFCLKRequiredForPeakBandwidthPerPlane[k],
6834 ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency);
6836 DCFCLKRequiredForPeakBandwidthPerPlane[k] = DCFCLKPerState[i];
6840 DCFCLKRequiredForPeakBandwidth = 0;
6841 for (k = 0; k <= NumberOfActivePlanes - 1; ++k) {
6842 DCFCLKRequiredForPeakBandwidth = DCFCLKRequiredForPeakBandwidth + DCFCLKRequiredForPeakBandwidthPerPlane[k];
6844 MinimumTvmPlus2Tr0 = UrgLatency[i] * (GPUVMEnable == true ? (HostVMEnable == true ?
6845 (GPUVMMaxPageTableLevels + 2) * (HostVMMaxNonCachedPageTableLevels + 1) - 1 : GPUVMMaxPageTableLevels + 1) : 0);
6846 for (k = 0; k < NumberOfActivePlanes; ++k) {
6847 double MaximumTvmPlus2Tr0PlusTsw = { 0 };
6848 MaximumTvmPlus2Tr0PlusTsw = (MaximumVStartup[i][j][k] - 2) * HTotal[k] / PixelClock[k] - MinimumTWait - DynamicMetadataVMExtraLatency[k];
6849 if (MaximumTvmPlus2Tr0PlusTsw <= MinimumTvmPlus2Tr0 + PrefetchPixelLinesTime[k] / 4) {
6850 DCFCLKRequiredForPeakBandwidth = DCFCLKPerState[i];
6852 DCFCLKRequiredForPeakBandwidth = dml_max3(DCFCLKRequiredForPeakBandwidth, 2 * ExtraLatencyCycles
6853 / (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0 - PrefetchPixelLinesTime[k] / 4),
6854 (2 * ExtraLatencyCycles + PixelDCFCLKCyclesRequiredInPrefetch[k]) / (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0));
6857 DCFCLKState[i][j] = dml_min(DCFCLKPerState[i], 1.05 * (1 + mode_lib->vba.PercentMarginOverMinimumRequiredDCFCLK / 100)
6858 * dml_max(DCFCLKRequiredForAverageBandwidth, DCFCLKRequiredForPeakBandwidth));
6863 #endif /* CONFIG_DRM_AMD_DC_DCN3_0 */