2 * Copyright 2018 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 #include "../display_mode_lib.h"
27 #include "display_mode_vba_20.h"
28 #include "../dml_inline_defs.h"
32 * This file is gcc-parseable HW gospel, coming straight from HW engineers.
34 * It doesn't adhere to Linux kernel style and sometimes will do things in odd
35 * ways. Unless there is something clearly wrong with it the code should
36 * remain as-is as it provides us with a guarantee from HW that it is correct.
40 #define BPP_BLENDED_PIPE 0xffffffff
42 static double adjust_ReturnBW(
43 struct display_mode_lib *mode_lib,
45 bool DCCEnabledAnyPlane,
46 double ReturnBandwidthToDCN);
47 static unsigned int dscceComputeDelay(
50 unsigned int sliceWidth,
51 unsigned int numSlices,
52 enum output_format_class pixelFormat);
53 static unsigned int dscComputeDelay(enum output_format_class pixelFormat);
54 // Super monster function with some 45 argument
55 static bool CalculatePrefetchSchedule(
56 struct display_mode_lib *mode_lib,
60 double DCFCLKDeepSleep,
61 unsigned int DSCDelay,
62 unsigned int DPPPerPlane,
64 unsigned int NumberOfCursors,
65 double DPPCLKDelaySubtotal,
66 double DPPCLKDelaySCL,
67 double DPPCLKDelaySCLLBOnly,
68 double DPPCLKDelayCNVCFormater,
69 double DPPCLKDelayCNVCCursor,
70 double DISPCLKDelaySubtotal,
71 unsigned int ScalerRecoutWidth,
72 enum output_format_class OutputFormat,
75 unsigned int MaxInterDCNTileRepeaters,
76 unsigned int VStartup,
77 unsigned int PageTableLevels,
79 bool DynamicMetadataEnable,
80 unsigned int DynamicMetadataLinesBeforeActiveRequired,
81 unsigned int DynamicMetadataTransmittedBytes,
83 double UrgentLatencyPixelDataOnly,
84 double UrgentExtraLatency,
86 unsigned int PDEAndMetaPTEBytesFrame,
87 unsigned int MetaRowByte,
88 unsigned int PixelPTEBytesPerRow,
89 double PrefetchSourceLinesY,
90 unsigned int SwathWidthY,
91 double BytePerPixelDETY,
93 unsigned int MaxNumSwathY,
94 double PrefetchSourceLinesC,
95 double BytePerPixelDETC,
97 unsigned int MaxNumSwathC,
98 unsigned int SwathHeightY,
99 unsigned int SwathHeightC,
102 double XFCRemoteSurfaceFlipDelay,
103 bool InterlaceEnable,
104 bool ProgressiveToInterlaceUnitInOPP,
105 double *DSTXAfterScaler,
106 double *DSTYAfterScaler,
107 double *DestinationLinesForPrefetch,
108 double *PrefetchBandwidth,
109 double *DestinationLinesToRequestVMInVBlank,
110 double *DestinationLinesToRequestRowInVBlank,
111 double *VRatioPrefetchY,
112 double *VRatioPrefetchC,
113 double *RequiredPrefetchPixDataBW,
114 unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata,
116 unsigned int *VUpdateOffsetPix,
117 double *VUpdateWidthPix,
118 double *VReadyOffsetPix);
119 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed);
120 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed);
121 static double CalculatePrefetchSourceLines(
122 struct display_mode_lib *mode_lib,
126 bool ProgressiveToInterlaceUnitInOPP,
127 unsigned int SwathHeight,
128 unsigned int ViewportYStart,
129 double *VInitPreFill,
130 unsigned int *MaxNumSwath);
131 static unsigned int CalculateVMAndRowBytes(
132 struct display_mode_lib *mode_lib,
134 unsigned int BlockHeight256Bytes,
135 unsigned int BlockWidth256Bytes,
136 enum source_format_class SourcePixelFormat,
137 unsigned int SurfaceTiling,
138 unsigned int BytePerPixel,
139 enum scan_direction_class ScanDirection,
140 unsigned int ViewportWidth,
141 unsigned int ViewportHeight,
142 unsigned int SwathWidthY,
144 unsigned int VMMPageSize,
145 unsigned int PTEBufferSizeInRequestsLuma,
146 unsigned int PDEProcessingBufIn64KBReqs,
148 unsigned int DCCMetaPitch,
149 unsigned int *MacroTileWidth,
150 unsigned int *MetaRowByte,
151 unsigned int *PixelPTEBytesPerRow,
152 bool *PTEBufferSizeNotExceeded,
153 unsigned int *dpte_row_height,
154 unsigned int *meta_row_height);
155 static double CalculateTWait(
156 unsigned int PrefetchMode,
157 double DRAMClockChangeLatency,
158 double UrgentLatencyPixelDataOnly,
159 double SREnterPlusExitTime);
160 static double CalculateRemoteSurfaceFlipDelay(
161 struct display_mode_lib *mode_lib,
166 double XFCTSlvVupdateOffset,
167 double XFCTSlvVupdateWidth,
168 double XFCTSlvVreadyOffset,
169 double XFCXBUFLatencyTolerance,
170 double XFCFillBWOverhead,
171 double XFCSlvChunkSize,
172 double XFCBusTransportTime,
175 double *SrcActiveDrainRate,
178 static void CalculateActiveRowBandwidth(
180 enum source_format_class SourcePixelFormat,
184 unsigned int MetaRowByteLuma,
185 unsigned int MetaRowByteChroma,
186 unsigned int meta_row_height_luma,
187 unsigned int meta_row_height_chroma,
188 unsigned int PixelPTEBytesPerRowLuma,
189 unsigned int PixelPTEBytesPerRowChroma,
190 unsigned int dpte_row_height_luma,
191 unsigned int dpte_row_height_chroma,
194 double *qual_row_bw);
195 static void CalculateFlipSchedule(
196 struct display_mode_lib *mode_lib,
197 double UrgentExtraLatency,
198 double UrgentLatencyPixelDataOnly,
199 unsigned int GPUVMMaxPageTableLevels,
201 double BandwidthAvailableForImmediateFlip,
202 unsigned int TotImmediateFlipBytes,
203 enum source_format_class SourcePixelFormat,
204 unsigned int ImmediateFlipBytes,
208 double PDEAndMetaPTEBytesFrame,
209 unsigned int MetaRowByte,
210 unsigned int PixelPTEBytesPerRow,
212 unsigned int dpte_row_height,
213 unsigned int meta_row_height,
215 double *DestinationLinesToRequestVMInImmediateFlip,
216 double *DestinationLinesToRequestRowInImmediateFlip,
217 double *final_flip_bw,
218 bool *ImmediateFlipSupportedForPipe);
219 static double CalculateWriteBackDelay(
220 enum source_format_class WritebackPixelFormat,
221 double WritebackHRatio,
222 double WritebackVRatio,
223 unsigned int WritebackLumaHTaps,
224 unsigned int WritebackLumaVTaps,
225 unsigned int WritebackChromaHTaps,
226 unsigned int WritebackChromaVTaps,
227 unsigned int WritebackDestinationWidth);
229 static void dml20_DisplayPipeConfiguration(struct display_mode_lib *mode_lib);
230 static void dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
231 struct display_mode_lib *mode_lib);
233 void dml20_recalculate(struct display_mode_lib *mode_lib)
235 ModeSupportAndSystemConfiguration(mode_lib);
236 mode_lib->vba.FabricAndDRAMBandwidth = dml_min(
237 mode_lib->vba.DRAMSpeed * mode_lib->vba.NumberOfChannels * mode_lib->vba.DRAMChannelWidth,
238 mode_lib->vba.FabricClock * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000.0;
239 PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
240 dml20_DisplayPipeConfiguration(mode_lib);
241 dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
244 static double adjust_ReturnBW(
245 struct display_mode_lib *mode_lib,
247 bool DCCEnabledAnyPlane,
248 double ReturnBandwidthToDCN)
250 double CriticalCompression;
252 if (DCCEnabledAnyPlane
253 && ReturnBandwidthToDCN
254 > mode_lib->vba.DCFCLK * mode_lib->vba.ReturnBusWidth / 4.0)
258 ReturnBandwidthToDCN * 4
260 - mode_lib->vba.UrgentLatencyPixelDataOnly
261 / ((mode_lib->vba.ROBBufferSizeInKByte
262 - mode_lib->vba.PixelChunkSizeInKByte)
264 / ReturnBandwidthToDCN
265 - mode_lib->vba.DCFCLK
266 * mode_lib->vba.ReturnBusWidth
268 + mode_lib->vba.UrgentLatencyPixelDataOnly));
270 CriticalCompression = 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK
271 * mode_lib->vba.UrgentLatencyPixelDataOnly
272 / (ReturnBandwidthToDCN * mode_lib->vba.UrgentLatencyPixelDataOnly
273 + (mode_lib->vba.ROBBufferSizeInKByte
274 - mode_lib->vba.PixelChunkSizeInKByte)
277 if (DCCEnabledAnyPlane && CriticalCompression > 1.0 && CriticalCompression < 4.0)
281 4.0 * ReturnBandwidthToDCN
282 * (mode_lib->vba.ROBBufferSizeInKByte
283 - mode_lib->vba.PixelChunkSizeInKByte)
285 * mode_lib->vba.ReturnBusWidth
286 * mode_lib->vba.DCFCLK
287 * mode_lib->vba.UrgentLatencyPixelDataOnly
289 (ReturnBandwidthToDCN
290 * mode_lib->vba.UrgentLatencyPixelDataOnly
291 + (mode_lib->vba.ROBBufferSizeInKByte
292 - mode_lib->vba.PixelChunkSizeInKByte)
299 static unsigned int dscceComputeDelay(
302 unsigned int sliceWidth,
303 unsigned int numSlices,
304 enum output_format_class pixelFormat)
306 // valid bpc = source bits per component in the set of {8, 10, 12}
307 // valid bpp = increments of 1/16 of a bit
308 // min = 6/7/8 in N420/N422/444, respectively
309 // max = such that compression is 1:1
310 //valid sliceWidth = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
311 //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
312 //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
315 unsigned int rcModelSize = 8192;
317 // N422/N420 operate at 2 pixels per clock
318 unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, l,
321 if (pixelFormat == dm_n422 || pixelFormat == dm_420)
323 // #all other modes operate at 1 pixel per clock
327 //initial transmit delay as per PPS
328 initalXmitDelay = dml_round(rcModelSize / 2.0 / bpp / pixelsPerClock);
338 //divide by pixel per cycle to compute slice width as seen by DSC
339 w = sliceWidth / pixelsPerClock;
341 //422 mode has an additional cycle of delay
342 if (pixelFormat == dm_s422)
347 //main calculation for the dscce
348 ix = initalXmitDelay + 45;
353 ax = (a + 2) / 3 + D + 6 + 1;
354 l = (ax + wx - 1) / wx;
355 if ((ix % w) == 0 && p != 0)
359 Delay = l * wx * (numSlices - 1) + ax + s + lstall + 22;
361 //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
362 pixels = Delay * 3 * pixelsPerClock;
366 static unsigned int dscComputeDelay(enum output_format_class pixelFormat)
368 unsigned int Delay = 0;
370 if (pixelFormat == dm_420) {
375 // dscc - input deserializer
377 // dscc gets pixels every other cycle
379 // dscc - input cdc fifo
381 // dscc gets pixels every other cycle
383 // dscc - cdc uncertainty
385 // dscc - output cdc fifo
387 // dscc gets pixels every other cycle
389 // dscc - cdc uncertainty
391 // dscc - output serializer
395 } else if (pixelFormat == dm_n422) {
400 // dscc - input deserializer
402 // dscc - input cdc fifo
404 // dscc - cdc uncertainty
406 // dscc - output cdc fifo
408 // dscc - cdc uncertainty
410 // dscc - output serializer
419 // dscc - input deserializer
421 // dscc - input cdc fifo
423 // dscc - cdc uncertainty
425 // dscc - output cdc fifo
427 // dscc - output serializer
429 // dscc - cdc uncertainty
438 static bool CalculatePrefetchSchedule(
439 struct display_mode_lib *mode_lib,
443 double DCFCLKDeepSleep,
444 unsigned int DSCDelay,
445 unsigned int DPPPerPlane,
447 unsigned int NumberOfCursors,
448 double DPPCLKDelaySubtotal,
449 double DPPCLKDelaySCL,
450 double DPPCLKDelaySCLLBOnly,
451 double DPPCLKDelayCNVCFormater,
452 double DPPCLKDelayCNVCCursor,
453 double DISPCLKDelaySubtotal,
454 unsigned int ScalerRecoutWidth,
455 enum output_format_class OutputFormat,
458 unsigned int MaxInterDCNTileRepeaters,
459 unsigned int VStartup,
460 unsigned int PageTableLevels,
462 bool DynamicMetadataEnable,
463 unsigned int DynamicMetadataLinesBeforeActiveRequired,
464 unsigned int DynamicMetadataTransmittedBytes,
466 double UrgentLatencyPixelDataOnly,
467 double UrgentExtraLatency,
469 unsigned int PDEAndMetaPTEBytesFrame,
470 unsigned int MetaRowByte,
471 unsigned int PixelPTEBytesPerRow,
472 double PrefetchSourceLinesY,
473 unsigned int SwathWidthY,
474 double BytePerPixelDETY,
475 double VInitPreFillY,
476 unsigned int MaxNumSwathY,
477 double PrefetchSourceLinesC,
478 double BytePerPixelDETC,
479 double VInitPreFillC,
480 unsigned int MaxNumSwathC,
481 unsigned int SwathHeightY,
482 unsigned int SwathHeightC,
485 double XFCRemoteSurfaceFlipDelay,
486 bool InterlaceEnable,
487 bool ProgressiveToInterlaceUnitInOPP,
488 double *DSTXAfterScaler,
489 double *DSTYAfterScaler,
490 double *DestinationLinesForPrefetch,
491 double *PrefetchBandwidth,
492 double *DestinationLinesToRequestVMInVBlank,
493 double *DestinationLinesToRequestRowInVBlank,
494 double *VRatioPrefetchY,
495 double *VRatioPrefetchC,
496 double *RequiredPrefetchPixDataBW,
497 unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata,
499 unsigned int *VUpdateOffsetPix,
500 double *VUpdateWidthPix,
501 double *VReadyOffsetPix)
503 bool MyError = false;
504 unsigned int DPPCycles, DISPCLKCycles;
505 double DSTTotalPixelsAfterScaler, TotalRepeaterDelayTime;
506 double Tdm, LineTime, Tsetup;
507 double dst_y_prefetch_equ;
509 double prefetch_bw_oto;
513 double dst_y_prefetch_oto;
514 double TimeForFetchingMetaPTE = 0;
515 double TimeForFetchingRowInVBlank = 0;
516 double LinesToRequestPrefetchPixelData = 0;
519 DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCL;
521 DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCLLBOnly;
523 DPPCycles = DPPCycles + DPPCLKDelayCNVCFormater + NumberOfCursors * DPPCLKDelayCNVCCursor;
525 DISPCLKCycles = DISPCLKDelaySubtotal;
527 if (DPPCLK == 0.0 || DISPCLK == 0.0)
530 *DSTXAfterScaler = DPPCycles * PixelClock / DPPCLK + DISPCLKCycles * PixelClock / DISPCLK
534 *DSTXAfterScaler = *DSTXAfterScaler + ScalerRecoutWidth;
536 if (OutputFormat == dm_420 || (InterlaceEnable && ProgressiveToInterlaceUnitInOPP))
537 *DSTYAfterScaler = 1;
539 *DSTYAfterScaler = 0;
541 DSTTotalPixelsAfterScaler = ((double) (*DSTYAfterScaler * HTotal)) + *DSTXAfterScaler;
542 *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / HTotal, 1);
543 *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * HTotal));
545 *VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1);
546 TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2.0 / DPPCLK + 3.0 / DISPCLK);
547 *VUpdateWidthPix = (14.0 / DCFCLKDeepSleep + 12.0 / DPPCLK + TotalRepeaterDelayTime)
550 *VReadyOffsetPix = dml_max(
552 TotalRepeaterDelayTime + 20.0 / DCFCLKDeepSleep + 10.0 / DPPCLK)
555 Tsetup = (double) (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock;
557 LineTime = (double) HTotal / PixelClock;
559 if (DynamicMetadataEnable) {
560 double Tdmbf, Tdmec, Tdmsks;
562 Tdm = dml_max(0.0, UrgentExtraLatency - TCalc);
563 Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / DISPCLK;
565 if (DynamicMetadataLinesBeforeActiveRequired == 0)
566 Tdmsks = VBlank * LineTime / 2.0;
568 Tdmsks = DynamicMetadataLinesBeforeActiveRequired * LineTime;
569 if (InterlaceEnable && !ProgressiveToInterlaceUnitInOPP)
571 if (VStartup * LineTime
572 < Tsetup + TWait + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) {
574 *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = (Tsetup + TWait
575 + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) / LineTime;
577 *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = 0.0;
582 if (PageTableLevels == 4)
583 *Tno_bw = UrgentExtraLatency + UrgentLatencyPixelDataOnly;
584 else if (PageTableLevels == 3)
585 *Tno_bw = UrgentExtraLatency;
588 } else if (DCCEnable)
591 *Tno_bw = LineTime / 4;
593 dst_y_prefetch_equ = VStartup - dml_max(TCalc + TWait, XFCRemoteSurfaceFlipDelay) / LineTime
594 - (Tsetup + Tdm) / LineTime
595 - (*DSTYAfterScaler + *DSTXAfterScaler / HTotal);
597 Tsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime;
599 prefetch_bw_oto = (MetaRowByte + PixelPTEBytesPerRow
600 + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1)
601 + PrefetchSourceLinesC * SwathWidthY / 2 * dml_ceil(BytePerPixelDETC, 2))
604 if (GPUVMEnable == true) {
607 *Tno_bw + PDEAndMetaPTEBytesFrame / prefetch_bw_oto,
610 + UrgentLatencyPixelDataOnly
615 Tvm_oto = LineTime / 4.0;
617 if ((GPUVMEnable == true || DCCEnable == true)) {
619 (MetaRowByte + PixelPTEBytesPerRow) / prefetch_bw_oto,
620 dml_max(UrgentLatencyPixelDataOnly, dml_max(LineTime - Tvm_oto, LineTime / 4)));
622 Tr0_oto = LineTime - Tvm_oto;
624 Tpre_oto = Tvm_oto + Tr0_oto + Tsw_oto;
626 dst_y_prefetch_oto = Tpre_oto / LineTime;
628 if (dst_y_prefetch_oto < dst_y_prefetch_equ)
629 *DestinationLinesForPrefetch = dst_y_prefetch_oto;
631 *DestinationLinesForPrefetch = dst_y_prefetch_equ;
633 *DestinationLinesForPrefetch = dml_floor(4.0 * (*DestinationLinesForPrefetch + 0.125), 1)
636 dml_print("DML: VStartup: %d\n", VStartup);
637 dml_print("DML: TCalc: %f\n", TCalc);
638 dml_print("DML: TWait: %f\n", TWait);
639 dml_print("DML: XFCRemoteSurfaceFlipDelay: %f\n", XFCRemoteSurfaceFlipDelay);
640 dml_print("DML: LineTime: %f\n", LineTime);
641 dml_print("DML: Tsetup: %f\n", Tsetup);
642 dml_print("DML: Tdm: %f\n", Tdm);
643 dml_print("DML: DSTYAfterScaler: %f\n", *DSTYAfterScaler);
644 dml_print("DML: DSTXAfterScaler: %f\n", *DSTXAfterScaler);
645 dml_print("DML: HTotal: %d\n", HTotal);
647 *PrefetchBandwidth = 0;
648 *DestinationLinesToRequestVMInVBlank = 0;
649 *DestinationLinesToRequestRowInVBlank = 0;
650 *VRatioPrefetchY = 0;
651 *VRatioPrefetchC = 0;
652 *RequiredPrefetchPixDataBW = 0;
653 if (*DestinationLinesForPrefetch > 1) {
654 *PrefetchBandwidth = (PDEAndMetaPTEBytesFrame + 2 * MetaRowByte
655 + 2 * PixelPTEBytesPerRow
656 + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1)
657 + PrefetchSourceLinesC * SwathWidthY / 2
658 * dml_ceil(BytePerPixelDETC, 2))
659 / (*DestinationLinesForPrefetch * LineTime - *Tno_bw);
661 TimeForFetchingMetaPTE =
664 + (double) PDEAndMetaPTEBytesFrame
665 / *PrefetchBandwidth,
668 + UrgentLatencyPixelDataOnly
673 if (NumberOfCursors > 0 || XFCEnabled)
674 TimeForFetchingMetaPTE = LineTime / 4;
676 TimeForFetchingMetaPTE = 0.0;
679 if ((GPUVMEnable == true || DCCEnable == true)) {
680 TimeForFetchingRowInVBlank =
682 (MetaRowByte + PixelPTEBytesPerRow)
683 / *PrefetchBandwidth,
685 UrgentLatencyPixelDataOnly,
688 - TimeForFetchingMetaPTE,
692 if (NumberOfCursors > 0 || XFCEnabled)
693 TimeForFetchingRowInVBlank = LineTime - TimeForFetchingMetaPTE;
695 TimeForFetchingRowInVBlank = 0.0;
698 *DestinationLinesToRequestVMInVBlank = dml_floor(
699 4.0 * (TimeForFetchingMetaPTE / LineTime + 0.125),
702 *DestinationLinesToRequestRowInVBlank = dml_floor(
703 4.0 * (TimeForFetchingRowInVBlank / LineTime + 0.125),
706 LinesToRequestPrefetchPixelData =
707 *DestinationLinesForPrefetch
708 - ((NumberOfCursors > 0 || GPUVMEnable
710 (*DestinationLinesToRequestVMInVBlank
711 + *DestinationLinesToRequestRowInVBlank) :
714 if (LinesToRequestPrefetchPixelData > 0) {
716 *VRatioPrefetchY = (double) PrefetchSourceLinesY
717 / LinesToRequestPrefetchPixelData;
718 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
719 if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
720 if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
723 (double) PrefetchSourceLinesY
724 / LinesToRequestPrefetchPixelData,
725 (double) MaxNumSwathY
727 / (LinesToRequestPrefetchPixelData
731 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
734 *VRatioPrefetchY = 0;
738 *VRatioPrefetchC = (double) PrefetchSourceLinesC
739 / LinesToRequestPrefetchPixelData;
740 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
742 if ((SwathHeightC > 4)) {
743 if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
747 (double) MaxNumSwathC
749 / (LinesToRequestPrefetchPixelData
753 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
756 *VRatioPrefetchC = 0;
760 *RequiredPrefetchPixDataBW =
762 * ((double) PrefetchSourceLinesY
763 / LinesToRequestPrefetchPixelData
767 + (double) PrefetchSourceLinesC
768 / LinesToRequestPrefetchPixelData
773 * SwathWidthY / LineTime;
776 *VRatioPrefetchY = 0;
777 *VRatioPrefetchC = 0;
778 *RequiredPrefetchPixDataBW = 0;
786 *PrefetchBandwidth = 0;
787 TimeForFetchingMetaPTE = 0;
788 TimeForFetchingRowInVBlank = 0;
789 *DestinationLinesToRequestVMInVBlank = 0;
790 *DestinationLinesToRequestRowInVBlank = 0;
791 *DestinationLinesForPrefetch = 0;
792 LinesToRequestPrefetchPixelData = 0;
793 *VRatioPrefetchY = 0;
794 *VRatioPrefetchC = 0;
795 *RequiredPrefetchPixDataBW = 0;
801 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed)
803 return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1);
806 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed)
808 return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4 / Clock, 1);
811 static double CalculatePrefetchSourceLines(
812 struct display_mode_lib *mode_lib,
816 bool ProgressiveToInterlaceUnitInOPP,
817 unsigned int SwathHeight,
818 unsigned int ViewportYStart,
819 double *VInitPreFill,
820 unsigned int *MaxNumSwath)
822 unsigned int MaxPartialSwath;
824 if (ProgressiveToInterlaceUnitInOPP)
825 *VInitPreFill = dml_floor((VRatio + vtaps + 1) / 2.0, 1);
827 *VInitPreFill = dml_floor((VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1);
829 if (!mode_lib->vba.IgnoreViewportPositioning) {
831 *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0;
833 if (*VInitPreFill > 1.0)
834 MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight;
836 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2)
838 MaxPartialSwath = dml_max(1U, MaxPartialSwath);
842 if (ViewportYStart != 0)
844 "WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n");
846 *MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1);
848 if (*VInitPreFill > 1.0)
849 MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight;
851 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1)
855 return *MaxNumSwath * SwathHeight + MaxPartialSwath;
858 static unsigned int CalculateVMAndRowBytes(
859 struct display_mode_lib *mode_lib,
861 unsigned int BlockHeight256Bytes,
862 unsigned int BlockWidth256Bytes,
863 enum source_format_class SourcePixelFormat,
864 unsigned int SurfaceTiling,
865 unsigned int BytePerPixel,
866 enum scan_direction_class ScanDirection,
867 unsigned int ViewportWidth,
868 unsigned int ViewportHeight,
869 unsigned int SwathWidth,
871 unsigned int VMMPageSize,
872 unsigned int PTEBufferSizeInRequestsLuma,
873 unsigned int PDEProcessingBufIn64KBReqs,
875 unsigned int DCCMetaPitch,
876 unsigned int *MacroTileWidth,
877 unsigned int *MetaRowByte,
878 unsigned int *PixelPTEBytesPerRow,
879 bool *PTEBufferSizeNotExceeded,
880 unsigned int *dpte_row_height,
881 unsigned int *meta_row_height)
883 unsigned int MetaRequestHeight;
884 unsigned int MetaRequestWidth;
885 unsigned int MetaSurfWidth;
886 unsigned int MetaSurfHeight;
887 unsigned int MPDEBytesFrame;
888 unsigned int MetaPTEBytesFrame;
889 unsigned int DCCMetaSurfaceBytes;
891 unsigned int MacroTileSizeBytes;
892 unsigned int MacroTileHeight;
893 unsigned int DPDE0BytesFrame;
894 unsigned int ExtraDPDEBytesFrame;
895 unsigned int PDEAndMetaPTEBytesFrame;
897 if (DCCEnable == true) {
898 MetaRequestHeight = 8 * BlockHeight256Bytes;
899 MetaRequestWidth = 8 * BlockWidth256Bytes;
900 if (ScanDirection == dm_horz) {
901 *meta_row_height = MetaRequestHeight;
902 MetaSurfWidth = dml_ceil((double) SwathWidth - 1, MetaRequestWidth)
904 *MetaRowByte = MetaSurfWidth * MetaRequestHeight * BytePerPixel / 256.0;
906 *meta_row_height = MetaRequestWidth;
907 MetaSurfHeight = dml_ceil((double) SwathWidth - 1, MetaRequestHeight)
909 *MetaRowByte = MetaSurfHeight * MetaRequestWidth * BytePerPixel / 256.0;
911 if (ScanDirection == dm_horz) {
912 DCCMetaSurfaceBytes = DCCMetaPitch
913 * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes)
914 + 64 * BlockHeight256Bytes) * BytePerPixel
917 DCCMetaSurfaceBytes = DCCMetaPitch
919 (double) ViewportHeight - 1,
920 64 * BlockHeight256Bytes)
921 + 64 * BlockHeight256Bytes) * BytePerPixel
924 if (GPUVMEnable == true) {
925 MetaPTEBytesFrame = (dml_ceil(
926 (double) (DCCMetaSurfaceBytes - VMMPageSize)
929 MPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 1);
931 MetaPTEBytesFrame = 0;
935 MetaPTEBytesFrame = 0;
940 if (SurfaceTiling == dm_sw_linear || SurfaceTiling == dm_sw_gfx7_2d_thin_gl || SurfaceTiling == dm_sw_gfx7_2d_thin_lvp) {
941 MacroTileSizeBytes = 256;
942 MacroTileHeight = BlockHeight256Bytes;
943 } else if (SurfaceTiling == dm_sw_4kb_s || SurfaceTiling == dm_sw_4kb_s_x
944 || SurfaceTiling == dm_sw_4kb_d || SurfaceTiling == dm_sw_4kb_d_x) {
945 MacroTileSizeBytes = 4096;
946 MacroTileHeight = 4 * BlockHeight256Bytes;
947 } else if (SurfaceTiling == dm_sw_64kb_s || SurfaceTiling == dm_sw_64kb_s_t
948 || SurfaceTiling == dm_sw_64kb_s_x || SurfaceTiling == dm_sw_64kb_d
949 || SurfaceTiling == dm_sw_64kb_d_t || SurfaceTiling == dm_sw_64kb_d_x
950 || SurfaceTiling == dm_sw_64kb_r_x) {
951 MacroTileSizeBytes = 65536;
952 MacroTileHeight = 16 * BlockHeight256Bytes;
954 MacroTileSizeBytes = 262144;
955 MacroTileHeight = 32 * BlockHeight256Bytes;
957 *MacroTileWidth = MacroTileSizeBytes / BytePerPixel / MacroTileHeight;
959 if (GPUVMEnable == true && mode_lib->vba.GPUVMMaxPageTableLevels > 1) {
960 if (ScanDirection == dm_horz) {
971 - MacroTileSizeBytes)
986 - MacroTileSizeBytes)
991 ExtraDPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 2);
994 ExtraDPDEBytesFrame = 0;
997 PDEAndMetaPTEBytesFrame = MetaPTEBytesFrame + MPDEBytesFrame + DPDE0BytesFrame
998 + ExtraDPDEBytesFrame;
1000 if (GPUVMEnable == true) {
1001 unsigned int PTERequestSize;
1002 unsigned int PixelPTEReqHeight;
1003 unsigned int PixelPTEReqWidth;
1004 double FractionOfPTEReturnDrop;
1005 unsigned int EffectivePDEProcessingBufIn64KBReqs;
1007 if (SurfaceTiling == dm_sw_linear) {
1008 PixelPTEReqHeight = 1;
1009 PixelPTEReqWidth = 8.0 * VMMPageSize / BytePerPixel;
1010 PTERequestSize = 64;
1011 FractionOfPTEReturnDrop = 0;
1012 } else if (MacroTileSizeBytes == 4096) {
1013 PixelPTEReqHeight = MacroTileHeight;
1014 PixelPTEReqWidth = 8 * *MacroTileWidth;
1015 PTERequestSize = 64;
1016 if (ScanDirection == dm_horz)
1017 FractionOfPTEReturnDrop = 0;
1019 FractionOfPTEReturnDrop = 7 / 8;
1020 } else if (VMMPageSize == 4096 && MacroTileSizeBytes > 4096) {
1021 PixelPTEReqHeight = 16 * BlockHeight256Bytes;
1022 PixelPTEReqWidth = 16 * BlockWidth256Bytes;
1023 PTERequestSize = 128;
1024 FractionOfPTEReturnDrop = 0;
1026 PixelPTEReqHeight = MacroTileHeight;
1027 PixelPTEReqWidth = 8 * *MacroTileWidth;
1028 PTERequestSize = 64;
1029 FractionOfPTEReturnDrop = 0;
1032 if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)
1033 EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs / 2;
1035 EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs;
1037 if (SurfaceTiling == dm_sw_linear) {
1042 << (unsigned int) dml_floor(
1045 (double) PTEBufferSizeInRequestsLuma
1047 EffectivePDEProcessingBufIn64KBReqs
1052 *PixelPTEBytesPerRow = PTERequestSize
1054 (double) (Pitch * *dpte_row_height - 1)
1057 } else if (ScanDirection == dm_horz) {
1058 *dpte_row_height = PixelPTEReqHeight;
1059 *PixelPTEBytesPerRow = PTERequestSize
1060 * (dml_ceil(((double) SwathWidth - 1) / PixelPTEReqWidth, 1)
1063 *dpte_row_height = dml_min(PixelPTEReqWidth, *MacroTileWidth);
1064 *PixelPTEBytesPerRow = PTERequestSize
1066 ((double) SwathWidth - 1)
1067 / PixelPTEReqHeight,
1070 if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop)
1071 <= 64 * PTEBufferSizeInRequestsLuma) {
1072 *PTEBufferSizeNotExceeded = true;
1074 *PTEBufferSizeNotExceeded = false;
1077 *PixelPTEBytesPerRow = 0;
1078 *PTEBufferSizeNotExceeded = true;
1081 return PDEAndMetaPTEBytesFrame;
1084 static void dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
1085 struct display_mode_lib *mode_lib)
1089 mode_lib->vba.WritebackDISPCLK = 0.0;
1090 mode_lib->vba.DISPCLKWithRamping = 0;
1091 mode_lib->vba.DISPCLKWithoutRamping = 0;
1092 mode_lib->vba.GlobalDPPCLK = 0.0;
1094 // dml_ml->vba.DISPCLK and dml_ml->vba.DPPCLK Calculation
1096 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1097 if (mode_lib->vba.WritebackEnable[k]) {
1098 mode_lib->vba.WritebackDISPCLK =
1100 mode_lib->vba.WritebackDISPCLK,
1101 CalculateWriteBackDISPCLK(
1102 mode_lib->vba.WritebackPixelFormat[k],
1103 mode_lib->vba.PixelClock[k],
1104 mode_lib->vba.WritebackHRatio[k],
1105 mode_lib->vba.WritebackVRatio[k],
1106 mode_lib->vba.WritebackLumaHTaps[k],
1107 mode_lib->vba.WritebackLumaVTaps[k],
1108 mode_lib->vba.WritebackChromaHTaps[k],
1109 mode_lib->vba.WritebackChromaVTaps[k],
1110 mode_lib->vba.WritebackDestinationWidth[k],
1111 mode_lib->vba.HTotal[k],
1112 mode_lib->vba.WritebackChromaLineBufferWidth));
1116 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1117 if (mode_lib->vba.HRatio[k] > 1) {
1118 mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(
1119 mode_lib->vba.MaxDCHUBToPSCLThroughput,
1120 mode_lib->vba.MaxPSCLToLBThroughput
1121 * mode_lib->vba.HRatio[k]
1123 mode_lib->vba.htaps[k]
1127 mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(
1128 mode_lib->vba.MaxDCHUBToPSCLThroughput,
1129 mode_lib->vba.MaxPSCLToLBThroughput);
1132 mode_lib->vba.DPPCLKUsingSingleDPPLuma =
1133 mode_lib->vba.PixelClock[k]
1135 mode_lib->vba.vtaps[k] / 6.0
1138 mode_lib->vba.HRatio[k]),
1140 mode_lib->vba.HRatio[k]
1141 * mode_lib->vba.VRatio[k]
1142 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k],
1145 if ((mode_lib->vba.htaps[k] > 6 || mode_lib->vba.vtaps[k] > 6)
1146 && mode_lib->vba.DPPCLKUsingSingleDPPLuma
1147 < 2 * mode_lib->vba.PixelClock[k]) {
1148 mode_lib->vba.DPPCLKUsingSingleDPPLuma = 2 * mode_lib->vba.PixelClock[k];
1151 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
1152 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
1153 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = 0.0;
1154 mode_lib->vba.DPPCLKUsingSingleDPP[k] =
1155 mode_lib->vba.DPPCLKUsingSingleDPPLuma;
1157 if (mode_lib->vba.HRatio[k] > 1) {
1158 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] =
1160 mode_lib->vba.MaxDCHUBToPSCLThroughput,
1161 mode_lib->vba.MaxPSCLToLBThroughput
1162 * mode_lib->vba.HRatio[k]
1165 mode_lib->vba.HTAPsChroma[k]
1169 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = dml_min(
1170 mode_lib->vba.MaxDCHUBToPSCLThroughput,
1171 mode_lib->vba.MaxPSCLToLBThroughput);
1173 mode_lib->vba.DPPCLKUsingSingleDPPChroma =
1174 mode_lib->vba.PixelClock[k]
1176 mode_lib->vba.VTAPsChroma[k]
1180 mode_lib->vba.HRatio[k]
1183 mode_lib->vba.HRatio[k]
1184 * mode_lib->vba.VRatio[k]
1186 / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k],
1189 if ((mode_lib->vba.HTAPsChroma[k] > 6 || mode_lib->vba.VTAPsChroma[k] > 6)
1190 && mode_lib->vba.DPPCLKUsingSingleDPPChroma
1191 < 2 * mode_lib->vba.PixelClock[k]) {
1192 mode_lib->vba.DPPCLKUsingSingleDPPChroma = 2
1193 * mode_lib->vba.PixelClock[k];
1196 mode_lib->vba.DPPCLKUsingSingleDPP[k] = dml_max(
1197 mode_lib->vba.DPPCLKUsingSingleDPPLuma,
1198 mode_lib->vba.DPPCLKUsingSingleDPPChroma);
1202 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1203 if (mode_lib->vba.BlendingAndTiming[k] != k)
1205 if (mode_lib->vba.ODMCombineEnabled[k]) {
1206 mode_lib->vba.DISPCLKWithRamping =
1208 mode_lib->vba.DISPCLKWithRamping,
1209 mode_lib->vba.PixelClock[k] / 2
1211 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1214 + mode_lib->vba.DISPCLKRampingMargin
1216 mode_lib->vba.DISPCLKWithoutRamping =
1218 mode_lib->vba.DISPCLKWithoutRamping,
1219 mode_lib->vba.PixelClock[k] / 2
1221 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1223 } else if (!mode_lib->vba.ODMCombineEnabled[k]) {
1224 mode_lib->vba.DISPCLKWithRamping =
1226 mode_lib->vba.DISPCLKWithRamping,
1227 mode_lib->vba.PixelClock[k]
1229 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1232 + mode_lib->vba.DISPCLKRampingMargin
1234 mode_lib->vba.DISPCLKWithoutRamping =
1236 mode_lib->vba.DISPCLKWithoutRamping,
1237 mode_lib->vba.PixelClock[k]
1239 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1244 mode_lib->vba.DISPCLKWithRamping = dml_max(
1245 mode_lib->vba.DISPCLKWithRamping,
1246 mode_lib->vba.WritebackDISPCLK);
1247 mode_lib->vba.DISPCLKWithoutRamping = dml_max(
1248 mode_lib->vba.DISPCLKWithoutRamping,
1249 mode_lib->vba.WritebackDISPCLK);
1251 ASSERT(mode_lib->vba.DISPCLKDPPCLKVCOSpeed != 0);
1252 mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1253 mode_lib->vba.DISPCLKWithRamping,
1254 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1255 mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1256 mode_lib->vba.DISPCLKWithoutRamping,
1257 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1258 mode_lib->vba.MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown(
1259 mode_lib->vba.soc.clock_limits[mode_lib->vba.soc.num_states].dispclk_mhz,
1260 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1261 if (mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity
1262 > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) {
1263 mode_lib->vba.DISPCLK_calculated =
1264 mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity;
1265 } else if (mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity
1266 > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) {
1267 mode_lib->vba.DISPCLK_calculated = mode_lib->vba.MaxDispclkRoundedToDFSGranularity;
1269 mode_lib->vba.DISPCLK_calculated =
1270 mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity;
1272 DTRACE(" dispclk_mhz (calculated) = %f", mode_lib->vba.DISPCLK_calculated);
1274 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1275 if (mode_lib->vba.DPPPerPlane[k] == 0) {
1276 mode_lib->vba.DPPCLK_calculated[k] = 0;
1278 mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.DPPCLKUsingSingleDPP[k]
1279 / mode_lib->vba.DPPPerPlane[k]
1280 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
1282 mode_lib->vba.GlobalDPPCLK = dml_max(
1283 mode_lib->vba.GlobalDPPCLK,
1284 mode_lib->vba.DPPCLK_calculated[k]);
1286 mode_lib->vba.GlobalDPPCLK = RoundToDFSGranularityUp(
1287 mode_lib->vba.GlobalDPPCLK,
1288 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1289 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1290 mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.GlobalDPPCLK / 255
1292 mode_lib->vba.DPPCLK_calculated[k] * 255
1293 / mode_lib->vba.GlobalDPPCLK,
1295 DTRACE(" dppclk_mhz[%i] (calculated) = %f", k, mode_lib->vba.DPPCLK_calculated[k]);
1299 mode_lib->vba.DCCEnabledAnyPlane = false;
1300 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
1301 if (mode_lib->vba.DCCEnable[k])
1302 mode_lib->vba.DCCEnabledAnyPlane = true;
1304 mode_lib->vba.ReturnBandwidthToDCN = dml_min(
1305 mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK,
1306 mode_lib->vba.FabricAndDRAMBandwidth * 1000)
1307 * mode_lib->vba.PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
1309 mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBandwidthToDCN;
1310 mode_lib->vba.ReturnBW = adjust_ReturnBW(
1312 mode_lib->vba.ReturnBW,
1313 mode_lib->vba.DCCEnabledAnyPlane,
1314 mode_lib->vba.ReturnBandwidthToDCN);
1316 // Let's do this calculation again??
1317 mode_lib->vba.ReturnBandwidthToDCN = dml_min(
1318 mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK,
1319 mode_lib->vba.FabricAndDRAMBandwidth * 1000);
1320 mode_lib->vba.ReturnBW = adjust_ReturnBW(
1322 mode_lib->vba.ReturnBW,
1323 mode_lib->vba.DCCEnabledAnyPlane,
1324 mode_lib->vba.ReturnBandwidthToDCN);
1326 DTRACE(" dcfclk_mhz = %f", mode_lib->vba.DCFCLK);
1327 DTRACE(" return_bw_to_dcn = %f", mode_lib->vba.ReturnBandwidthToDCN);
1328 DTRACE(" return_bus_bw = %f", mode_lib->vba.ReturnBW);
1330 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1331 bool MainPlaneDoesODMCombine = false;
1333 if (mode_lib->vba.SourceScan[k] == dm_horz)
1334 mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportWidth[k];
1336 mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportHeight[k];
1338 if (mode_lib->vba.ODMCombineEnabled[k] == true)
1339 MainPlaneDoesODMCombine = true;
1340 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j)
1341 if (mode_lib->vba.BlendingAndTiming[k] == j
1342 && mode_lib->vba.ODMCombineEnabled[j] == true)
1343 MainPlaneDoesODMCombine = true;
1345 if (MainPlaneDoesODMCombine == true)
1346 mode_lib->vba.SwathWidthY[k] = dml_min(
1347 (double) mode_lib->vba.SwathWidthSingleDPPY[k],
1349 mode_lib->vba.HActive[k] / 2.0
1350 * mode_lib->vba.HRatio[k]));
1352 if (mode_lib->vba.DPPPerPlane[k] == 0) {
1353 mode_lib->vba.SwathWidthY[k] = 0;
1355 mode_lib->vba.SwathWidthY[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1356 / mode_lib->vba.DPPPerPlane[k];
1361 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1362 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
1363 mode_lib->vba.BytePerPixelDETY[k] = 8;
1364 mode_lib->vba.BytePerPixelDETC[k] = 0;
1365 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
1366 mode_lib->vba.BytePerPixelDETY[k] = 4;
1367 mode_lib->vba.BytePerPixelDETC[k] = 0;
1368 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
1369 mode_lib->vba.BytePerPixelDETY[k] = 2;
1370 mode_lib->vba.BytePerPixelDETC[k] = 0;
1371 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) {
1372 mode_lib->vba.BytePerPixelDETY[k] = 1;
1373 mode_lib->vba.BytePerPixelDETC[k] = 0;
1374 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
1375 mode_lib->vba.BytePerPixelDETY[k] = 1;
1376 mode_lib->vba.BytePerPixelDETC[k] = 2;
1377 } else { // dm_420_10
1378 mode_lib->vba.BytePerPixelDETY[k] = 4.0 / 3.0;
1379 mode_lib->vba.BytePerPixelDETC[k] = 8.0 / 3.0;
1383 mode_lib->vba.TotalDataReadBandwidth = 0.0;
1384 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1385 mode_lib->vba.ReadBandwidthPlaneLuma[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1386 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1)
1387 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1388 * mode_lib->vba.VRatio[k];
1389 mode_lib->vba.ReadBandwidthPlaneChroma[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1390 / 2 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2)
1391 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1392 * mode_lib->vba.VRatio[k] / 2;
1394 " read_bw[%i] = %fBps",
1396 mode_lib->vba.ReadBandwidthPlaneLuma[k]
1397 + mode_lib->vba.ReadBandwidthPlaneChroma[k]);
1398 mode_lib->vba.TotalDataReadBandwidth += mode_lib->vba.ReadBandwidthPlaneLuma[k]
1399 + mode_lib->vba.ReadBandwidthPlaneChroma[k];
1402 mode_lib->vba.TotalDCCActiveDPP = 0;
1403 mode_lib->vba.TotalActiveDPP = 0;
1404 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1405 mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP
1406 + mode_lib->vba.DPPPerPlane[k];
1407 if (mode_lib->vba.DCCEnable[k])
1408 mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP
1409 + mode_lib->vba.DPPPerPlane[k];
1412 mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency =
1413 (mode_lib->vba.RoundTripPingLatencyCycles + 32) / mode_lib->vba.DCFCLK
1414 + mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly
1415 * mode_lib->vba.NumberOfChannels
1416 / mode_lib->vba.ReturnBW;
1418 mode_lib->vba.LastPixelOfLineExtraWatermark = 0;
1419 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1420 double DataFabricLineDeliveryTimeLuma, DataFabricLineDeliveryTimeChroma;
1422 if (mode_lib->vba.VRatio[k] <= 1.0)
1423 mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] =
1424 (double) mode_lib->vba.SwathWidthY[k]
1425 * mode_lib->vba.DPPPerPlane[k]
1426 / mode_lib->vba.HRatio[k]
1427 / mode_lib->vba.PixelClock[k];
1429 mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] =
1430 (double) mode_lib->vba.SwathWidthY[k]
1431 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
1432 / mode_lib->vba.DPPCLK[k];
1434 DataFabricLineDeliveryTimeLuma = mode_lib->vba.SwathWidthSingleDPPY[k]
1435 * mode_lib->vba.SwathHeightY[k]
1436 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1)
1437 / (mode_lib->vba.ReturnBW * mode_lib->vba.ReadBandwidthPlaneLuma[k]
1438 / mode_lib->vba.TotalDataReadBandwidth);
1439 mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max(
1440 mode_lib->vba.LastPixelOfLineExtraWatermark,
1441 DataFabricLineDeliveryTimeLuma
1442 - mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]);
1444 if (mode_lib->vba.BytePerPixelDETC[k] == 0)
1445 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 0.0;
1446 else if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0)
1447 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] =
1448 mode_lib->vba.SwathWidthY[k] / 2.0
1449 * mode_lib->vba.DPPPerPlane[k]
1450 / (mode_lib->vba.HRatio[k] / 2.0)
1451 / mode_lib->vba.PixelClock[k];
1453 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] =
1454 mode_lib->vba.SwathWidthY[k] / 2.0
1455 / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k]
1456 / mode_lib->vba.DPPCLK[k];
1458 DataFabricLineDeliveryTimeChroma = mode_lib->vba.SwathWidthSingleDPPY[k] / 2.0
1459 * mode_lib->vba.SwathHeightC[k]
1460 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2)
1461 / (mode_lib->vba.ReturnBW
1462 * mode_lib->vba.ReadBandwidthPlaneChroma[k]
1463 / mode_lib->vba.TotalDataReadBandwidth);
1464 mode_lib->vba.LastPixelOfLineExtraWatermark =
1466 mode_lib->vba.LastPixelOfLineExtraWatermark,
1467 DataFabricLineDeliveryTimeChroma
1468 - mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]);
1471 mode_lib->vba.UrgentExtraLatency = mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency
1472 + (mode_lib->vba.TotalActiveDPP * mode_lib->vba.PixelChunkSizeInKByte
1473 + mode_lib->vba.TotalDCCActiveDPP
1474 * mode_lib->vba.MetaChunkSize) * 1024.0
1475 / mode_lib->vba.ReturnBW;
1477 if (mode_lib->vba.GPUVMEnable)
1478 mode_lib->vba.UrgentExtraLatency += mode_lib->vba.TotalActiveDPP
1479 * mode_lib->vba.PTEGroupSize / mode_lib->vba.ReturnBW;
1481 mode_lib->vba.UrgentWatermark = mode_lib->vba.UrgentLatencyPixelDataOnly
1482 + mode_lib->vba.LastPixelOfLineExtraWatermark
1483 + mode_lib->vba.UrgentExtraLatency;
1485 DTRACE(" urgent_extra_latency = %fus", mode_lib->vba.UrgentExtraLatency);
1486 DTRACE(" wm_urgent = %fus", mode_lib->vba.UrgentWatermark);
1488 mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly;
1490 mode_lib->vba.TotalActiveWriteback = 0;
1491 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1492 if (mode_lib->vba.WritebackEnable[k])
1493 mode_lib->vba.TotalActiveWriteback = mode_lib->vba.TotalActiveWriteback + mode_lib->vba.ActiveWritebacksPerPlane[k];
1496 if (mode_lib->vba.TotalActiveWriteback <= 1)
1497 mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency;
1499 mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency
1500 + mode_lib->vba.WritebackChunkSize * 1024.0 / 32
1501 / mode_lib->vba.SOCCLK;
1503 DTRACE(" wm_wb_urgent = %fus", mode_lib->vba.WritebackUrgentWatermark);
1505 // NB P-State/DRAM Clock Change Watermark
1506 mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency
1507 + mode_lib->vba.UrgentWatermark;
1509 DTRACE(" wm_pstate_change = %fus", mode_lib->vba.DRAMClockChangeWatermark);
1511 DTRACE(" calculating wb pstate watermark");
1512 DTRACE(" total wb outputs %d", mode_lib->vba.TotalActiveWriteback);
1513 DTRACE(" socclk frequency %f Mhz", mode_lib->vba.SOCCLK);
1515 if (mode_lib->vba.TotalActiveWriteback <= 1)
1516 mode_lib->vba.WritebackDRAMClockChangeWatermark =
1517 mode_lib->vba.DRAMClockChangeLatency
1518 + mode_lib->vba.WritebackLatency;
1520 mode_lib->vba.WritebackDRAMClockChangeWatermark =
1521 mode_lib->vba.DRAMClockChangeLatency
1522 + mode_lib->vba.WritebackLatency
1523 + mode_lib->vba.WritebackChunkSize * 1024.0 / 32
1524 / mode_lib->vba.SOCCLK;
1526 DTRACE(" wm_wb_pstate %fus", mode_lib->vba.WritebackDRAMClockChangeWatermark);
1528 // Stutter Efficiency
1529 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1530 mode_lib->vba.LinesInDETY[k] = mode_lib->vba.DETBufferSizeY[k]
1531 / mode_lib->vba.BytePerPixelDETY[k] / mode_lib->vba.SwathWidthY[k];
1532 mode_lib->vba.LinesInDETYRoundedDownToSwath[k] = dml_floor(
1533 mode_lib->vba.LinesInDETY[k],
1534 mode_lib->vba.SwathHeightY[k]);
1535 mode_lib->vba.FullDETBufferingTimeY[k] =
1536 mode_lib->vba.LinesInDETYRoundedDownToSwath[k]
1537 * (mode_lib->vba.HTotal[k]
1538 / mode_lib->vba.PixelClock[k])
1539 / mode_lib->vba.VRatio[k];
1540 if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1541 mode_lib->vba.LinesInDETC[k] = mode_lib->vba.DETBufferSizeC[k]
1542 / mode_lib->vba.BytePerPixelDETC[k]
1543 / (mode_lib->vba.SwathWidthY[k] / 2);
1544 mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = dml_floor(
1545 mode_lib->vba.LinesInDETC[k],
1546 mode_lib->vba.SwathHeightC[k]);
1547 mode_lib->vba.FullDETBufferingTimeC[k] =
1548 mode_lib->vba.LinesInDETCRoundedDownToSwath[k]
1549 * (mode_lib->vba.HTotal[k]
1550 / mode_lib->vba.PixelClock[k])
1551 / (mode_lib->vba.VRatio[k] / 2);
1553 mode_lib->vba.LinesInDETC[k] = 0;
1554 mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = 0;
1555 mode_lib->vba.FullDETBufferingTimeC[k] = 999999;
1559 mode_lib->vba.MinFullDETBufferingTime = 999999.0;
1560 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1561 if (mode_lib->vba.FullDETBufferingTimeY[k]
1562 < mode_lib->vba.MinFullDETBufferingTime) {
1563 mode_lib->vba.MinFullDETBufferingTime =
1564 mode_lib->vba.FullDETBufferingTimeY[k];
1565 mode_lib->vba.FrameTimeForMinFullDETBufferingTime =
1566 (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k]
1567 / mode_lib->vba.PixelClock[k];
1569 if (mode_lib->vba.FullDETBufferingTimeC[k]
1570 < mode_lib->vba.MinFullDETBufferingTime) {
1571 mode_lib->vba.MinFullDETBufferingTime =
1572 mode_lib->vba.FullDETBufferingTimeC[k];
1573 mode_lib->vba.FrameTimeForMinFullDETBufferingTime =
1574 (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k]
1575 / mode_lib->vba.PixelClock[k];
1579 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 0.0;
1580 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1581 if (mode_lib->vba.DCCEnable[k]) {
1582 mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1583 mode_lib->vba.AverageReadBandwidthGBytePerSecond
1584 + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1585 / mode_lib->vba.DCCRate[k]
1587 + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1588 / mode_lib->vba.DCCRate[k]
1591 mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1592 mode_lib->vba.AverageReadBandwidthGBytePerSecond
1593 + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1595 + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1598 if (mode_lib->vba.DCCEnable[k]) {
1599 mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1600 mode_lib->vba.AverageReadBandwidthGBytePerSecond
1601 + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1603 + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1606 if (mode_lib->vba.GPUVMEnable) {
1607 mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1608 mode_lib->vba.AverageReadBandwidthGBytePerSecond
1609 + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1611 + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1616 mode_lib->vba.PartOfBurstThatFitsInROB =
1618 mode_lib->vba.MinFullDETBufferingTime
1619 * mode_lib->vba.TotalDataReadBandwidth,
1620 mode_lib->vba.ROBBufferSizeInKByte * 1024
1621 * mode_lib->vba.TotalDataReadBandwidth
1622 / (mode_lib->vba.AverageReadBandwidthGBytePerSecond
1624 mode_lib->vba.StutterBurstTime = mode_lib->vba.PartOfBurstThatFitsInROB
1625 * (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000)
1626 / mode_lib->vba.TotalDataReadBandwidth / mode_lib->vba.ReturnBW
1627 + (mode_lib->vba.MinFullDETBufferingTime
1628 * mode_lib->vba.TotalDataReadBandwidth
1629 - mode_lib->vba.PartOfBurstThatFitsInROB)
1630 / (mode_lib->vba.DCFCLK * 64);
1631 if (mode_lib->vba.TotalActiveWriteback == 0) {
1632 mode_lib->vba.StutterEfficiencyNotIncludingVBlank = (1
1633 - (mode_lib->vba.SRExitTime + mode_lib->vba.StutterBurstTime)
1634 / mode_lib->vba.MinFullDETBufferingTime) * 100;
1636 mode_lib->vba.StutterEfficiencyNotIncludingVBlank = 0;
1639 mode_lib->vba.SmallestVBlank = 999999;
1640 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1641 if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) {
1642 mode_lib->vba.VBlankTime = (double) (mode_lib->vba.VTotal[k]
1643 - mode_lib->vba.VActive[k]) * mode_lib->vba.HTotal[k]
1644 / mode_lib->vba.PixelClock[k];
1646 mode_lib->vba.VBlankTime = 0;
1648 mode_lib->vba.SmallestVBlank = dml_min(
1649 mode_lib->vba.SmallestVBlank,
1650 mode_lib->vba.VBlankTime);
1653 mode_lib->vba.StutterEfficiency = (mode_lib->vba.StutterEfficiencyNotIncludingVBlank / 100
1654 * (mode_lib->vba.FrameTimeForMinFullDETBufferingTime
1655 - mode_lib->vba.SmallestVBlank)
1656 + mode_lib->vba.SmallestVBlank)
1657 / mode_lib->vba.FrameTimeForMinFullDETBufferingTime * 100;
1659 // dml_ml->vba.DCFCLK Deep Sleep
1660 mode_lib->vba.DCFCLKDeepSleep = 8.0;
1662 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++) {
1663 if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1664 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] =
1666 1.1 * mode_lib->vba.SwathWidthY[k]
1668 mode_lib->vba.BytePerPixelDETY[k],
1670 / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k],
1671 1.1 * mode_lib->vba.SwathWidthY[k] / 2.0
1673 mode_lib->vba.BytePerPixelDETC[k],
1675 / mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]);
1677 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1.1 * mode_lib->vba.SwathWidthY[k]
1678 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 64.0
1679 / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k];
1680 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max(
1681 mode_lib->vba.DCFCLKDeepSleepPerPlane[k],
1682 mode_lib->vba.PixelClock[k] / 16.0);
1683 mode_lib->vba.DCFCLKDeepSleep = dml_max(
1684 mode_lib->vba.DCFCLKDeepSleep,
1685 mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
1688 " dcfclk_deepsleep_per_plane[%i] = %fMHz",
1690 mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
1693 DTRACE(" dcfclk_deepsleep_mhz = %fMHz", mode_lib->vba.DCFCLKDeepSleep);
1695 // Stutter Watermark
1696 mode_lib->vba.StutterExitWatermark = mode_lib->vba.SRExitTime
1697 + mode_lib->vba.LastPixelOfLineExtraWatermark
1698 + mode_lib->vba.UrgentExtraLatency + 10 / mode_lib->vba.DCFCLKDeepSleep;
1699 mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.SREnterPlusExitTime
1700 + mode_lib->vba.LastPixelOfLineExtraWatermark
1701 + mode_lib->vba.UrgentExtraLatency;
1703 DTRACE(" wm_cstate_exit = %fus", mode_lib->vba.StutterExitWatermark);
1704 DTRACE(" wm_cstate_enter_exit = %fus", mode_lib->vba.StutterEnterPlusExitWatermark);
1706 // Urgent Latency Supported
1707 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1708 mode_lib->vba.EffectiveDETPlusLBLinesLuma =
1710 mode_lib->vba.LinesInDETY[k]
1712 mode_lib->vba.LinesInDETY[k]
1713 * mode_lib->vba.DPPCLK[k]
1714 * mode_lib->vba.BytePerPixelDETY[k]
1715 * mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
1716 / (mode_lib->vba.ReturnBW
1717 / mode_lib->vba.DPPPerPlane[k]),
1718 (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma),
1719 mode_lib->vba.SwathHeightY[k]);
1721 mode_lib->vba.UrgentLatencySupportUsLuma = mode_lib->vba.EffectiveDETPlusLBLinesLuma
1722 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1723 / mode_lib->vba.VRatio[k]
1724 - mode_lib->vba.EffectiveDETPlusLBLinesLuma
1725 * mode_lib->vba.SwathWidthY[k]
1726 * mode_lib->vba.BytePerPixelDETY[k]
1727 / (mode_lib->vba.ReturnBW
1728 / mode_lib->vba.DPPPerPlane[k]);
1730 if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1731 mode_lib->vba.EffectiveDETPlusLBLinesChroma =
1733 mode_lib->vba.LinesInDETC[k]
1735 mode_lib->vba.LinesInDETC[k]
1736 * mode_lib->vba.DPPCLK[k]
1737 * mode_lib->vba.BytePerPixelDETC[k]
1738 * mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k]
1739 / (mode_lib->vba.ReturnBW
1740 / mode_lib->vba.DPPPerPlane[k]),
1741 (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma),
1742 mode_lib->vba.SwathHeightC[k]);
1743 mode_lib->vba.UrgentLatencySupportUsChroma =
1744 mode_lib->vba.EffectiveDETPlusLBLinesChroma
1745 * (mode_lib->vba.HTotal[k]
1746 / mode_lib->vba.PixelClock[k])
1747 / (mode_lib->vba.VRatio[k] / 2)
1748 - mode_lib->vba.EffectiveDETPlusLBLinesChroma
1749 * (mode_lib->vba.SwathWidthY[k]
1751 * mode_lib->vba.BytePerPixelDETC[k]
1752 / (mode_lib->vba.ReturnBW
1753 / mode_lib->vba.DPPPerPlane[k]);
1754 mode_lib->vba.UrgentLatencySupportUs[k] = dml_min(
1755 mode_lib->vba.UrgentLatencySupportUsLuma,
1756 mode_lib->vba.UrgentLatencySupportUsChroma);
1758 mode_lib->vba.UrgentLatencySupportUs[k] =
1759 mode_lib->vba.UrgentLatencySupportUsLuma;
1763 mode_lib->vba.MinUrgentLatencySupportUs = 999999;
1764 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1765 mode_lib->vba.MinUrgentLatencySupportUs = dml_min(
1766 mode_lib->vba.MinUrgentLatencySupportUs,
1767 mode_lib->vba.UrgentLatencySupportUs[k]);
1770 // Non-Urgent Latency Tolerance
1771 mode_lib->vba.NonUrgentLatencyTolerance = mode_lib->vba.MinUrgentLatencySupportUs
1772 - mode_lib->vba.UrgentWatermark;
1775 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1776 if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
1777 mode_lib->vba.DSCCLK_calculated[k] = 0.0;
1779 if (mode_lib->vba.OutputFormat[k] == dm_420
1780 || mode_lib->vba.OutputFormat[k] == dm_n422)
1781 mode_lib->vba.DSCFormatFactor = 2;
1783 mode_lib->vba.DSCFormatFactor = 1;
1784 if (mode_lib->vba.ODMCombineEnabled[k])
1785 mode_lib->vba.DSCCLK_calculated[k] =
1786 mode_lib->vba.PixelClockBackEnd[k] / 6
1787 / mode_lib->vba.DSCFormatFactor
1789 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1792 mode_lib->vba.DSCCLK_calculated[k] =
1793 mode_lib->vba.PixelClockBackEnd[k] / 3
1794 / mode_lib->vba.DSCFormatFactor
1796 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1803 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1804 double bpp = mode_lib->vba.OutputBpp[k];
1805 unsigned int slices = mode_lib->vba.NumberOfDSCSlices[k];
1807 if (mode_lib->vba.DSCEnabled[k] && bpp != 0) {
1808 if (!mode_lib->vba.ODMCombineEnabled[k]) {
1809 mode_lib->vba.DSCDelay[k] =
1811 mode_lib->vba.DSCInputBitPerComponent[k],
1814 (double) mode_lib->vba.HActive[k]
1815 / mode_lib->vba.NumberOfDSCSlices[k],
1818 mode_lib->vba.OutputFormat[k])
1820 mode_lib->vba.OutputFormat[k]);
1822 mode_lib->vba.DSCDelay[k] =
1824 * (dscceComputeDelay(
1825 mode_lib->vba.DSCInputBitPerComponent[k],
1828 (double) mode_lib->vba.HActive[k]
1829 / mode_lib->vba.NumberOfDSCSlices[k],
1832 mode_lib->vba.OutputFormat[k])
1834 mode_lib->vba.OutputFormat[k]));
1836 mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[k]
1837 * mode_lib->vba.PixelClock[k]
1838 / mode_lib->vba.PixelClockBackEnd[k];
1840 mode_lib->vba.DSCDelay[k] = 0;
1844 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
1845 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) // NumberOfPlanes
1846 if (j != k && mode_lib->vba.BlendingAndTiming[k] == j
1847 && mode_lib->vba.DSCEnabled[j])
1848 mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[j];
1851 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1852 unsigned int PDEAndMetaPTEBytesFrameY;
1853 unsigned int PixelPTEBytesPerRowY;
1854 unsigned int MetaRowByteY;
1855 unsigned int MetaRowByteC;
1856 unsigned int PDEAndMetaPTEBytesFrameC;
1857 unsigned int PixelPTEBytesPerRowC;
1859 Calculate256BBlockSizes(
1860 mode_lib->vba.SourcePixelFormat[k],
1861 mode_lib->vba.SurfaceTiling[k],
1862 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
1863 dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2),
1864 &mode_lib->vba.BlockHeight256BytesY[k],
1865 &mode_lib->vba.BlockHeight256BytesC[k],
1866 &mode_lib->vba.BlockWidth256BytesY[k],
1867 &mode_lib->vba.BlockWidth256BytesC[k]);
1868 PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
1870 mode_lib->vba.DCCEnable[k],
1871 mode_lib->vba.BlockHeight256BytesY[k],
1872 mode_lib->vba.BlockWidth256BytesY[k],
1873 mode_lib->vba.SourcePixelFormat[k],
1874 mode_lib->vba.SurfaceTiling[k],
1875 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
1876 mode_lib->vba.SourceScan[k],
1877 mode_lib->vba.ViewportWidth[k],
1878 mode_lib->vba.ViewportHeight[k],
1879 mode_lib->vba.SwathWidthY[k],
1880 mode_lib->vba.GPUVMEnable,
1881 mode_lib->vba.VMMPageSize,
1882 mode_lib->vba.PTEBufferSizeInRequestsLuma,
1883 mode_lib->vba.PDEProcessingBufIn64KBReqs,
1884 mode_lib->vba.PitchY[k],
1885 mode_lib->vba.DCCMetaPitchY[k],
1886 &mode_lib->vba.MacroTileWidthY[k],
1888 &PixelPTEBytesPerRowY,
1889 &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0],
1890 &mode_lib->vba.dpte_row_height[k],
1891 &mode_lib->vba.meta_row_height[k]);
1892 mode_lib->vba.PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
1894 mode_lib->vba.VRatio[k],
1895 mode_lib->vba.vtaps[k],
1896 mode_lib->vba.Interlace[k],
1897 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1898 mode_lib->vba.SwathHeightY[k],
1899 mode_lib->vba.ViewportYStartY[k],
1900 &mode_lib->vba.VInitPreFillY[k],
1901 &mode_lib->vba.MaxNumSwathY[k]);
1903 if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1904 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1905 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1906 && mode_lib->vba.SourcePixelFormat[k] != dm_444_8)) {
1907 PDEAndMetaPTEBytesFrameC =
1908 CalculateVMAndRowBytes(
1910 mode_lib->vba.DCCEnable[k],
1911 mode_lib->vba.BlockHeight256BytesC[k],
1912 mode_lib->vba.BlockWidth256BytesC[k],
1913 mode_lib->vba.SourcePixelFormat[k],
1914 mode_lib->vba.SurfaceTiling[k],
1916 mode_lib->vba.BytePerPixelDETC[k],
1918 mode_lib->vba.SourceScan[k],
1919 mode_lib->vba.ViewportWidth[k] / 2,
1920 mode_lib->vba.ViewportHeight[k] / 2,
1921 mode_lib->vba.SwathWidthY[k] / 2,
1922 mode_lib->vba.GPUVMEnable,
1923 mode_lib->vba.VMMPageSize,
1924 mode_lib->vba.PTEBufferSizeInRequestsLuma,
1925 mode_lib->vba.PDEProcessingBufIn64KBReqs,
1926 mode_lib->vba.PitchC[k],
1928 &mode_lib->vba.MacroTileWidthC[k],
1930 &PixelPTEBytesPerRowC,
1931 &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0],
1932 &mode_lib->vba.dpte_row_height_chroma[k],
1933 &mode_lib->vba.meta_row_height_chroma[k]);
1934 mode_lib->vba.PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(
1936 mode_lib->vba.VRatio[k] / 2,
1937 mode_lib->vba.VTAPsChroma[k],
1938 mode_lib->vba.Interlace[k],
1939 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1940 mode_lib->vba.SwathHeightC[k],
1941 mode_lib->vba.ViewportYStartC[k],
1942 &mode_lib->vba.VInitPreFillC[k],
1943 &mode_lib->vba.MaxNumSwathC[k]);
1945 PixelPTEBytesPerRowC = 0;
1946 PDEAndMetaPTEBytesFrameC = 0;
1948 mode_lib->vba.MaxNumSwathC[k] = 0;
1949 mode_lib->vba.PrefetchSourceLinesC[k] = 0;
1952 mode_lib->vba.PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC;
1953 mode_lib->vba.PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY
1954 + PDEAndMetaPTEBytesFrameC;
1955 mode_lib->vba.MetaRowByte[k] = MetaRowByteY + MetaRowByteC;
1957 CalculateActiveRowBandwidth(
1958 mode_lib->vba.GPUVMEnable,
1959 mode_lib->vba.SourcePixelFormat[k],
1960 mode_lib->vba.VRatio[k],
1961 mode_lib->vba.DCCEnable[k],
1962 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
1965 mode_lib->vba.meta_row_height[k],
1966 mode_lib->vba.meta_row_height_chroma[k],
1967 PixelPTEBytesPerRowY,
1968 PixelPTEBytesPerRowC,
1969 mode_lib->vba.dpte_row_height[k],
1970 mode_lib->vba.dpte_row_height_chroma[k],
1971 &mode_lib->vba.meta_row_bw[k],
1972 &mode_lib->vba.dpte_row_bw[k],
1973 &mode_lib->vba.qual_row_bw[k]);
1976 mode_lib->vba.TCalc = 24.0 / mode_lib->vba.DCFCLKDeepSleep;
1978 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1979 if (mode_lib->vba.BlendingAndTiming[k] == k) {
1980 if (mode_lib->vba.WritebackEnable[k] == true) {
1981 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
1982 mode_lib->vba.WritebackLatency
1983 + CalculateWriteBackDelay(
1984 mode_lib->vba.WritebackPixelFormat[k],
1985 mode_lib->vba.WritebackHRatio[k],
1986 mode_lib->vba.WritebackVRatio[k],
1987 mode_lib->vba.WritebackLumaHTaps[k],
1988 mode_lib->vba.WritebackLumaVTaps[k],
1989 mode_lib->vba.WritebackChromaHTaps[k],
1990 mode_lib->vba.WritebackChromaVTaps[k],
1991 mode_lib->vba.WritebackDestinationWidth[k])
1992 / mode_lib->vba.DISPCLK;
1994 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
1995 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
1996 if (mode_lib->vba.BlendingAndTiming[j] == k
1997 && mode_lib->vba.WritebackEnable[j] == true) {
1998 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
2000 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k],
2001 mode_lib->vba.WritebackLatency
2002 + CalculateWriteBackDelay(
2003 mode_lib->vba.WritebackPixelFormat[j],
2004 mode_lib->vba.WritebackHRatio[j],
2005 mode_lib->vba.WritebackVRatio[j],
2006 mode_lib->vba.WritebackLumaHTaps[j],
2007 mode_lib->vba.WritebackLumaVTaps[j],
2008 mode_lib->vba.WritebackChromaHTaps[j],
2009 mode_lib->vba.WritebackChromaVTaps[j],
2010 mode_lib->vba.WritebackDestinationWidth[j])
2011 / mode_lib->vba.DISPCLK);
2017 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
2018 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j)
2019 if (mode_lib->vba.BlendingAndTiming[k] == j)
2020 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
2021 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][j];
2023 mode_lib->vba.VStartupLines = 13;
2024 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2025 mode_lib->vba.MaxVStartupLines[k] =
2026 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
2030 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k]
2031 / (mode_lib->vba.HTotal[k]
2032 / mode_lib->vba.PixelClock[k]),
2036 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
2037 mode_lib->vba.MaximumMaxVStartupLines = dml_max(
2038 mode_lib->vba.MaximumMaxVStartupLines,
2039 mode_lib->vba.MaxVStartupLines[k]);
2041 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2042 mode_lib->vba.cursor_bw[k] = 0.0;
2043 for (j = 0; j < mode_lib->vba.NumberOfCursors[k]; ++j)
2044 mode_lib->vba.cursor_bw[k] += mode_lib->vba.CursorWidth[k][j]
2045 * mode_lib->vba.CursorBPP[k][j] / 8.0
2046 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
2047 * mode_lib->vba.VRatio[k];
2051 double MaxTotalRDBandwidth = 0;
2052 bool DestinationLineTimesForPrefetchLessThan2 = false;
2053 bool VRatioPrefetchMoreThan4 = false;
2054 bool prefetch_vm_bw_valid = true;
2055 bool prefetch_row_bw_valid = true;
2056 double TWait = CalculateTWait(
2057 mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
2058 mode_lib->vba.DRAMClockChangeLatency,
2059 mode_lib->vba.UrgentLatencyPixelDataOnly,
2060 mode_lib->vba.SREnterPlusExitTime);
2062 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2063 if (mode_lib->vba.XFCEnabled[k] == true) {
2064 mode_lib->vba.XFCRemoteSurfaceFlipDelay =
2065 CalculateRemoteSurfaceFlipDelay(
2067 mode_lib->vba.VRatio[k],
2068 mode_lib->vba.SwathWidthY[k],
2070 mode_lib->vba.BytePerPixelDETY[k],
2072 mode_lib->vba.HTotal[k]
2073 / mode_lib->vba.PixelClock[k],
2074 mode_lib->vba.XFCTSlvVupdateOffset,
2075 mode_lib->vba.XFCTSlvVupdateWidth,
2076 mode_lib->vba.XFCTSlvVreadyOffset,
2077 mode_lib->vba.XFCXBUFLatencyTolerance,
2078 mode_lib->vba.XFCFillBWOverhead,
2079 mode_lib->vba.XFCSlvChunkSize,
2080 mode_lib->vba.XFCBusTransportTime,
2081 mode_lib->vba.TCalc,
2083 &mode_lib->vba.SrcActiveDrainRate,
2084 &mode_lib->vba.TInitXFill,
2085 &mode_lib->vba.TslvChk);
2087 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0;
2089 mode_lib->vba.ErrorResult[k] =
2090 CalculatePrefetchSchedule(
2092 mode_lib->vba.DPPCLK[k],
2093 mode_lib->vba.DISPCLK,
2094 mode_lib->vba.PixelClock[k],
2095 mode_lib->vba.DCFCLKDeepSleep,
2096 mode_lib->vba.DSCDelay[k],
2097 mode_lib->vba.DPPPerPlane[k],
2098 mode_lib->vba.ScalerEnabled[k],
2099 mode_lib->vba.NumberOfCursors[k],
2100 mode_lib->vba.DPPCLKDelaySubtotal,
2101 mode_lib->vba.DPPCLKDelaySCL,
2102 mode_lib->vba.DPPCLKDelaySCLLBOnly,
2103 mode_lib->vba.DPPCLKDelayCNVCFormater,
2104 mode_lib->vba.DPPCLKDelayCNVCCursor,
2105 mode_lib->vba.DISPCLKDelaySubtotal,
2106 (unsigned int) (mode_lib->vba.SwathWidthY[k]
2107 / mode_lib->vba.HRatio[k]),
2108 mode_lib->vba.OutputFormat[k],
2109 mode_lib->vba.VTotal[k]
2110 - mode_lib->vba.VActive[k],
2111 mode_lib->vba.HTotal[k],
2112 mode_lib->vba.MaxInterDCNTileRepeaters,
2114 mode_lib->vba.VStartupLines,
2115 mode_lib->vba.MaxVStartupLines[k]),
2116 mode_lib->vba.GPUVMMaxPageTableLevels,
2117 mode_lib->vba.GPUVMEnable,
2118 mode_lib->vba.DynamicMetadataEnable[k],
2119 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
2120 mode_lib->vba.DynamicMetadataTransmittedBytes[k],
2121 mode_lib->vba.DCCEnable[k],
2122 mode_lib->vba.UrgentLatencyPixelDataOnly,
2123 mode_lib->vba.UrgentExtraLatency,
2124 mode_lib->vba.TCalc,
2125 mode_lib->vba.PDEAndMetaPTEBytesFrame[k],
2126 mode_lib->vba.MetaRowByte[k],
2127 mode_lib->vba.PixelPTEBytesPerRow[k],
2128 mode_lib->vba.PrefetchSourceLinesY[k],
2129 mode_lib->vba.SwathWidthY[k],
2130 mode_lib->vba.BytePerPixelDETY[k],
2131 mode_lib->vba.VInitPreFillY[k],
2132 mode_lib->vba.MaxNumSwathY[k],
2133 mode_lib->vba.PrefetchSourceLinesC[k],
2134 mode_lib->vba.BytePerPixelDETC[k],
2135 mode_lib->vba.VInitPreFillC[k],
2136 mode_lib->vba.MaxNumSwathC[k],
2137 mode_lib->vba.SwathHeightY[k],
2138 mode_lib->vba.SwathHeightC[k],
2140 mode_lib->vba.XFCEnabled[k],
2141 mode_lib->vba.XFCRemoteSurfaceFlipDelay,
2142 mode_lib->vba.Interlace[k],
2143 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
2144 &mode_lib->vba.DSTXAfterScaler[k],
2145 &mode_lib->vba.DSTYAfterScaler[k],
2146 &mode_lib->vba.DestinationLinesForPrefetch[k],
2147 &mode_lib->vba.PrefetchBandwidth[k],
2148 &mode_lib->vba.DestinationLinesToRequestVMInVBlank[k],
2149 &mode_lib->vba.DestinationLinesToRequestRowInVBlank[k],
2150 &mode_lib->vba.VRatioPrefetchY[k],
2151 &mode_lib->vba.VRatioPrefetchC[k],
2152 &mode_lib->vba.RequiredPrefetchPixDataBWLuma[k],
2153 &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata,
2154 &mode_lib->vba.Tno_bw[k],
2155 &mode_lib->vba.VUpdateOffsetPix[k],
2156 &mode_lib->vba.VUpdateWidthPix[k],
2157 &mode_lib->vba.VReadyOffsetPix[k]);
2158 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2159 mode_lib->vba.VStartup[k] = dml_min(
2160 mode_lib->vba.VStartupLines,
2161 mode_lib->vba.MaxVStartupLines[k]);
2162 if (mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata
2164 mode_lib->vba.VStartup[k] =
2165 mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata;
2168 mode_lib->vba.VStartup[k] =
2170 mode_lib->vba.VStartupLines,
2171 mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]);
2175 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2177 if (mode_lib->vba.PDEAndMetaPTEBytesFrame[k] == 0)
2178 mode_lib->vba.prefetch_vm_bw[k] = 0;
2179 else if (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] > 0) {
2180 mode_lib->vba.prefetch_vm_bw[k] =
2181 (double) mode_lib->vba.PDEAndMetaPTEBytesFrame[k]
2182 / (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2183 * mode_lib->vba.HTotal[k]
2184 / mode_lib->vba.PixelClock[k]);
2186 mode_lib->vba.prefetch_vm_bw[k] = 0;
2187 prefetch_vm_bw_valid = false;
2189 if (mode_lib->vba.MetaRowByte[k] + mode_lib->vba.PixelPTEBytesPerRow[k]
2191 mode_lib->vba.prefetch_row_bw[k] = 0;
2192 else if (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] > 0) {
2193 mode_lib->vba.prefetch_row_bw[k] =
2194 (double) (mode_lib->vba.MetaRowByte[k]
2195 + mode_lib->vba.PixelPTEBytesPerRow[k])
2196 / (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]
2197 * mode_lib->vba.HTotal[k]
2198 / mode_lib->vba.PixelClock[k]);
2200 mode_lib->vba.prefetch_row_bw[k] = 0;
2201 prefetch_row_bw_valid = false;
2204 MaxTotalRDBandwidth =
2205 MaxTotalRDBandwidth + mode_lib->vba.cursor_bw[k]
2207 mode_lib->vba.prefetch_vm_bw[k],
2209 mode_lib->vba.prefetch_row_bw[k],
2211 mode_lib->vba.ReadBandwidthPlaneLuma[k]
2212 + mode_lib->vba.ReadBandwidthPlaneChroma[k],
2213 mode_lib->vba.RequiredPrefetchPixDataBWLuma[k])
2214 + mode_lib->vba.meta_row_bw[k]
2215 + mode_lib->vba.dpte_row_bw[k]));
2217 if (mode_lib->vba.DestinationLinesForPrefetch[k] < 2)
2218 DestinationLineTimesForPrefetchLessThan2 = true;
2219 if (mode_lib->vba.VRatioPrefetchY[k] > 4
2220 || mode_lib->vba.VRatioPrefetchC[k] > 4)
2221 VRatioPrefetchMoreThan4 = true;
2224 if (MaxTotalRDBandwidth <= mode_lib->vba.ReturnBW && prefetch_vm_bw_valid
2225 && prefetch_row_bw_valid && !VRatioPrefetchMoreThan4
2226 && !DestinationLineTimesForPrefetchLessThan2)
2227 mode_lib->vba.PrefetchModeSupported = true;
2229 mode_lib->vba.PrefetchModeSupported = false;
2231 "DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n");
2234 if (mode_lib->vba.PrefetchModeSupported == true) {
2235 double final_flip_bw[DC__NUM_DPP__MAX];
2236 unsigned int ImmediateFlipBytes[DC__NUM_DPP__MAX];
2237 double total_dcn_read_bw_with_flip = 0;
2239 mode_lib->vba.BandwidthAvailableForImmediateFlip = mode_lib->vba.ReturnBW;
2240 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2241 mode_lib->vba.BandwidthAvailableForImmediateFlip =
2242 mode_lib->vba.BandwidthAvailableForImmediateFlip
2243 - mode_lib->vba.cursor_bw[k]
2245 mode_lib->vba.ReadBandwidthPlaneLuma[k]
2246 + mode_lib->vba.ReadBandwidthPlaneChroma[k]
2247 + mode_lib->vba.qual_row_bw[k],
2248 mode_lib->vba.PrefetchBandwidth[k]);
2251 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2252 ImmediateFlipBytes[k] = 0;
2253 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
2254 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
2255 ImmediateFlipBytes[k] =
2256 mode_lib->vba.PDEAndMetaPTEBytesFrame[k]
2257 + mode_lib->vba.MetaRowByte[k]
2258 + mode_lib->vba.PixelPTEBytesPerRow[k];
2261 mode_lib->vba.TotImmediateFlipBytes = 0;
2262 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2263 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
2264 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
2265 mode_lib->vba.TotImmediateFlipBytes =
2266 mode_lib->vba.TotImmediateFlipBytes
2267 + ImmediateFlipBytes[k];
2270 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2271 CalculateFlipSchedule(
2273 mode_lib->vba.UrgentExtraLatency,
2274 mode_lib->vba.UrgentLatencyPixelDataOnly,
2275 mode_lib->vba.GPUVMMaxPageTableLevels,
2276 mode_lib->vba.GPUVMEnable,
2277 mode_lib->vba.BandwidthAvailableForImmediateFlip,
2278 mode_lib->vba.TotImmediateFlipBytes,
2279 mode_lib->vba.SourcePixelFormat[k],
2280 ImmediateFlipBytes[k],
2281 mode_lib->vba.HTotal[k]
2282 / mode_lib->vba.PixelClock[k],
2283 mode_lib->vba.VRatio[k],
2284 mode_lib->vba.Tno_bw[k],
2285 mode_lib->vba.PDEAndMetaPTEBytesFrame[k],
2286 mode_lib->vba.MetaRowByte[k],
2287 mode_lib->vba.PixelPTEBytesPerRow[k],
2288 mode_lib->vba.DCCEnable[k],
2289 mode_lib->vba.dpte_row_height[k],
2290 mode_lib->vba.meta_row_height[k],
2291 mode_lib->vba.qual_row_bw[k],
2292 &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
2293 &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
2295 &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
2297 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2298 total_dcn_read_bw_with_flip =
2299 total_dcn_read_bw_with_flip
2300 + mode_lib->vba.cursor_bw[k]
2302 mode_lib->vba.prefetch_vm_bw[k],
2304 mode_lib->vba.prefetch_row_bw[k],
2307 mode_lib->vba.ReadBandwidthPlaneLuma[k]
2308 + mode_lib->vba.ReadBandwidthPlaneChroma[k],
2309 mode_lib->vba.RequiredPrefetchPixDataBWLuma[k])));
2311 mode_lib->vba.ImmediateFlipSupported = true;
2312 if (total_dcn_read_bw_with_flip > mode_lib->vba.ReturnBW) {
2313 mode_lib->vba.ImmediateFlipSupported = false;
2315 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2316 if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) {
2317 mode_lib->vba.ImmediateFlipSupported = false;
2321 mode_lib->vba.ImmediateFlipSupported = false;
2324 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2325 if (mode_lib->vba.ErrorResult[k]) {
2326 mode_lib->vba.PrefetchModeSupported = false;
2328 "DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n");
2332 mode_lib->vba.VStartupLines = mode_lib->vba.VStartupLines + 1;
2333 } while (!((mode_lib->vba.PrefetchModeSupported
2334 && (!mode_lib->vba.ImmediateFlipSupport
2335 || mode_lib->vba.ImmediateFlipSupported))
2336 || mode_lib->vba.MaximumMaxVStartupLines < mode_lib->vba.VStartupLines));
2338 //Display Pipeline Delivery Time in Prefetch
2339 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2340 if (mode_lib->vba.VRatioPrefetchY[k] <= 1) {
2341 mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
2342 mode_lib->vba.SwathWidthY[k] * mode_lib->vba.DPPPerPlane[k]
2343 / mode_lib->vba.HRatio[k]
2344 / mode_lib->vba.PixelClock[k];
2346 mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
2347 mode_lib->vba.SwathWidthY[k]
2348 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
2349 / mode_lib->vba.DPPCLK[k];
2351 if (mode_lib->vba.BytePerPixelDETC[k] == 0) {
2352 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
2354 if (mode_lib->vba.VRatioPrefetchC[k] <= 1) {
2355 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] =
2356 mode_lib->vba.SwathWidthY[k]
2357 * mode_lib->vba.DPPPerPlane[k]
2358 / mode_lib->vba.HRatio[k]
2359 / mode_lib->vba.PixelClock[k];
2361 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] =
2362 mode_lib->vba.SwathWidthY[k]
2363 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
2364 / mode_lib->vba.DPPCLK[k];
2370 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2371 if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
2372 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = true;
2373 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true;
2374 mode_lib->vba.MinTTUVBlank[k] = dml_max(
2375 mode_lib->vba.DRAMClockChangeWatermark,
2377 mode_lib->vba.StutterEnterPlusExitWatermark,
2378 mode_lib->vba.UrgentWatermark));
2379 } else if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 1) {
2380 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false;
2381 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true;
2382 mode_lib->vba.MinTTUVBlank[k] = dml_max(
2383 mode_lib->vba.StutterEnterPlusExitWatermark,
2384 mode_lib->vba.UrgentWatermark);
2386 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false;
2387 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = false;
2388 mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.UrgentWatermark;
2390 if (!mode_lib->vba.DynamicMetadataEnable[k])
2391 mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.TCalc
2392 + mode_lib->vba.MinTTUVBlank[k];
2395 // DCC Configuration
2396 mode_lib->vba.ActiveDPPs = 0;
2397 // NB P-State/DRAM Clock Change Support
2398 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2399 mode_lib->vba.ActiveDPPs = mode_lib->vba.ActiveDPPs + mode_lib->vba.DPPPerPlane[k];
2402 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2403 double EffectiveLBLatencyHidingY;
2404 double EffectiveLBLatencyHidingC;
2405 double DPPOutputBufferLinesY;
2406 double DPPOutputBufferLinesC;
2407 double DPPOPPBufferingY;
2408 double MaxDETBufferingTimeY;
2409 double ActiveDRAMClockChangeLatencyMarginY;
2411 mode_lib->vba.LBLatencyHidingSourceLinesY =
2413 mode_lib->vba.MaxLineBufferLines,
2414 (unsigned int) dml_floor(
2415 (double) mode_lib->vba.LineBufferSize
2416 / mode_lib->vba.LBBitPerPixel[k]
2417 / (mode_lib->vba.SwathWidthY[k]
2419 mode_lib->vba.HRatio[k],
2421 1)) - (mode_lib->vba.vtaps[k] - 1);
2423 mode_lib->vba.LBLatencyHidingSourceLinesC =
2425 mode_lib->vba.MaxLineBufferLines,
2426 (unsigned int) dml_floor(
2427 (double) mode_lib->vba.LineBufferSize
2428 / mode_lib->vba.LBBitPerPixel[k]
2429 / (mode_lib->vba.SwathWidthY[k]
2432 mode_lib->vba.HRatio[k]
2436 - (mode_lib->vba.VTAPsChroma[k] - 1);
2438 EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY
2439 / mode_lib->vba.VRatio[k]
2440 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]);
2442 EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC
2443 / (mode_lib->vba.VRatio[k] / 2)
2444 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]);
2446 if (mode_lib->vba.SwathWidthY[k] > 2 * mode_lib->vba.DPPOutputBufferPixels) {
2447 DPPOutputBufferLinesY = mode_lib->vba.DPPOutputBufferPixels
2448 / mode_lib->vba.SwathWidthY[k];
2449 } else if (mode_lib->vba.SwathWidthY[k] > mode_lib->vba.DPPOutputBufferPixels) {
2450 DPPOutputBufferLinesY = 0.5;
2452 DPPOutputBufferLinesY = 1;
2455 if (mode_lib->vba.SwathWidthY[k] / 2 > 2 * mode_lib->vba.DPPOutputBufferPixels) {
2456 DPPOutputBufferLinesC = mode_lib->vba.DPPOutputBufferPixels
2457 / (mode_lib->vba.SwathWidthY[k] / 2);
2458 } else if (mode_lib->vba.SwathWidthY[k] / 2 > mode_lib->vba.DPPOutputBufferPixels) {
2459 DPPOutputBufferLinesC = 0.5;
2461 DPPOutputBufferLinesC = 1;
2464 DPPOPPBufferingY = (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
2465 * (DPPOutputBufferLinesY + mode_lib->vba.OPPOutputBufferLines);
2466 MaxDETBufferingTimeY = mode_lib->vba.FullDETBufferingTimeY[k]
2467 + (mode_lib->vba.LinesInDETY[k]
2468 - mode_lib->vba.LinesInDETYRoundedDownToSwath[k])
2469 / mode_lib->vba.SwathHeightY[k]
2470 * (mode_lib->vba.HTotal[k]
2471 / mode_lib->vba.PixelClock[k]);
2473 ActiveDRAMClockChangeLatencyMarginY = DPPOPPBufferingY + EffectiveLBLatencyHidingY
2474 + MaxDETBufferingTimeY - mode_lib->vba.DRAMClockChangeWatermark;
2476 if (mode_lib->vba.ActiveDPPs > 1) {
2477 ActiveDRAMClockChangeLatencyMarginY =
2478 ActiveDRAMClockChangeLatencyMarginY
2479 - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1))
2480 * mode_lib->vba.SwathHeightY[k]
2481 * (mode_lib->vba.HTotal[k]
2482 / mode_lib->vba.PixelClock[k]);
2485 if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
2486 double DPPOPPBufferingC = (mode_lib->vba.HTotal[k]
2487 / mode_lib->vba.PixelClock[k])
2488 * (DPPOutputBufferLinesC
2489 + mode_lib->vba.OPPOutputBufferLines);
2490 double MaxDETBufferingTimeC =
2491 mode_lib->vba.FullDETBufferingTimeC[k]
2492 + (mode_lib->vba.LinesInDETC[k]
2493 - mode_lib->vba.LinesInDETCRoundedDownToSwath[k])
2494 / mode_lib->vba.SwathHeightC[k]
2495 * (mode_lib->vba.HTotal[k]
2496 / mode_lib->vba.PixelClock[k]);
2497 double ActiveDRAMClockChangeLatencyMarginC = DPPOPPBufferingC
2498 + EffectiveLBLatencyHidingC + MaxDETBufferingTimeC
2499 - mode_lib->vba.DRAMClockChangeWatermark;
2501 if (mode_lib->vba.ActiveDPPs > 1) {
2502 ActiveDRAMClockChangeLatencyMarginC =
2503 ActiveDRAMClockChangeLatencyMarginC
2506 / (mode_lib->vba.ActiveDPPs
2508 * mode_lib->vba.SwathHeightC[k]
2509 * (mode_lib->vba.HTotal[k]
2510 / mode_lib->vba.PixelClock[k]);
2512 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(
2513 ActiveDRAMClockChangeLatencyMarginY,
2514 ActiveDRAMClockChangeLatencyMarginC);
2516 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] =
2517 ActiveDRAMClockChangeLatencyMarginY;
2520 if (mode_lib->vba.WritebackEnable[k]) {
2521 double WritebackDRAMClockChangeLatencyMargin;
2523 if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
2524 WritebackDRAMClockChangeLatencyMargin =
2525 (double) (mode_lib->vba.WritebackInterfaceLumaBufferSize
2526 + mode_lib->vba.WritebackInterfaceChromaBufferSize)
2527 / (mode_lib->vba.WritebackDestinationWidth[k]
2528 * mode_lib->vba.WritebackDestinationHeight[k]
2529 / (mode_lib->vba.WritebackSourceHeight[k]
2530 * mode_lib->vba.HTotal[k]
2531 / mode_lib->vba.PixelClock[k])
2533 - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2534 } else if (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
2535 WritebackDRAMClockChangeLatencyMargin =
2537 (double) mode_lib->vba.WritebackInterfaceLumaBufferSize
2540 * mode_lib->vba.WritebackInterfaceChromaBufferSize
2542 / (mode_lib->vba.WritebackDestinationWidth[k]
2543 * mode_lib->vba.WritebackDestinationHeight[k]
2544 / (mode_lib->vba.WritebackSourceHeight[k]
2545 * mode_lib->vba.HTotal[k]
2546 / mode_lib->vba.PixelClock[k]))
2547 - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2549 WritebackDRAMClockChangeLatencyMargin =
2551 (double) mode_lib->vba.WritebackInterfaceLumaBufferSize,
2553 * mode_lib->vba.WritebackInterfaceChromaBufferSize)
2554 / (mode_lib->vba.WritebackDestinationWidth[k]
2555 * mode_lib->vba.WritebackDestinationHeight[k]
2556 / (mode_lib->vba.WritebackSourceHeight[k]
2557 * mode_lib->vba.HTotal[k]
2558 / mode_lib->vba.PixelClock[k]))
2559 - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2561 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(
2562 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k],
2563 WritebackDRAMClockChangeLatencyMargin);
2567 mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999;
2568 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2569 if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]
2570 < mode_lib->vba.MinActiveDRAMClockChangeMargin) {
2571 mode_lib->vba.MinActiveDRAMClockChangeMargin =
2572 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
2576 mode_lib->vba.MinActiveDRAMClockChangeLatencySupported =
2577 mode_lib->vba.MinActiveDRAMClockChangeMargin
2578 + mode_lib->vba.DRAMClockChangeLatency;
2580 if (mode_lib->vba.DRAMClockChangeSupportsVActive &&
2581 mode_lib->vba.MinActiveDRAMClockChangeMargin > 50) {
2582 mode_lib->vba.DRAMClockChangeWatermark += 25;
2583 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vactive;
2585 if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) {
2586 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vblank;
2587 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2588 if (!mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k]) {
2589 mode_lib->vba.DRAMClockChangeSupport[0][0] =
2590 dm_dram_clock_change_unsupported;
2594 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_unsupported;
2597 for (k = 0; k <= mode_lib->vba.soc.num_states; k++)
2598 for (j = 0; j < 2; j++)
2599 mode_lib->vba.DRAMClockChangeSupport[k][j] = mode_lib->vba.DRAMClockChangeSupport[0][0];
2602 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2603 if (mode_lib->vba.XFCEnabled[k] == true) {
2606 mode_lib->vba.XFCSlaveVUpdateOffset[k] = mode_lib->vba.XFCTSlvVupdateOffset;
2607 mode_lib->vba.XFCSlaveVupdateWidth[k] = mode_lib->vba.XFCTSlvVupdateWidth;
2608 mode_lib->vba.XFCSlaveVReadyOffset[k] = mode_lib->vba.XFCTSlvVreadyOffset;
2609 TWait = CalculateTWait(
2610 mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
2611 mode_lib->vba.DRAMClockChangeLatency,
2612 mode_lib->vba.UrgentLatencyPixelDataOnly,
2613 mode_lib->vba.SREnterPlusExitTime);
2614 mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay(
2616 mode_lib->vba.VRatio[k],
2617 mode_lib->vba.SwathWidthY[k],
2618 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
2619 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2620 mode_lib->vba.XFCTSlvVupdateOffset,
2621 mode_lib->vba.XFCTSlvVupdateWidth,
2622 mode_lib->vba.XFCTSlvVreadyOffset,
2623 mode_lib->vba.XFCXBUFLatencyTolerance,
2624 mode_lib->vba.XFCFillBWOverhead,
2625 mode_lib->vba.XFCSlvChunkSize,
2626 mode_lib->vba.XFCBusTransportTime,
2627 mode_lib->vba.TCalc,
2629 &mode_lib->vba.SrcActiveDrainRate,
2630 &mode_lib->vba.TInitXFill,
2631 &mode_lib->vba.TslvChk);
2632 mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] =
2634 mode_lib->vba.XFCRemoteSurfaceFlipDelay
2635 / (mode_lib->vba.HTotal[k]
2636 / mode_lib->vba.PixelClock[k]),
2638 mode_lib->vba.XFCTransferDelay[k] =
2640 mode_lib->vba.XFCBusTransportTime
2641 / (mode_lib->vba.HTotal[k]
2642 / mode_lib->vba.PixelClock[k]),
2644 mode_lib->vba.XFCPrechargeDelay[k] =
2646 (mode_lib->vba.XFCBusTransportTime
2647 + mode_lib->vba.TInitXFill
2648 + mode_lib->vba.TslvChk)
2649 / (mode_lib->vba.HTotal[k]
2650 / mode_lib->vba.PixelClock[k]),
2652 mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance
2653 * mode_lib->vba.SrcActiveDrainRate;
2654 mode_lib->vba.FinalFillMargin =
2655 (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2656 + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2657 * mode_lib->vba.HTotal[k]
2658 / mode_lib->vba.PixelClock[k]
2659 * mode_lib->vba.SrcActiveDrainRate
2660 + mode_lib->vba.XFCFillConstant;
2661 mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay
2662 * mode_lib->vba.SrcActiveDrainRate
2663 + mode_lib->vba.FinalFillMargin;
2664 mode_lib->vba.RemainingFillLevel = dml_max(
2666 mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel);
2667 mode_lib->vba.TFinalxFill = mode_lib->vba.RemainingFillLevel
2668 / (mode_lib->vba.SrcActiveDrainRate
2669 * mode_lib->vba.XFCFillBWOverhead / 100);
2670 mode_lib->vba.XFCPrefetchMargin[k] =
2671 mode_lib->vba.XFCRemoteSurfaceFlipDelay
2672 + mode_lib->vba.TFinalxFill
2673 + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2674 + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2675 * mode_lib->vba.HTotal[k]
2676 / mode_lib->vba.PixelClock[k];
2678 mode_lib->vba.XFCSlaveVUpdateOffset[k] = 0;
2679 mode_lib->vba.XFCSlaveVupdateWidth[k] = 0;
2680 mode_lib->vba.XFCSlaveVReadyOffset[k] = 0;
2681 mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = 0;
2682 mode_lib->vba.XFCPrechargeDelay[k] = 0;
2683 mode_lib->vba.XFCTransferDelay[k] = 0;
2684 mode_lib->vba.XFCPrefetchMargin[k] = 0;
2688 unsigned int VStartupMargin = 0;
2689 bool FirstMainPlane = true;
2691 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2692 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2693 unsigned int Margin = (mode_lib->vba.MaxVStartupLines[k] - mode_lib->vba.VStartup[k])
2694 * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k];
2696 if (FirstMainPlane) {
2697 VStartupMargin = Margin;
2698 FirstMainPlane = false;
2700 VStartupMargin = dml_min(VStartupMargin, Margin);
2703 if (mode_lib->vba.UseMaximumVStartup) {
2704 if (mode_lib->vba.VTotal_Max[k] == mode_lib->vba.VTotal[k]) {
2705 //only use max vstart if it is not drr or lateflip.
2706 mode_lib->vba.VStartup[k] = mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]];
2713 static void dml20_DisplayPipeConfiguration(struct display_mode_lib *mode_lib)
2715 double BytePerPixDETY;
2716 double BytePerPixDETC;
2717 double Read256BytesBlockHeightY;
2718 double Read256BytesBlockHeightC;
2719 double Read256BytesBlockWidthY;
2720 double Read256BytesBlockWidthC;
2721 double MaximumSwathHeightY;
2722 double MaximumSwathHeightC;
2723 double MinimumSwathHeightY;
2724 double MinimumSwathHeightC;
2726 double SwathWidthGranularityY;
2727 double SwathWidthGranularityC;
2728 double RoundedUpMaxSwathSizeBytesY;
2729 double RoundedUpMaxSwathSizeBytesC;
2732 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2733 bool MainPlaneDoesODMCombine = false;
2735 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2738 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
2741 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2744 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) {
2747 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2751 BytePerPixDETY = 4.0 / 3.0;
2752 BytePerPixDETC = 8.0 / 3.0;
2755 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2756 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2757 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2758 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2759 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2760 Read256BytesBlockHeightY = 1;
2761 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2762 Read256BytesBlockHeightY = 4;
2763 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2764 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2765 Read256BytesBlockHeightY = 8;
2767 Read256BytesBlockHeightY = 16;
2769 Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2770 / Read256BytesBlockHeightY;
2771 Read256BytesBlockHeightC = 0;
2772 Read256BytesBlockWidthC = 0;
2774 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2775 Read256BytesBlockHeightY = 1;
2776 Read256BytesBlockHeightC = 1;
2777 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2778 Read256BytesBlockHeightY = 16;
2779 Read256BytesBlockHeightC = 8;
2781 Read256BytesBlockHeightY = 8;
2782 Read256BytesBlockHeightC = 8;
2784 Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2785 / Read256BytesBlockHeightY;
2786 Read256BytesBlockWidthC = 256 / dml_ceil(BytePerPixDETC, 2)
2787 / Read256BytesBlockHeightC;
2790 if (mode_lib->vba.SourceScan[k] == dm_horz) {
2791 MaximumSwathHeightY = Read256BytesBlockHeightY;
2792 MaximumSwathHeightC = Read256BytesBlockHeightC;
2794 MaximumSwathHeightY = Read256BytesBlockWidthY;
2795 MaximumSwathHeightC = Read256BytesBlockWidthC;
2798 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2799 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2800 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2801 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2802 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
2803 || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2804 && (mode_lib->vba.SurfaceTiling[k]
2806 || mode_lib->vba.SurfaceTiling[k]
2808 || mode_lib->vba.SurfaceTiling[k]
2810 || mode_lib->vba.SurfaceTiling[k]
2812 || mode_lib->vba.SurfaceTiling[k]
2814 || mode_lib->vba.SurfaceTiling[k]
2816 || mode_lib->vba.SurfaceTiling[k]
2818 && mode_lib->vba.SourceScan[k] == dm_horz)) {
2819 MinimumSwathHeightY = MaximumSwathHeightY;
2820 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8
2821 && mode_lib->vba.SourceScan[k] != dm_horz) {
2822 MinimumSwathHeightY = MaximumSwathHeightY;
2824 MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2826 MinimumSwathHeightC = MaximumSwathHeightC;
2828 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2829 MinimumSwathHeightY = MaximumSwathHeightY;
2830 MinimumSwathHeightC = MaximumSwathHeightC;
2831 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2832 && mode_lib->vba.SourceScan[k] == dm_horz) {
2833 MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2834 MinimumSwathHeightC = MaximumSwathHeightC;
2835 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2836 && mode_lib->vba.SourceScan[k] == dm_horz) {
2837 MinimumSwathHeightC = MaximumSwathHeightC / 2.0;
2838 MinimumSwathHeightY = MaximumSwathHeightY;
2840 MinimumSwathHeightY = MaximumSwathHeightY;
2841 MinimumSwathHeightC = MaximumSwathHeightC;
2845 if (mode_lib->vba.SourceScan[k] == dm_horz) {
2846 SwathWidth = mode_lib->vba.ViewportWidth[k];
2848 SwathWidth = mode_lib->vba.ViewportHeight[k];
2851 if (mode_lib->vba.ODMCombineEnabled[k] == true) {
2852 MainPlaneDoesODMCombine = true;
2854 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
2855 if (mode_lib->vba.BlendingAndTiming[k] == j
2856 && mode_lib->vba.ODMCombineEnabled[j] == true) {
2857 MainPlaneDoesODMCombine = true;
2861 if (MainPlaneDoesODMCombine == true) {
2862 SwathWidth = dml_min(
2864 mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]);
2866 if (mode_lib->vba.DPPPerPlane[k] == 0)
2869 SwathWidth = SwathWidth / mode_lib->vba.DPPPerPlane[k];
2872 SwathWidthGranularityY = 256 / dml_ceil(BytePerPixDETY, 1) / MaximumSwathHeightY;
2873 RoundedUpMaxSwathSizeBytesY = (dml_ceil(
2874 (double) (SwathWidth - 1),
2875 SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY
2876 * MaximumSwathHeightY;
2877 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2878 RoundedUpMaxSwathSizeBytesY = dml_ceil(RoundedUpMaxSwathSizeBytesY, 256)
2881 if (MaximumSwathHeightC > 0) {
2882 SwathWidthGranularityC = 256.0 / dml_ceil(BytePerPixDETC, 2)
2883 / MaximumSwathHeightC;
2884 RoundedUpMaxSwathSizeBytesC = (dml_ceil(
2885 (double) (SwathWidth / 2.0 - 1),
2886 SwathWidthGranularityC) + SwathWidthGranularityC)
2887 * BytePerPixDETC * MaximumSwathHeightC;
2888 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2889 RoundedUpMaxSwathSizeBytesC = dml_ceil(
2890 RoundedUpMaxSwathSizeBytesC,
2894 RoundedUpMaxSwathSizeBytesC = 0.0;
2896 if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
2897 <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) {
2898 mode_lib->vba.SwathHeightY[k] = MaximumSwathHeightY;
2899 mode_lib->vba.SwathHeightC[k] = MaximumSwathHeightC;
2901 mode_lib->vba.SwathHeightY[k] = MinimumSwathHeightY;
2902 mode_lib->vba.SwathHeightC[k] = MinimumSwathHeightC;
2905 if (mode_lib->vba.SwathHeightC[k] == 0) {
2906 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024;
2907 mode_lib->vba.DETBufferSizeC[k] = 0;
2908 } else if (mode_lib->vba.SwathHeightY[k] <= mode_lib->vba.SwathHeightC[k]) {
2909 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte
2911 mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte
2914 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte
2916 mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte
2922 static double CalculateTWait(
2923 unsigned int PrefetchMode,
2924 double DRAMClockChangeLatency,
2925 double UrgentLatencyPixelDataOnly,
2926 double SREnterPlusExitTime)
2928 if (PrefetchMode == 0) {
2930 DRAMClockChangeLatency + UrgentLatencyPixelDataOnly,
2931 dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly));
2932 } else if (PrefetchMode == 1) {
2933 return dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly);
2935 return UrgentLatencyPixelDataOnly;
2939 static double CalculateRemoteSurfaceFlipDelay(
2940 struct display_mode_lib *mode_lib,
2945 double XFCTSlvVupdateOffset,
2946 double XFCTSlvVupdateWidth,
2947 double XFCTSlvVreadyOffset,
2948 double XFCXBUFLatencyTolerance,
2949 double XFCFillBWOverhead,
2950 double XFCSlvChunkSize,
2951 double XFCBusTransportTime,
2954 double *SrcActiveDrainRate,
2958 double TSlvSetup, AvgfillRate, result;
2960 *SrcActiveDrainRate = VRatio * SwathWidth * Bpp / LineTime;
2961 TSlvSetup = XFCTSlvVupdateOffset + XFCTSlvVupdateWidth + XFCTSlvVreadyOffset;
2962 *TInitXFill = XFCXBUFLatencyTolerance / (1 + XFCFillBWOverhead / 100);
2963 AvgfillRate = *SrcActiveDrainRate * (1 + XFCFillBWOverhead / 100);
2964 *TslvChk = XFCSlvChunkSize / AvgfillRate;
2966 "DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n",
2967 *SrcActiveDrainRate);
2968 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TSlvSetup: %f\n", TSlvSetup);
2969 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TInitXFill: %f\n", *TInitXFill);
2970 dml_print("DML::CalculateRemoteSurfaceFlipDelay: AvgfillRate: %f\n", AvgfillRate);
2971 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TslvChk: %f\n", *TslvChk);
2972 result = 2 * XFCBusTransportTime + TSlvSetup + TCalc + TWait + *TslvChk + *TInitXFill; // TODO: This doesn't seem to match programming guide
2973 dml_print("DML::CalculateRemoteSurfaceFlipDelay: RemoteSurfaceFlipDelay: %f\n", result);
2977 static double CalculateWriteBackDelay(
2978 enum source_format_class WritebackPixelFormat,
2979 double WritebackHRatio,
2980 double WritebackVRatio,
2981 unsigned int WritebackLumaHTaps,
2982 unsigned int WritebackLumaVTaps,
2983 unsigned int WritebackChromaHTaps,
2984 unsigned int WritebackChromaVTaps,
2985 unsigned int WritebackDestinationWidth)
2987 double CalculateWriteBackDelay =
2989 dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio,
2990 WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1)
2992 WritebackDestinationWidth
2995 + dml_ceil(1.0 / WritebackVRatio, 1)
3001 if (WritebackPixelFormat != dm_444_32) {
3002 CalculateWriteBackDelay =
3004 CalculateWriteBackDelay,
3007 WritebackChromaHTaps
3012 WritebackChromaVTaps
3019 WritebackDestinationWidth
3029 WritebackChromaVTaps
3034 return CalculateWriteBackDelay;
3037 static void CalculateActiveRowBandwidth(
3039 enum source_format_class SourcePixelFormat,
3043 unsigned int MetaRowByteLuma,
3044 unsigned int MetaRowByteChroma,
3045 unsigned int meta_row_height_luma,
3046 unsigned int meta_row_height_chroma,
3047 unsigned int PixelPTEBytesPerRowLuma,
3048 unsigned int PixelPTEBytesPerRowChroma,
3049 unsigned int dpte_row_height_luma,
3050 unsigned int dpte_row_height_chroma,
3051 double *meta_row_bw,
3052 double *dpte_row_bw,
3053 double *qual_row_bw)
3055 if (DCCEnable != true) {
3057 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3058 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
3059 + VRatio / 2 * MetaRowByteChroma
3060 / (meta_row_height_chroma * LineTime);
3062 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
3065 if (GPUVMEnable != true) {
3067 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3068 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
3069 + VRatio / 2 * PixelPTEBytesPerRowChroma
3070 / (dpte_row_height_chroma * LineTime);
3072 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
3075 if ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)) {
3076 *qual_row_bw = *meta_row_bw + *dpte_row_bw;
3082 static void CalculateFlipSchedule(
3083 struct display_mode_lib *mode_lib,
3084 double UrgentExtraLatency,
3085 double UrgentLatencyPixelDataOnly,
3086 unsigned int GPUVMMaxPageTableLevels,
3088 double BandwidthAvailableForImmediateFlip,
3089 unsigned int TotImmediateFlipBytes,
3090 enum source_format_class SourcePixelFormat,
3091 unsigned int ImmediateFlipBytes,
3095 double PDEAndMetaPTEBytesFrame,
3096 unsigned int MetaRowByte,
3097 unsigned int PixelPTEBytesPerRow,
3099 unsigned int dpte_row_height,
3100 unsigned int meta_row_height,
3102 double *DestinationLinesToRequestVMInImmediateFlip,
3103 double *DestinationLinesToRequestRowInImmediateFlip,
3104 double *final_flip_bw,
3105 bool *ImmediateFlipSupportedForPipe)
3107 double min_row_time = 0.0;
3109 if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3110 *DestinationLinesToRequestVMInImmediateFlip = 0.0;
3111 *DestinationLinesToRequestRowInImmediateFlip = 0.0;
3112 *final_flip_bw = qual_row_bw;
3113 *ImmediateFlipSupportedForPipe = true;
3115 double TimeForFetchingMetaPTEImmediateFlip;
3116 double TimeForFetchingRowInVBlankImmediateFlip;
3118 if (GPUVMEnable == true) {
3119 mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3120 * ImmediateFlipBytes / TotImmediateFlipBytes;
3121 TimeForFetchingMetaPTEImmediateFlip =
3124 + PDEAndMetaPTEBytesFrame
3125 / mode_lib->vba.ImmediateFlipBW[0],
3128 + UrgentLatencyPixelDataOnly
3129 * (GPUVMMaxPageTableLevels
3133 TimeForFetchingMetaPTEImmediateFlip = 0;
3136 *DestinationLinesToRequestVMInImmediateFlip = dml_floor(
3137 4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125),
3140 if ((GPUVMEnable == true || DCCEnable == true)) {
3141 mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3142 * ImmediateFlipBytes / TotImmediateFlipBytes;
3143 TimeForFetchingRowInVBlankImmediateFlip = dml_max(
3144 (MetaRowByte + PixelPTEBytesPerRow)
3145 / mode_lib->vba.ImmediateFlipBW[0],
3146 dml_max(UrgentLatencyPixelDataOnly, LineTime / 4.0));
3148 TimeForFetchingRowInVBlankImmediateFlip = 0;
3151 *DestinationLinesToRequestRowInImmediateFlip = dml_floor(
3152 4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125),
3155 if (GPUVMEnable == true) {
3158 PDEAndMetaPTEBytesFrame
3159 / (*DestinationLinesToRequestVMInImmediateFlip
3161 (MetaRowByte + PixelPTEBytesPerRow)
3162 / (TimeForFetchingRowInVBlankImmediateFlip
3164 } else if (MetaRowByte + PixelPTEBytesPerRow > 0) {
3165 *final_flip_bw = (MetaRowByte + PixelPTEBytesPerRow)
3166 / (TimeForFetchingRowInVBlankImmediateFlip * LineTime);
3171 if (GPUVMEnable && !DCCEnable)
3172 min_row_time = dpte_row_height * LineTime / VRatio;
3173 else if (!GPUVMEnable && DCCEnable)
3174 min_row_time = meta_row_height * LineTime / VRatio;
3176 min_row_time = dml_min(dpte_row_height, meta_row_height) * LineTime
3179 if (*DestinationLinesToRequestVMInImmediateFlip >= 8
3180 || *DestinationLinesToRequestRowInImmediateFlip >= 16
3181 || TimeForFetchingMetaPTEImmediateFlip
3182 + 2 * TimeForFetchingRowInVBlankImmediateFlip
3184 *ImmediateFlipSupportedForPipe = false;
3186 *ImmediateFlipSupportedForPipe = true;
3190 static unsigned int TruncToValidBPP(
3193 enum output_encoder_class Output,
3194 enum output_format_class Format,
3195 unsigned int DSCInputBitPerComponent)
3197 if (Output == dm_hdmi) {
3198 if (Format == dm_420) {
3199 if (DecimalBPP >= 18)
3201 else if (DecimalBPP >= 15)
3203 else if (DecimalBPP >= 12)
3207 } else if (Format == dm_444) {
3208 if (DecimalBPP >= 36)
3210 else if (DecimalBPP >= 30)
3212 else if (DecimalBPP >= 24)
3214 else if (DecimalBPP >= 18)
3219 if (DecimalBPP / 1.5 >= 24)
3221 else if (DecimalBPP / 1.5 >= 20)
3223 else if (DecimalBPP / 1.5 >= 16)
3230 if (Format == dm_420) {
3233 else if (DecimalBPP >= 1.5 * DSCInputBitPerComponent - 1 / 16)
3234 return 1.5 * DSCInputBitPerComponent - 1 / 16;
3236 return dml_floor(16 * DecimalBPP, 1) / 16;
3237 } else if (Format == dm_n422) {
3240 else if (DecimalBPP >= 2 * DSCInputBitPerComponent - 1 / 16)
3241 return 2 * DSCInputBitPerComponent - 1 / 16;
3243 return dml_floor(16 * DecimalBPP, 1) / 16;
3247 else if (DecimalBPP >= 3 * DSCInputBitPerComponent - 1 / 16)
3248 return 3 * DSCInputBitPerComponent - 1 / 16;
3250 return dml_floor(16 * DecimalBPP, 1) / 16;
3252 } else if (Format == dm_420) {
3253 if (DecimalBPP >= 18)
3255 else if (DecimalBPP >= 15)
3257 else if (DecimalBPP >= 12)
3261 } else if (Format == dm_s422 || Format == dm_n422) {
3262 if (DecimalBPP >= 24)
3264 else if (DecimalBPP >= 20)
3266 else if (DecimalBPP >= 16)
3271 if (DecimalBPP >= 36)
3273 else if (DecimalBPP >= 30)
3275 else if (DecimalBPP >= 24)
3277 else if (DecimalBPP >= 18)
3285 void dml20_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
3287 struct vba_vars_st *locals = &mode_lib->vba;
3290 unsigned int j, k, m;
3292 /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
3294 /*Scale Ratio, taps Support Check*/
3296 mode_lib->vba.ScaleRatioAndTapsSupport = true;
3297 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3298 if (mode_lib->vba.ScalerEnabled[k] == false
3299 && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3300 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3301 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3302 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3303 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)
3304 || mode_lib->vba.HRatio[k] != 1.0
3305 || mode_lib->vba.htaps[k] != 1.0
3306 || mode_lib->vba.VRatio[k] != 1.0
3307 || mode_lib->vba.vtaps[k] != 1.0)) {
3308 mode_lib->vba.ScaleRatioAndTapsSupport = false;
3309 } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0
3310 || mode_lib->vba.htaps[k] < 1.0 || mode_lib->vba.htaps[k] > 8.0
3311 || (mode_lib->vba.htaps[k] > 1.0
3312 && (mode_lib->vba.htaps[k] % 2) == 1)
3313 || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
3314 || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
3315 || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
3316 || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
3317 || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3318 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3319 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3320 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3321 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
3322 && (mode_lib->vba.HRatio[k] / 2.0
3323 > mode_lib->vba.HTAPsChroma[k]
3324 || mode_lib->vba.VRatio[k] / 2.0
3325 > mode_lib->vba.VTAPsChroma[k]))) {
3326 mode_lib->vba.ScaleRatioAndTapsSupport = false;
3329 /*Source Format, Pixel Format and Scan Support Check*/
3331 mode_lib->vba.SourceFormatPixelAndScanSupport = true;
3332 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3333 if ((mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3334 && mode_lib->vba.SourceScan[k] != dm_horz)
3335 || ((mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d
3336 || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x
3337 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d
3338 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t
3339 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x
3340 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d
3341 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d_x)
3342 && mode_lib->vba.SourcePixelFormat[k] != dm_444_64)
3343 || (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x
3344 && (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8
3345 || mode_lib->vba.SourcePixelFormat[k]
3347 || mode_lib->vba.SourcePixelFormat[k]
3349 || (((mode_lib->vba.SurfaceTiling[k] == dm_sw_gfx7_2d_thin_gl
3350 || mode_lib->vba.SurfaceTiling[k]
3351 == dm_sw_gfx7_2d_thin_lvp)
3352 && !((mode_lib->vba.SourcePixelFormat[k]
3354 || mode_lib->vba.SourcePixelFormat[k]
3356 && mode_lib->vba.SourceScan[k]
3358 && mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp
3360 && mode_lib->vba.DCCEnable[k]
3362 || (mode_lib->vba.DCCEnable[k] == true
3363 && (mode_lib->vba.SurfaceTiling[k]
3365 || mode_lib->vba.SourcePixelFormat[k]
3367 || mode_lib->vba.SourcePixelFormat[k]
3369 mode_lib->vba.SourceFormatPixelAndScanSupport = false;
3372 /*Bandwidth Support Check*/
3374 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3375 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
3376 locals->BytePerPixelInDETY[k] = 8.0;
3377 locals->BytePerPixelInDETC[k] = 0.0;
3378 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
3379 locals->BytePerPixelInDETY[k] = 4.0;
3380 locals->BytePerPixelInDETC[k] = 0.0;
3381 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3382 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16) {
3383 locals->BytePerPixelInDETY[k] = 2.0;
3384 locals->BytePerPixelInDETC[k] = 0.0;
3385 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8) {
3386 locals->BytePerPixelInDETY[k] = 1.0;
3387 locals->BytePerPixelInDETC[k] = 0.0;
3388 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
3389 locals->BytePerPixelInDETY[k] = 1.0;
3390 locals->BytePerPixelInDETC[k] = 2.0;
3392 locals->BytePerPixelInDETY[k] = 4.0 / 3;
3393 locals->BytePerPixelInDETC[k] = 8.0 / 3;
3395 if (mode_lib->vba.SourceScan[k] == dm_horz) {
3396 locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
3398 locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
3401 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3402 locals->ReadBandwidthLuma[k] = locals->SwathWidthYSingleDPP[k] * dml_ceil(locals->BytePerPixelInDETY[k], 1.0)
3403 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
3404 locals->ReadBandwidthChroma[k] = locals->SwathWidthYSingleDPP[k] / 2 * dml_ceil(locals->BytePerPixelInDETC[k], 2.0)
3405 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k] / 2.0;
3406 locals->ReadBandwidth[k] = locals->ReadBandwidthLuma[k] + locals->ReadBandwidthChroma[k];
3408 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3409 if (mode_lib->vba.WritebackEnable[k] == true
3410 && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3411 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3412 * mode_lib->vba.WritebackDestinationHeight[k]
3413 / (mode_lib->vba.WritebackSourceHeight[k]
3414 * mode_lib->vba.HTotal[k]
3415 / mode_lib->vba.PixelClock[k]) * 4.0;
3416 } else if (mode_lib->vba.WritebackEnable[k] == true
3417 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3418 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3419 * mode_lib->vba.WritebackDestinationHeight[k]
3420 / (mode_lib->vba.WritebackSourceHeight[k]
3421 * mode_lib->vba.HTotal[k]
3422 / mode_lib->vba.PixelClock[k]) * 3.0;
3423 } else if (mode_lib->vba.WritebackEnable[k] == true) {
3424 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3425 * mode_lib->vba.WritebackDestinationHeight[k]
3426 / (mode_lib->vba.WritebackSourceHeight[k]
3427 * mode_lib->vba.HTotal[k]
3428 / mode_lib->vba.PixelClock[k]) * 1.5;
3430 locals->WriteBandwidth[k] = 0.0;
3433 mode_lib->vba.DCCEnabledInAnyPlane = false;
3434 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3435 if (mode_lib->vba.DCCEnable[k] == true) {
3436 mode_lib->vba.DCCEnabledInAnyPlane = true;
3439 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3440 locals->FabricAndDRAMBandwidthPerState[i] = dml_min(
3441 mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels
3442 * mode_lib->vba.DRAMChannelWidth,
3443 mode_lib->vba.FabricClockPerState[i]
3444 * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000;
3445 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth * locals->DCFCLKPerState[i],
3446 locals->FabricAndDRAMBandwidthPerState[i] * 1000)
3447 * locals->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
3449 locals->ReturnBWPerState[i] = locals->ReturnBWToDCNPerState;
3451 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3452 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i],
3453 locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3454 ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3455 / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3456 * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3458 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3459 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3460 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3462 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3463 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i],
3464 4 * locals->ReturnBWToDCNPerState *
3465 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3466 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3467 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3468 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3471 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth *
3472 locals->DCFCLKPerState[i], locals->FabricAndDRAMBandwidthPerState[i] * 1000);
3474 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3475 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i],
3476 locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3477 ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3478 / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3479 * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3481 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3482 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3483 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3485 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3486 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i],
3487 4 * locals->ReturnBWToDCNPerState *
3488 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3489 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3490 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3491 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3494 /*Writeback Latency support check*/
3496 mode_lib->vba.WritebackLatencySupport = true;
3497 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3498 if (mode_lib->vba.WritebackEnable[k] == true) {
3499 if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3500 if (locals->WriteBandwidth[k]
3501 > (mode_lib->vba.WritebackInterfaceLumaBufferSize
3502 + mode_lib->vba.WritebackInterfaceChromaBufferSize)
3503 / mode_lib->vba.WritebackLatency) {
3504 mode_lib->vba.WritebackLatencySupport = false;
3507 if (locals->WriteBandwidth[k]
3510 mode_lib->vba.WritebackInterfaceLumaBufferSize,
3512 * mode_lib->vba.WritebackInterfaceChromaBufferSize)
3513 / mode_lib->vba.WritebackLatency) {
3514 mode_lib->vba.WritebackLatencySupport = false;
3519 /*Re-ordering Buffer Support Check*/
3521 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3522 locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i] =
3523 (mode_lib->vba.RoundTripPingLatencyCycles + 32.0) / mode_lib->vba.DCFCLKPerState[i]
3524 + locals->UrgentOutOfOrderReturnPerChannel * mode_lib->vba.NumberOfChannels / locals->ReturnBWPerState[i];
3525 if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024.0 / locals->ReturnBWPerState[i]
3526 > locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i]) {
3527 locals->ROBSupport[i] = true;
3529 locals->ROBSupport[i] = false;
3532 /*Writeback Mode Support Check*/
3534 mode_lib->vba.TotalNumberOfActiveWriteback = 0;
3535 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3536 if (mode_lib->vba.WritebackEnable[k] == true) {
3537 if (mode_lib->vba.ActiveWritebacksPerPlane[k] == 0)
3538 mode_lib->vba.ActiveWritebacksPerPlane[k] = 1;
3539 mode_lib->vba.TotalNumberOfActiveWriteback =
3540 mode_lib->vba.TotalNumberOfActiveWriteback
3541 + mode_lib->vba.ActiveWritebacksPerPlane[k];
3544 mode_lib->vba.WritebackModeSupport = true;
3545 if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback) {
3546 mode_lib->vba.WritebackModeSupport = false;
3548 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3549 if (mode_lib->vba.WritebackEnable[k] == true
3550 && mode_lib->vba.Writeback10bpc420Supported != true
3551 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3552 mode_lib->vba.WritebackModeSupport = false;
3555 /*Writeback Scale Ratio and Taps Support Check*/
3557 mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
3558 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3559 if (mode_lib->vba.WritebackEnable[k] == true) {
3560 if (mode_lib->vba.WritebackLumaAndChromaScalingSupported == false
3561 && (mode_lib->vba.WritebackHRatio[k] != 1.0
3562 || mode_lib->vba.WritebackVRatio[k] != 1.0)) {
3563 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3565 if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
3566 || mode_lib->vba.WritebackVRatio[k]
3567 > mode_lib->vba.WritebackMaxVSCLRatio
3568 || mode_lib->vba.WritebackHRatio[k]
3569 < mode_lib->vba.WritebackMinHSCLRatio
3570 || mode_lib->vba.WritebackVRatio[k]
3571 < mode_lib->vba.WritebackMinVSCLRatio
3572 || mode_lib->vba.WritebackLumaHTaps[k]
3573 > mode_lib->vba.WritebackMaxHSCLTaps
3574 || mode_lib->vba.WritebackLumaVTaps[k]
3575 > mode_lib->vba.WritebackMaxVSCLTaps
3576 || mode_lib->vba.WritebackHRatio[k]
3577 > mode_lib->vba.WritebackLumaHTaps[k]
3578 || mode_lib->vba.WritebackVRatio[k]
3579 > mode_lib->vba.WritebackLumaVTaps[k]
3580 || (mode_lib->vba.WritebackLumaHTaps[k] > 2.0
3581 && ((mode_lib->vba.WritebackLumaHTaps[k] % 2)
3583 || (mode_lib->vba.WritebackPixelFormat[k] != dm_444_32
3584 && (mode_lib->vba.WritebackChromaHTaps[k]
3585 > mode_lib->vba.WritebackMaxHSCLTaps
3586 || mode_lib->vba.WritebackChromaVTaps[k]
3587 > mode_lib->vba.WritebackMaxVSCLTaps
3589 * mode_lib->vba.WritebackHRatio[k]
3590 > mode_lib->vba.WritebackChromaHTaps[k]
3592 * mode_lib->vba.WritebackVRatio[k]
3593 > mode_lib->vba.WritebackChromaVTaps[k]
3594 || (mode_lib->vba.WritebackChromaHTaps[k] > 2.0
3595 && ((mode_lib->vba.WritebackChromaHTaps[k] % 2) == 1))))) {
3596 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3598 if (mode_lib->vba.WritebackVRatio[k] < 1.0) {
3599 mode_lib->vba.WritebackLumaVExtra =
3600 dml_max(1.0 - 2.0 / dml_ceil(1.0 / mode_lib->vba.WritebackVRatio[k], 1.0), 0.0);
3602 mode_lib->vba.WritebackLumaVExtra = -1;
3604 if ((mode_lib->vba.WritebackPixelFormat[k] == dm_444_32
3605 && mode_lib->vba.WritebackLumaVTaps[k]
3606 > (mode_lib->vba.WritebackLineBufferLumaBufferSize
3607 + mode_lib->vba.WritebackLineBufferChromaBufferSize)
3609 / mode_lib->vba.WritebackDestinationWidth[k]
3610 - mode_lib->vba.WritebackLumaVExtra)
3611 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3612 && mode_lib->vba.WritebackLumaVTaps[k]
3613 > mode_lib->vba.WritebackLineBufferLumaBufferSize
3614 * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3615 - mode_lib->vba.WritebackLumaVExtra)
3616 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3617 && mode_lib->vba.WritebackLumaVTaps[k]
3618 > mode_lib->vba.WritebackLineBufferLumaBufferSize
3620 / mode_lib->vba.WritebackDestinationWidth[k]
3621 - mode_lib->vba.WritebackLumaVExtra)) {
3622 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3624 if (2.0 * mode_lib->vba.WritebackVRatio[k] < 1) {
3625 mode_lib->vba.WritebackChromaVExtra = 0.0;
3627 mode_lib->vba.WritebackChromaVExtra = -1;
3629 if ((mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3630 && mode_lib->vba.WritebackChromaVTaps[k]
3631 > mode_lib->vba.WritebackLineBufferChromaBufferSize
3632 * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3633 - mode_lib->vba.WritebackChromaVExtra)
3634 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3635 && mode_lib->vba.WritebackChromaVTaps[k]
3636 > mode_lib->vba.WritebackLineBufferChromaBufferSize
3638 / mode_lib->vba.WritebackDestinationWidth[k]
3639 - mode_lib->vba.WritebackChromaVExtra)) {
3640 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3644 /*Maximum DISPCLK/DPPCLK Support check*/
3646 mode_lib->vba.WritebackRequiredDISPCLK = 0.0;
3647 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3648 if (mode_lib->vba.WritebackEnable[k] == true) {
3649 mode_lib->vba.WritebackRequiredDISPCLK =
3651 mode_lib->vba.WritebackRequiredDISPCLK,
3652 CalculateWriteBackDISPCLK(
3653 mode_lib->vba.WritebackPixelFormat[k],
3654 mode_lib->vba.PixelClock[k],
3655 mode_lib->vba.WritebackHRatio[k],
3656 mode_lib->vba.WritebackVRatio[k],
3657 mode_lib->vba.WritebackLumaHTaps[k],
3658 mode_lib->vba.WritebackLumaVTaps[k],
3659 mode_lib->vba.WritebackChromaHTaps[k],
3660 mode_lib->vba.WritebackChromaVTaps[k],
3661 mode_lib->vba.WritebackDestinationWidth[k],
3662 mode_lib->vba.HTotal[k],
3663 mode_lib->vba.WritebackChromaLineBufferWidth));
3666 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3667 if (mode_lib->vba.HRatio[k] > 1.0) {
3668 locals->PSCL_FACTOR[k] = dml_min(
3669 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3670 mode_lib->vba.MaxPSCLToLBThroughput
3671 * mode_lib->vba.HRatio[k]
3673 mode_lib->vba.htaps[k]
3677 locals->PSCL_FACTOR[k] = dml_min(
3678 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3679 mode_lib->vba.MaxPSCLToLBThroughput);
3681 if (locals->BytePerPixelInDETC[k] == 0.0) {
3682 locals->PSCL_FACTOR_CHROMA[k] = 0.0;
3683 locals->MinDPPCLKUsingSingleDPP[k] =
3684 mode_lib->vba.PixelClock[k]
3686 mode_lib->vba.vtaps[k] / 6.0
3689 mode_lib->vba.HRatio[k]),
3690 mode_lib->vba.HRatio[k]
3691 * mode_lib->vba.VRatio[k]
3692 / locals->PSCL_FACTOR[k],
3694 if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0)
3695 && locals->MinDPPCLKUsingSingleDPP[k]
3696 < 2.0 * mode_lib->vba.PixelClock[k]) {
3697 locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3698 * mode_lib->vba.PixelClock[k];
3701 if (mode_lib->vba.HRatio[k] / 2.0 > 1.0) {
3702 locals->PSCL_FACTOR_CHROMA[k] =
3704 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3705 mode_lib->vba.MaxPSCLToLBThroughput
3706 * mode_lib->vba.HRatio[k]
3709 mode_lib->vba.HTAPsChroma[k]
3713 locals->PSCL_FACTOR_CHROMA[k] = dml_min(
3714 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3715 mode_lib->vba.MaxPSCLToLBThroughput);
3717 locals->MinDPPCLKUsingSingleDPP[k] =
3718 mode_lib->vba.PixelClock[k]
3720 mode_lib->vba.vtaps[k] / 6.0
3723 mode_lib->vba.HRatio[k]),
3724 mode_lib->vba.HRatio[k]
3725 * mode_lib->vba.VRatio[k]
3726 / locals->PSCL_FACTOR[k],
3727 mode_lib->vba.VTAPsChroma[k]
3731 mode_lib->vba.HRatio[k]
3733 mode_lib->vba.HRatio[k]
3734 * mode_lib->vba.VRatio[k]
3736 / locals->PSCL_FACTOR_CHROMA[k],
3738 if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0
3739 || mode_lib->vba.HTAPsChroma[k] > 6.0
3740 || mode_lib->vba.VTAPsChroma[k] > 6.0)
3741 && locals->MinDPPCLKUsingSingleDPP[k]
3742 < 2.0 * mode_lib->vba.PixelClock[k]) {
3743 locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3744 * mode_lib->vba.PixelClock[k];
3748 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3749 Calculate256BBlockSizes(
3750 mode_lib->vba.SourcePixelFormat[k],
3751 mode_lib->vba.SurfaceTiling[k],
3752 dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
3753 dml_ceil(locals->BytePerPixelInDETC[k], 2.0),
3754 &locals->Read256BlockHeightY[k],
3755 &locals->Read256BlockHeightC[k],
3756 &locals->Read256BlockWidthY[k],
3757 &locals->Read256BlockWidthC[k]);
3758 if (mode_lib->vba.SourceScan[k] == dm_horz) {
3759 locals->MaxSwathHeightY[k] = locals->Read256BlockHeightY[k];
3760 locals->MaxSwathHeightC[k] = locals->Read256BlockHeightC[k];
3762 locals->MaxSwathHeightY[k] = locals->Read256BlockWidthY[k];
3763 locals->MaxSwathHeightC[k] = locals->Read256BlockWidthC[k];
3765 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3766 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
3767 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3768 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16
3769 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_8)) {
3770 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3771 || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3772 && (mode_lib->vba.SurfaceTiling[k]
3774 || mode_lib->vba.SurfaceTiling[k]
3776 || mode_lib->vba.SurfaceTiling[k]
3778 || mode_lib->vba.SurfaceTiling[k]
3780 || mode_lib->vba.SurfaceTiling[k]
3782 || mode_lib->vba.SurfaceTiling[k]
3784 || mode_lib->vba.SurfaceTiling[k]
3786 && mode_lib->vba.SourceScan[k] == dm_horz)) {
3787 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3789 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3792 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3794 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3795 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3796 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3797 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
3798 && mode_lib->vba.SourceScan[k] == dm_horz) {
3799 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3801 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3802 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
3803 && mode_lib->vba.SourceScan[k] == dm_horz) {
3804 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]
3806 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3808 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3809 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3812 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3813 mode_lib->vba.MaximumSwathWidthSupport = 8192.0;
3815 mode_lib->vba.MaximumSwathWidthSupport = 5120.0;
3817 mode_lib->vba.MaximumSwathWidthInDETBuffer =
3819 mode_lib->vba.MaximumSwathWidthSupport,
3820 mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0
3821 / (locals->BytePerPixelInDETY[k]
3822 * locals->MinSwathHeightY[k]
3823 + locals->BytePerPixelInDETC[k]
3825 * locals->MinSwathHeightC[k]));
3826 if (locals->BytePerPixelInDETC[k] == 0.0) {
3827 mode_lib->vba.MaximumSwathWidthInLineBuffer =
3828 mode_lib->vba.LineBufferSize
3829 * dml_max(mode_lib->vba.HRatio[k], 1.0)
3830 / mode_lib->vba.LBBitPerPixel[k]
3831 / (mode_lib->vba.vtaps[k]
3834 mode_lib->vba.VRatio[k],
3839 mode_lib->vba.MaximumSwathWidthInLineBuffer =
3841 mode_lib->vba.LineBufferSize
3843 mode_lib->vba.HRatio[k],
3845 / mode_lib->vba.LBBitPerPixel[k]
3846 / (mode_lib->vba.vtaps[k]
3849 mode_lib->vba.VRatio[k],
3853 2.0 * mode_lib->vba.LineBufferSize
3855 mode_lib->vba.HRatio[k]
3858 / mode_lib->vba.LBBitPerPixel[k]
3859 / (mode_lib->vba.VTAPsChroma[k]
3862 mode_lib->vba.VRatio[k]
3868 locals->MaximumSwathWidth[k] = dml_min(
3869 mode_lib->vba.MaximumSwathWidthInDETBuffer,
3870 mode_lib->vba.MaximumSwathWidthInLineBuffer);
3872 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3873 for (j = 0; j < 2; j++) {
3874 mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3875 mode_lib->vba.MaxDispclk[i],
3876 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3877 mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3878 mode_lib->vba.MaxDppclk[i],
3879 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3880 locals->RequiredDISPCLK[i][j] = 0.0;
3881 locals->DISPCLK_DPPCLK_Support[i][j] = true;
3882 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3883 mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine =
3884 mode_lib->vba.PixelClock[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3885 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3886 if (mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine >= mode_lib->vba.MaxDispclk[i]
3887 && i == mode_lib->vba.soc.num_states)
3888 mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = mode_lib->vba.PixelClock[k]
3889 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3891 mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
3892 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3893 if (mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine >= mode_lib->vba.MaxDispclk[i]
3894 && i == mode_lib->vba.soc.num_states)
3895 mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
3896 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3897 if (mode_lib->vba.ODMCapability == false || mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine <= mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) {
3898 locals->ODMCombineEnablePerState[i][k] = false;
3899 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine;
3901 locals->ODMCombineEnablePerState[i][k] = true;
3902 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine;
3904 if (locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
3905 && locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]
3906 && locals->ODMCombineEnablePerState[i][k] == false) {
3907 locals->NoOfDPP[i][j][k] = 1;
3908 locals->RequiredDPPCLK[i][j][k] =
3909 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3911 locals->NoOfDPP[i][j][k] = 2;
3912 locals->RequiredDPPCLK[i][j][k] =
3913 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3915 locals->RequiredDISPCLK[i][j] = dml_max(
3916 locals->RequiredDISPCLK[i][j],
3917 mode_lib->vba.PlaneRequiredDISPCLK);
3918 if ((locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3919 > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity)
3920 || (mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) {
3921 locals->DISPCLK_DPPCLK_Support[i][j] = false;
3924 locals->TotalNumberOfActiveDPP[i][j] = 0.0;
3925 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
3926 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
3928 while (locals->TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP
3929 && locals->TotalNumberOfActiveDPP[i][j] < 2 * mode_lib->vba.NumberOfActivePlanes) {
3930 double BWOfNonSplitPlaneOfMaximumBandwidth;
3931 unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth;
3933 BWOfNonSplitPlaneOfMaximumBandwidth = 0;
3934 NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
3935 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
3936 if (locals->ReadBandwidth[k] > BWOfNonSplitPlaneOfMaximumBandwidth && locals->NoOfDPP[i][j][k] == 1) {
3937 BWOfNonSplitPlaneOfMaximumBandwidth = locals->ReadBandwidth[k];
3938 NumberOfNonSplitPlaneOfMaximumBandwidth = k;
3941 locals->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
3942 locals->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] =
3943 locals->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
3944 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
3945 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + 1;
3948 if (locals->TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP) {
3949 locals->RequiredDISPCLK[i][j] = 0.0;
3950 locals->DISPCLK_DPPCLK_Support[i][j] = true;
3951 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3952 locals->ODMCombineEnablePerState[i][k] = false;
3953 if (locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]) {
3954 locals->NoOfDPP[i][j][k] = 1;
3955 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
3956 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3958 locals->NoOfDPP[i][j][k] = 2;
3959 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
3960 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3962 if (i != mode_lib->vba.soc.num_states) {
3963 mode_lib->vba.PlaneRequiredDISPCLK =
3964 mode_lib->vba.PixelClock[k]
3965 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3966 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3968 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PixelClock[k]
3969 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3971 locals->RequiredDISPCLK[i][j] = dml_max(
3972 locals->RequiredDISPCLK[i][j],
3973 mode_lib->vba.PlaneRequiredDISPCLK);
3974 if (locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3975 > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
3976 || mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)
3977 locals->DISPCLK_DPPCLK_Support[i][j] = false;
3979 locals->TotalNumberOfActiveDPP[i][j] = 0.0;
3980 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
3981 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
3983 locals->RequiredDISPCLK[i][j] = dml_max(
3984 locals->RequiredDISPCLK[i][j],
3985 mode_lib->vba.WritebackRequiredDISPCLK);
3986 if (mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity
3987 < mode_lib->vba.WritebackRequiredDISPCLK) {
3988 locals->DISPCLK_DPPCLK_Support[i][j] = false;
3992 /*Viewport Size Check*/
3994 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3995 locals->ViewportSizeSupport[i] = true;
3996 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3997 if (locals->ODMCombineEnablePerState[i][k] == true) {
3998 if (dml_min(locals->SwathWidthYSingleDPP[k], dml_round(mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]))
3999 > locals->MaximumSwathWidth[k]) {
4000 locals->ViewportSizeSupport[i] = false;
4003 if (locals->SwathWidthYSingleDPP[k] / 2.0 > locals->MaximumSwathWidth[k]) {
4004 locals->ViewportSizeSupport[i] = false;
4009 /*Total Available Pipes Support Check*/
4011 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4012 for (j = 0; j < 2; j++) {
4013 if (locals->TotalNumberOfActiveDPP[i][j] <= mode_lib->vba.MaxNumDPP)
4014 locals->TotalAvailablePipesSupport[i][j] = true;
4016 locals->TotalAvailablePipesSupport[i][j] = false;
4019 /*Total Available OTG Support Check*/
4021 mode_lib->vba.TotalNumberOfActiveOTG = 0.0;
4022 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4023 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4024 mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG
4028 if (mode_lib->vba.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG) {
4029 mode_lib->vba.NumberOfOTGSupport = true;
4031 mode_lib->vba.NumberOfOTGSupport = false;
4033 /*Display IO and DSC Support Check*/
4035 mode_lib->vba.NonsupportedDSCInputBPC = false;
4036 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4037 if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
4038 || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
4039 || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)) {
4040 mode_lib->vba.NonsupportedDSCInputBPC = true;
4043 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4044 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4045 locals->RequiresDSC[i][k] = 0;
4046 locals->RequiresFEC[i][k] = 0;
4047 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4048 if (mode_lib->vba.Output[k] == dm_hdmi) {
4049 locals->RequiresDSC[i][k] = 0;
4050 locals->RequiresFEC[i][k] = 0;
4051 locals->OutputBppPerState[i][k] = TruncToValidBPP(
4052 dml_min(600.0, mode_lib->vba.PHYCLKPerState[i]) / mode_lib->vba.PixelClockBackEnd[k] * 24,
4054 mode_lib->vba.Output[k],
4055 mode_lib->vba.OutputFormat[k],
4056 mode_lib->vba.DSCInputBitPerComponent[k]);
4057 } else if (mode_lib->vba.Output[k] == dm_dp
4058 || mode_lib->vba.Output[k] == dm_edp) {
4059 if (mode_lib->vba.Output[k] == dm_edp) {
4060 mode_lib->vba.EffectiveFECOverhead = 0.0;
4062 mode_lib->vba.EffectiveFECOverhead =
4063 mode_lib->vba.FECOverhead;
4065 if (mode_lib->vba.PHYCLKPerState[i] >= 270.0) {
4066 mode_lib->vba.Outbpp = TruncToValidBPP(
4067 (1.0 - mode_lib->vba.Downspreading / 100.0) * 270.0
4068 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4070 mode_lib->vba.Output[k],
4071 mode_lib->vba.OutputFormat[k],
4072 mode_lib->vba.DSCInputBitPerComponent[k]);
4073 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4074 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 270.0
4075 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4077 mode_lib->vba.Output[k],
4078 mode_lib->vba.OutputFormat[k],
4079 mode_lib->vba.DSCInputBitPerComponent[k]);
4080 if (mode_lib->vba.DSCEnabled[k] == true) {
4081 locals->RequiresDSC[i][k] = true;
4082 if (mode_lib->vba.Output[k] == dm_dp) {
4083 locals->RequiresFEC[i][k] = true;
4085 locals->RequiresFEC[i][k] = false;
4087 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4089 locals->RequiresDSC[i][k] = false;
4090 locals->RequiresFEC[i][k] = false;
4092 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4094 if (mode_lib->vba.Outbpp == BPP_INVALID && mode_lib->vba.PHYCLKPerState[i] >= 540.0) {
4095 mode_lib->vba.Outbpp = TruncToValidBPP(
4096 (1.0 - mode_lib->vba.Downspreading / 100.0) * 540.0
4097 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4099 mode_lib->vba.Output[k],
4100 mode_lib->vba.OutputFormat[k],
4101 mode_lib->vba.DSCInputBitPerComponent[k]);
4102 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4103 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 540.0
4104 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4106 mode_lib->vba.Output[k],
4107 mode_lib->vba.OutputFormat[k],
4108 mode_lib->vba.DSCInputBitPerComponent[k]);
4109 if (mode_lib->vba.DSCEnabled[k] == true) {
4110 locals->RequiresDSC[i][k] = true;
4111 if (mode_lib->vba.Output[k] == dm_dp) {
4112 locals->RequiresFEC[i][k] = true;
4114 locals->RequiresFEC[i][k] = false;
4116 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4118 locals->RequiresDSC[i][k] = false;
4119 locals->RequiresFEC[i][k] = false;
4121 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4123 if (mode_lib->vba.Outbpp == BPP_INVALID
4124 && mode_lib->vba.PHYCLKPerState[i]
4126 mode_lib->vba.Outbpp = TruncToValidBPP(
4127 (1.0 - mode_lib->vba.Downspreading / 100.0) * 810.0
4128 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4130 mode_lib->vba.Output[k],
4131 mode_lib->vba.OutputFormat[k],
4132 mode_lib->vba.DSCInputBitPerComponent[k]);
4133 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4134 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 810.0
4135 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4137 mode_lib->vba.Output[k],
4138 mode_lib->vba.OutputFormat[k],
4139 mode_lib->vba.DSCInputBitPerComponent[k]);
4140 if (mode_lib->vba.DSCEnabled[k] == true || mode_lib->vba.Outbpp == BPP_INVALID) {
4141 locals->RequiresDSC[i][k] = true;
4142 if (mode_lib->vba.Output[k] == dm_dp) {
4143 locals->RequiresFEC[i][k] = true;
4145 locals->RequiresFEC[i][k] = false;
4147 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4149 locals->RequiresDSC[i][k] = false;
4150 locals->RequiresFEC[i][k] = false;
4152 locals->OutputBppPerState[i][k] =
4153 mode_lib->vba.Outbpp;
4157 locals->OutputBppPerState[i][k] = BPP_BLENDED_PIPE;
4161 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4162 locals->DIOSupport[i] = true;
4163 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4164 if (locals->OutputBppPerState[i][k] == BPP_INVALID
4165 || (mode_lib->vba.OutputFormat[k] == dm_420
4166 && mode_lib->vba.Interlace[k] == true
4167 && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)) {
4168 locals->DIOSupport[i] = false;
4172 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4173 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4174 locals->DSCCLKRequiredMoreThanSupported[i] = false;
4175 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4176 if ((mode_lib->vba.Output[k] == dm_dp
4177 || mode_lib->vba.Output[k] == dm_edp)) {
4178 if (mode_lib->vba.OutputFormat[k] == dm_420
4179 || mode_lib->vba.OutputFormat[k]
4181 mode_lib->vba.DSCFormatFactor = 2;
4183 mode_lib->vba.DSCFormatFactor = 1;
4185 if (locals->RequiresDSC[i][k] == true) {
4186 if (locals->ODMCombineEnablePerState[i][k]
4188 if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor
4189 > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4190 locals->DSCCLKRequiredMoreThanSupported[i] =
4194 if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor
4195 > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4196 locals->DSCCLKRequiredMoreThanSupported[i] =
4205 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4206 locals->NotEnoughDSCUnits[i] = false;
4207 mode_lib->vba.TotalDSCUnitsRequired = 0.0;
4208 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4209 if (locals->RequiresDSC[i][k] == true) {
4210 if (locals->ODMCombineEnablePerState[i][k] == true) {
4211 mode_lib->vba.TotalDSCUnitsRequired =
4212 mode_lib->vba.TotalDSCUnitsRequired + 2.0;
4214 mode_lib->vba.TotalDSCUnitsRequired =
4215 mode_lib->vba.TotalDSCUnitsRequired + 1.0;
4219 if (mode_lib->vba.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC) {
4220 locals->NotEnoughDSCUnits[i] = true;
4223 /*DSC Delay per state*/
4225 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4226 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4227 if (mode_lib->vba.BlendingAndTiming[k] != k) {
4228 mode_lib->vba.slices = 0;
4229 } else if (locals->RequiresDSC[i][k] == 0
4230 || locals->RequiresDSC[i][k] == false) {
4231 mode_lib->vba.slices = 0;
4232 } else if (mode_lib->vba.PixelClockBackEnd[k] > 3200.0) {
4233 mode_lib->vba.slices = dml_ceil(
4234 mode_lib->vba.PixelClockBackEnd[k] / 400.0,
4236 } else if (mode_lib->vba.PixelClockBackEnd[k] > 1360.0) {
4237 mode_lib->vba.slices = 8.0;
4238 } else if (mode_lib->vba.PixelClockBackEnd[k] > 680.0) {
4239 mode_lib->vba.slices = 4.0;
4240 } else if (mode_lib->vba.PixelClockBackEnd[k] > 340.0) {
4241 mode_lib->vba.slices = 2.0;
4243 mode_lib->vba.slices = 1.0;
4245 if (locals->OutputBppPerState[i][k] == BPP_BLENDED_PIPE
4246 || locals->OutputBppPerState[i][k] == BPP_INVALID) {
4247 mode_lib->vba.bpp = 0.0;
4249 mode_lib->vba.bpp = locals->OutputBppPerState[i][k];
4251 if (locals->RequiresDSC[i][k] == true && mode_lib->vba.bpp != 0.0) {
4252 if (locals->ODMCombineEnablePerState[i][k] == false) {
4253 locals->DSCDelayPerState[i][k] =
4255 mode_lib->vba.DSCInputBitPerComponent[k],
4258 mode_lib->vba.HActive[k]
4259 / mode_lib->vba.slices,
4261 mode_lib->vba.slices,
4262 mode_lib->vba.OutputFormat[k])
4264 mode_lib->vba.OutputFormat[k]);
4266 locals->DSCDelayPerState[i][k] =
4267 2.0 * (dscceComputeDelay(
4268 mode_lib->vba.DSCInputBitPerComponent[k],
4270 dml_ceil(mode_lib->vba.HActive[k] / mode_lib->vba.slices, 1.0),
4271 mode_lib->vba.slices / 2,
4272 mode_lib->vba.OutputFormat[k])
4273 + dscComputeDelay(mode_lib->vba.OutputFormat[k]));
4275 locals->DSCDelayPerState[i][k] =
4276 locals->DSCDelayPerState[i][k] * mode_lib->vba.PixelClock[k] / mode_lib->vba.PixelClockBackEnd[k];
4278 locals->DSCDelayPerState[i][k] = 0.0;
4281 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4282 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4283 for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) {
4284 if (mode_lib->vba.BlendingAndTiming[k] == m && locals->RequiresDSC[i][m] == true)
4285 locals->DSCDelayPerState[i][k] = locals->DSCDelayPerState[i][m];
4292 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4293 for (j = 0; j < 2; j++) {
4294 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4295 if (locals->ODMCombineEnablePerState[i][k] == true)
4296 locals->SwathWidthYPerState[i][j][k] = dml_min(locals->SwathWidthYSingleDPP[k], dml_round(locals->HActive[k] / 2 * locals->HRatio[k]));
4298 locals->SwathWidthYPerState[i][j][k] = locals->SwathWidthYSingleDPP[k] / locals->NoOfDPP[i][j][k];
4299 locals->SwathWidthGranularityY = 256 / dml_ceil(locals->BytePerPixelInDETY[k], 1) / locals->MaxSwathHeightY[k];
4300 locals->RoundedUpMaxSwathSizeBytesY = (dml_ceil(locals->SwathWidthYPerState[i][j][k] - 1, locals->SwathWidthGranularityY)
4301 + locals->SwathWidthGranularityY) * locals->BytePerPixelInDETY[k] * locals->MaxSwathHeightY[k];
4302 if (locals->SourcePixelFormat[k] == dm_420_10) {
4303 locals->RoundedUpMaxSwathSizeBytesY = dml_ceil(locals->RoundedUpMaxSwathSizeBytesY, 256) + 256;
4305 if (locals->MaxSwathHeightC[k] > 0) {
4306 locals->SwathWidthGranularityC = 256 / dml_ceil(locals->BytePerPixelInDETC[k], 2) / locals->MaxSwathHeightC[k];
4308 locals->RoundedUpMaxSwathSizeBytesC = (dml_ceil(locals->SwathWidthYPerState[i][j][k] / 2 - 1, locals->SwathWidthGranularityC)
4309 + locals->SwathWidthGranularityC) * locals->BytePerPixelInDETC[k] * locals->MaxSwathHeightC[k];
4311 if (locals->SourcePixelFormat[k] == dm_420_10) {
4312 locals->RoundedUpMaxSwathSizeBytesC = dml_ceil(locals->RoundedUpMaxSwathSizeBytesC, 256) + 256;
4314 locals->RoundedUpMaxSwathSizeBytesC = 0;
4317 if (locals->RoundedUpMaxSwathSizeBytesY + locals->RoundedUpMaxSwathSizeBytesC <= locals->DETBufferSizeInKByte * 1024 / 2) {
4318 locals->SwathHeightYPerState[i][j][k] = locals->MaxSwathHeightY[k];
4319 locals->SwathHeightCPerState[i][j][k] = locals->MaxSwathHeightC[k];
4321 locals->SwathHeightYPerState[i][j][k] = locals->MinSwathHeightY[k];
4322 locals->SwathHeightCPerState[i][j][k] = locals->MinSwathHeightC[k];
4325 if (locals->BytePerPixelInDETC[k] == 0) {
4326 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4327 locals->LinesInDETChroma = 0;
4328 } else if (locals->SwathHeightYPerState[i][j][k] <= locals->SwathHeightCPerState[i][j][k]) {
4329 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETY[k] /
4330 locals->SwathWidthYPerState[i][j][k];
4331 locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETC[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4333 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 * 2 / 3 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4334 locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 3 / locals->BytePerPixelInDETY[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4337 locals->EffectiveLBLatencyHidingSourceLinesLuma = dml_min(locals->MaxLineBufferLines,
4338 dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k] / (locals->SwathWidthYPerState[i][j][k]
4339 / dml_max(locals->HRatio[k], 1)), 1)) - (locals->vtaps[k] - 1);
4341 locals->EffectiveLBLatencyHidingSourceLinesChroma = dml_min(locals->MaxLineBufferLines,
4342 dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k]
4343 / (locals->SwathWidthYPerState[i][j][k] / 2
4344 / dml_max(locals->HRatio[k] / 2, 1)), 1)) - (locals->VTAPsChroma[k] - 1);
4346 locals->EffectiveDETLBLinesLuma = dml_floor(locals->LinesInDETLuma + dml_min(
4347 locals->LinesInDETLuma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETY[k] *
4348 locals->PSCL_FACTOR[k] / locals->ReturnBWPerState[i],
4349 locals->EffectiveLBLatencyHidingSourceLinesLuma),
4350 locals->SwathHeightYPerState[i][j][k]);
4352 locals->EffectiveDETLBLinesChroma = dml_floor(locals->LinesInDETChroma + dml_min(
4353 locals->LinesInDETChroma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETC[k] *
4354 locals->PSCL_FACTOR_CHROMA[k] / locals->ReturnBWPerState[i],
4355 locals->EffectiveLBLatencyHidingSourceLinesChroma),
4356 locals->SwathHeightCPerState[i][j][k]);
4358 if (locals->BytePerPixelInDETC[k] == 0) {
4359 locals->UrgentLatencySupportUsPerState[i][j][k] = locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4360 / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4361 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k]);
4363 locals->UrgentLatencySupportUsPerState[i][j][k] = dml_min(
4364 locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4365 / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4366 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k]),
4367 locals->EffectiveDETLBLinesChroma * (locals->HTotal[k] / locals->PixelClock[k]) / (locals->VRatio[k] / 2) -
4368 locals->EffectiveDETLBLinesChroma * locals->SwathWidthYPerState[i][j][k] / 2 *
4369 dml_ceil(locals->BytePerPixelInDETC[k], 2) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k]));
4375 for (i = 0; i <= locals->soc.num_states; i++) {
4376 for (j = 0; j < 2; j++) {
4377 locals->UrgentLatencySupport[i][j] = true;
4378 for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4379 if (locals->UrgentLatencySupportUsPerState[i][j][k] < locals->UrgentLatency)
4380 locals->UrgentLatencySupport[i][j] = false;
4387 for (i = 0; i <= locals->soc.num_states; i++) {
4388 for (j = 0; j < 2; j++) {
4389 locals->TotalNumberOfDCCActiveDPP[i][j] = 0;
4390 for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4391 if (locals->DCCEnable[k] == true) {
4392 locals->TotalNumberOfDCCActiveDPP[i][j] =
4393 locals->TotalNumberOfDCCActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
4399 CalculateMinAndMaxPrefetchMode(locals->AllowDRAMSelfRefreshOrDRAMClockChangeInVblank, &locals->MinPrefetchMode, &locals->MaxPrefetchMode);
4401 for (i = 0; i <= locals->soc.num_states; i++) {
4402 for (j = 0; j < 2; j++) {
4403 for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4404 locals->NoOfDPPThisState[k] = locals->NoOfDPP[i][j][k];
4405 locals->RequiredDPPCLKThisState[k] = locals->RequiredDPPCLK[i][j][k];
4406 locals->SwathHeightYThisState[k] = locals->SwathHeightYPerState[i][j][k];
4407 locals->SwathHeightCThisState[k] = locals->SwathHeightCPerState[i][j][k];
4408 locals->SwathWidthYThisState[k] = locals->SwathWidthYPerState[i][j][k];
4409 mode_lib->vba.ProjectedDCFCLKDeepSleep = dml_max(
4410 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4411 mode_lib->vba.PixelClock[k] / 16.0);
4412 if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) {
4413 if (mode_lib->vba.VRatio[k] <= 1.0) {
4414 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4416 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4419 mode_lib->vba.BytePerPixelInDETY[k],
4422 * mode_lib->vba.HRatio[k]
4423 * mode_lib->vba.PixelClock[k]
4424 / mode_lib->vba.NoOfDPP[i][j][k]);
4426 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4428 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4431 mode_lib->vba.BytePerPixelInDETY[k],
4434 * mode_lib->vba.PSCL_FACTOR[k]
4435 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4438 if (mode_lib->vba.VRatio[k] <= 1.0) {
4439 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4441 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4444 mode_lib->vba.BytePerPixelInDETY[k],
4447 * mode_lib->vba.HRatio[k]
4448 * mode_lib->vba.PixelClock[k]
4449 / mode_lib->vba.NoOfDPP[i][j][k]);
4451 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4453 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4456 mode_lib->vba.BytePerPixelInDETY[k],
4459 * mode_lib->vba.PSCL_FACTOR[k]
4460 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4462 if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) {
4463 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4465 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4468 mode_lib->vba.BytePerPixelInDETC[k],
4471 * mode_lib->vba.HRatio[k]
4473 * mode_lib->vba.PixelClock[k]
4474 / mode_lib->vba.NoOfDPP[i][j][k]);
4476 mode_lib->vba.ProjectedDCFCLKDeepSleep =
4478 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4481 mode_lib->vba.BytePerPixelInDETC[k],
4484 * mode_lib->vba.PSCL_FACTOR_CHROMA[k]
4485 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4489 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4490 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
4492 mode_lib->vba.DCCEnable[k],
4493 mode_lib->vba.Read256BlockHeightY[k],
4494 mode_lib->vba.Read256BlockWidthY[k],
4495 mode_lib->vba.SourcePixelFormat[k],
4496 mode_lib->vba.SurfaceTiling[k],
4497 dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0),
4498 mode_lib->vba.SourceScan[k],
4499 mode_lib->vba.ViewportWidth[k],
4500 mode_lib->vba.ViewportHeight[k],
4501 mode_lib->vba.SwathWidthYPerState[i][j][k],
4502 mode_lib->vba.GPUVMEnable,
4503 mode_lib->vba.VMMPageSize,
4504 mode_lib->vba.PTEBufferSizeInRequestsLuma,
4505 mode_lib->vba.PDEProcessingBufIn64KBReqs,
4506 mode_lib->vba.PitchY[k],
4507 mode_lib->vba.DCCMetaPitchY[k],
4508 &mode_lib->vba.MacroTileWidthY[k],
4509 &mode_lib->vba.MetaRowBytesY,
4510 &mode_lib->vba.DPTEBytesPerRowY,
4511 &mode_lib->vba.PTEBufferSizeNotExceededY[i][j][k],
4512 &mode_lib->vba.dpte_row_height[k],
4513 &mode_lib->vba.meta_row_height[k]);
4514 mode_lib->vba.PrefetchLinesY[k] = CalculatePrefetchSourceLines(
4516 mode_lib->vba.VRatio[k],
4517 mode_lib->vba.vtaps[k],
4518 mode_lib->vba.Interlace[k],
4519 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4520 mode_lib->vba.SwathHeightYPerState[i][j][k],
4521 mode_lib->vba.ViewportYStartY[k],
4522 &mode_lib->vba.PrefillY[k],
4523 &mode_lib->vba.MaxNumSwY[k]);
4524 if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
4525 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
4526 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
4527 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
4528 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)) {
4529 mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
4531 mode_lib->vba.DCCEnable[k],
4532 mode_lib->vba.Read256BlockHeightY[k],
4533 mode_lib->vba.Read256BlockWidthY[k],
4534 mode_lib->vba.SourcePixelFormat[k],
4535 mode_lib->vba.SurfaceTiling[k],
4536 dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0),
4537 mode_lib->vba.SourceScan[k],
4538 mode_lib->vba.ViewportWidth[k] / 2.0,
4539 mode_lib->vba.ViewportHeight[k] / 2.0,
4540 mode_lib->vba.SwathWidthYPerState[i][j][k] / 2.0,
4541 mode_lib->vba.GPUVMEnable,
4542 mode_lib->vba.VMMPageSize,
4543 mode_lib->vba.PTEBufferSizeInRequestsLuma,
4544 mode_lib->vba.PDEProcessingBufIn64KBReqs,
4545 mode_lib->vba.PitchC[k],
4547 &mode_lib->vba.MacroTileWidthC[k],
4548 &mode_lib->vba.MetaRowBytesC,
4549 &mode_lib->vba.DPTEBytesPerRowC,
4550 &mode_lib->vba.PTEBufferSizeNotExceededC[i][j][k],
4551 &mode_lib->vba.dpte_row_height_chroma[k],
4552 &mode_lib->vba.meta_row_height_chroma[k]);
4553 mode_lib->vba.PrefetchLinesC[k] = CalculatePrefetchSourceLines(
4555 mode_lib->vba.VRatio[k] / 2.0,
4556 mode_lib->vba.VTAPsChroma[k],
4557 mode_lib->vba.Interlace[k],
4558 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4559 mode_lib->vba.SwathHeightCPerState[i][j][k],
4560 mode_lib->vba.ViewportYStartC[k],
4561 &mode_lib->vba.PrefillC[k],
4562 &mode_lib->vba.MaxNumSwC[k]);
4564 mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = 0.0;
4565 mode_lib->vba.MetaRowBytesC = 0.0;
4566 mode_lib->vba.DPTEBytesPerRowC = 0.0;
4567 locals->PrefetchLinesC[k] = 0.0;
4568 locals->PTEBufferSizeNotExceededC[i][j][k] = true;
4569 locals->PTEBufferSizeInRequestsForLuma = mode_lib->vba.PTEBufferSizeInRequestsLuma + mode_lib->vba.PTEBufferSizeInRequestsChroma;
4571 locals->PDEAndMetaPTEBytesPerFrame[k] =
4572 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY + mode_lib->vba.PDEAndMetaPTEBytesPerFrameC;
4573 locals->MetaRowBytes[k] = mode_lib->vba.MetaRowBytesY + mode_lib->vba.MetaRowBytesC;
4574 locals->DPTEBytesPerRow[k] = mode_lib->vba.DPTEBytesPerRowY + mode_lib->vba.DPTEBytesPerRowC;
4576 CalculateActiveRowBandwidth(
4577 mode_lib->vba.GPUVMEnable,
4578 mode_lib->vba.SourcePixelFormat[k],
4579 mode_lib->vba.VRatio[k],
4580 mode_lib->vba.DCCEnable[k],
4581 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4582 mode_lib->vba.MetaRowBytesY,
4583 mode_lib->vba.MetaRowBytesC,
4584 mode_lib->vba.meta_row_height[k],
4585 mode_lib->vba.meta_row_height_chroma[k],
4586 mode_lib->vba.DPTEBytesPerRowY,
4587 mode_lib->vba.DPTEBytesPerRowC,
4588 mode_lib->vba.dpte_row_height[k],
4589 mode_lib->vba.dpte_row_height_chroma[k],
4590 &mode_lib->vba.meta_row_bw[k],
4591 &mode_lib->vba.dpte_row_bw[k],
4592 &mode_lib->vba.qual_row_bw[k]);
4594 mode_lib->vba.ExtraLatency =
4595 mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i]
4596 + (mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4597 * mode_lib->vba.PixelChunkSizeInKByte
4598 + mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
4599 * mode_lib->vba.MetaChunkSize)
4601 / mode_lib->vba.ReturnBWPerState[i];
4602 if (mode_lib->vba.GPUVMEnable == true) {
4603 mode_lib->vba.ExtraLatency = mode_lib->vba.ExtraLatency
4604 + mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4605 * mode_lib->vba.PTEGroupSize
4606 / mode_lib->vba.ReturnBWPerState[i];
4608 mode_lib->vba.TimeCalc = 24.0 / mode_lib->vba.ProjectedDCFCLKDeepSleep;
4610 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4611 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4612 if (mode_lib->vba.WritebackEnable[k] == true) {
4613 locals->WritebackDelay[i][k] = mode_lib->vba.WritebackLatency
4614 + CalculateWriteBackDelay(
4615 mode_lib->vba.WritebackPixelFormat[k],
4616 mode_lib->vba.WritebackHRatio[k],
4617 mode_lib->vba.WritebackVRatio[k],
4618 mode_lib->vba.WritebackLumaHTaps[k],
4619 mode_lib->vba.WritebackLumaVTaps[k],
4620 mode_lib->vba.WritebackChromaHTaps[k],
4621 mode_lib->vba.WritebackChromaVTaps[k],
4622 mode_lib->vba.WritebackDestinationWidth[k]) / locals->RequiredDISPCLK[i][j];
4624 locals->WritebackDelay[i][k] = 0.0;
4626 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4627 if (mode_lib->vba.BlendingAndTiming[m] == k
4628 && mode_lib->vba.WritebackEnable[m]
4630 locals->WritebackDelay[i][k] = dml_max(locals->WritebackDelay[i][k],
4631 mode_lib->vba.WritebackLatency + CalculateWriteBackDelay(
4632 mode_lib->vba.WritebackPixelFormat[m],
4633 mode_lib->vba.WritebackHRatio[m],
4634 mode_lib->vba.WritebackVRatio[m],
4635 mode_lib->vba.WritebackLumaHTaps[m],
4636 mode_lib->vba.WritebackLumaVTaps[m],
4637 mode_lib->vba.WritebackChromaHTaps[m],
4638 mode_lib->vba.WritebackChromaVTaps[m],
4639 mode_lib->vba.WritebackDestinationWidth[m]) / locals->RequiredDISPCLK[i][j]);
4644 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4645 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4646 if (mode_lib->vba.BlendingAndTiming[k] == m) {
4647 locals->WritebackDelay[i][k] = locals->WritebackDelay[i][m];
4651 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4652 for (m = 0; m < locals->NumberOfCursors[k]; m++)
4653 locals->cursor_bw[k] = locals->NumberOfCursors[k] * locals->CursorWidth[k][m] * locals->CursorBPP[k][m]
4654 / 8 / (locals->HTotal[k] / locals->PixelClock[k]) * locals->VRatio[k];
4657 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4658 locals->MaximumVStartup[k] = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
4659 - dml_max(1.0, dml_ceil(locals->WritebackDelay[i][k] / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0));
4662 mode_lib->vba.NextPrefetchMode = mode_lib->vba.MinPrefetchMode;
4664 mode_lib->vba.PrefetchMode[i][j] = mode_lib->vba.NextPrefetchMode;
4665 mode_lib->vba.NextPrefetchMode = mode_lib->vba.NextPrefetchMode + 1;
4667 mode_lib->vba.TWait = CalculateTWait(
4668 mode_lib->vba.PrefetchMode[i][j],
4669 mode_lib->vba.DRAMClockChangeLatency,
4670 mode_lib->vba.UrgentLatency,
4671 mode_lib->vba.SREnterPlusExitTime);
4672 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4674 if (mode_lib->vba.XFCEnabled[k] == true) {
4675 mode_lib->vba.XFCRemoteSurfaceFlipDelay =
4676 CalculateRemoteSurfaceFlipDelay(
4678 mode_lib->vba.VRatio[k],
4679 locals->SwathWidthYPerState[i][j][k],
4680 dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
4681 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4682 mode_lib->vba.XFCTSlvVupdateOffset,
4683 mode_lib->vba.XFCTSlvVupdateWidth,
4684 mode_lib->vba.XFCTSlvVreadyOffset,
4685 mode_lib->vba.XFCXBUFLatencyTolerance,
4686 mode_lib->vba.XFCFillBWOverhead,
4687 mode_lib->vba.XFCSlvChunkSize,
4688 mode_lib->vba.XFCBusTransportTime,
4689 mode_lib->vba.TimeCalc,
4690 mode_lib->vba.TWait,
4691 &mode_lib->vba.SrcActiveDrainRate,
4692 &mode_lib->vba.TInitXFill,
4693 &mode_lib->vba.TslvChk);
4695 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0.0;
4697 mode_lib->vba.IsErrorResult[i][j][k] =
4698 CalculatePrefetchSchedule(
4700 mode_lib->vba.RequiredDPPCLK[i][j][k],
4701 mode_lib->vba.RequiredDISPCLK[i][j],
4702 mode_lib->vba.PixelClock[k],
4703 mode_lib->vba.ProjectedDCFCLKDeepSleep,
4704 mode_lib->vba.DSCDelayPerState[i][k],
4705 mode_lib->vba.NoOfDPP[i][j][k],
4706 mode_lib->vba.ScalerEnabled[k],
4707 mode_lib->vba.NumberOfCursors[k],
4708 mode_lib->vba.DPPCLKDelaySubtotal,
4709 mode_lib->vba.DPPCLKDelaySCL,
4710 mode_lib->vba.DPPCLKDelaySCLLBOnly,
4711 mode_lib->vba.DPPCLKDelayCNVCFormater,
4712 mode_lib->vba.DPPCLKDelayCNVCCursor,
4713 mode_lib->vba.DISPCLKDelaySubtotal,
4714 mode_lib->vba.SwathWidthYPerState[i][j][k]
4715 / mode_lib->vba.HRatio[k],
4716 mode_lib->vba.OutputFormat[k],
4717 mode_lib->vba.VTotal[k]
4718 - mode_lib->vba.VActive[k],
4719 mode_lib->vba.HTotal[k],
4720 mode_lib->vba.MaxInterDCNTileRepeaters,
4721 mode_lib->vba.MaximumVStartup[k],
4722 mode_lib->vba.GPUVMMaxPageTableLevels,
4723 mode_lib->vba.GPUVMEnable,
4724 mode_lib->vba.DynamicMetadataEnable[k],
4725 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
4726 mode_lib->vba.DynamicMetadataTransmittedBytes[k],
4727 mode_lib->vba.DCCEnable[k],
4728 mode_lib->vba.UrgentLatencyPixelDataOnly,
4729 mode_lib->vba.ExtraLatency,
4730 mode_lib->vba.TimeCalc,
4731 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k],
4732 mode_lib->vba.MetaRowBytes[k],
4733 mode_lib->vba.DPTEBytesPerRow[k],
4734 mode_lib->vba.PrefetchLinesY[k],
4735 mode_lib->vba.SwathWidthYPerState[i][j][k],
4736 mode_lib->vba.BytePerPixelInDETY[k],
4737 mode_lib->vba.PrefillY[k],
4738 mode_lib->vba.MaxNumSwY[k],
4739 mode_lib->vba.PrefetchLinesC[k],
4740 mode_lib->vba.BytePerPixelInDETC[k],
4741 mode_lib->vba.PrefillC[k],
4742 mode_lib->vba.MaxNumSwC[k],
4743 mode_lib->vba.SwathHeightYPerState[i][j][k],
4744 mode_lib->vba.SwathHeightCPerState[i][j][k],
4745 mode_lib->vba.TWait,
4746 mode_lib->vba.XFCEnabled[k],
4747 mode_lib->vba.XFCRemoteSurfaceFlipDelay,
4748 mode_lib->vba.Interlace[k],
4749 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4750 mode_lib->vba.DSTXAfterScaler,
4751 mode_lib->vba.DSTYAfterScaler,
4752 &mode_lib->vba.LineTimesForPrefetch[k],
4753 &mode_lib->vba.PrefetchBW[k],
4754 &mode_lib->vba.LinesForMetaPTE[k],
4755 &mode_lib->vba.LinesForMetaAndDPTERow[k],
4756 &mode_lib->vba.VRatioPreY[i][j][k],
4757 &mode_lib->vba.VRatioPreC[i][j][k],
4758 &mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k],
4759 &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata,
4760 &mode_lib->vba.Tno_bw[k],
4761 &mode_lib->vba.VUpdateOffsetPix[k],
4762 &mode_lib->vba.VUpdateWidthPix[k],
4763 &mode_lib->vba.VReadyOffsetPix[k]);
4765 mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = 0.0;
4766 mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0;
4767 locals->prefetch_vm_bw_valid = true;
4768 locals->prefetch_row_bw_valid = true;
4769 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4770 if (locals->PDEAndMetaPTEBytesPerFrame[k] == 0)
4771 locals->prefetch_vm_bw[k] = 0;
4772 else if (locals->LinesForMetaPTE[k] > 0)
4773 locals->prefetch_vm_bw[k] = locals->PDEAndMetaPTEBytesPerFrame[k]
4774 / (locals->LinesForMetaPTE[k] * locals->HTotal[k] / locals->PixelClock[k]);
4776 locals->prefetch_vm_bw[k] = 0;
4777 locals->prefetch_vm_bw_valid = false;
4779 if (locals->MetaRowBytes[k] + locals->DPTEBytesPerRow[k] == 0)
4780 locals->prefetch_row_bw[k] = 0;
4781 else if (locals->LinesForMetaAndDPTERow[k] > 0)
4782 locals->prefetch_row_bw[k] = (locals->MetaRowBytes[k] + locals->DPTEBytesPerRow[k])
4783 / (locals->LinesForMetaAndDPTERow[k] * locals->HTotal[k] / locals->PixelClock[k]);
4785 locals->prefetch_row_bw[k] = 0;
4786 locals->prefetch_row_bw_valid = false;
4789 mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = mode_lib->vba.MaximumReadBandwidthWithPrefetch
4790 + mode_lib->vba.cursor_bw[k] + mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k];
4791 mode_lib->vba.MaximumReadBandwidthWithPrefetch =
4792 mode_lib->vba.MaximumReadBandwidthWithPrefetch
4793 + mode_lib->vba.cursor_bw[k]
4795 mode_lib->vba.prefetch_vm_bw[k],
4796 mode_lib->vba.prefetch_row_bw[k],
4797 dml_max(mode_lib->vba.ReadBandwidth[k],
4798 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k])
4799 + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k]);
4801 locals->BandwidthWithoutPrefetchSupported[i] = true;
4802 if (mode_lib->vba.MaximumReadBandwidthWithoutPrefetch > locals->ReturnBWPerState[i]) {
4803 locals->BandwidthWithoutPrefetchSupported[i] = false;
4806 locals->PrefetchSupported[i][j] = true;
4807 if (mode_lib->vba.MaximumReadBandwidthWithPrefetch > locals->ReturnBWPerState[i]) {
4808 locals->PrefetchSupported[i][j] = false;
4810 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4811 if (locals->LineTimesForPrefetch[k] < 2.0
4812 || locals->LinesForMetaPTE[k] >= 8.0
4813 || locals->LinesForMetaAndDPTERow[k] >= 16.0
4814 || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4815 locals->PrefetchSupported[i][j] = false;
4818 locals->VRatioInPrefetchSupported[i][j] = true;
4819 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4820 if (locals->VRatioPreY[i][j][k] > 4.0
4821 || locals->VRatioPreC[i][j][k] > 4.0
4822 || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4823 locals->VRatioInPrefetchSupported[i][j] = false;
4826 } while ((locals->PrefetchSupported[i][j] != true || locals->VRatioInPrefetchSupported[i][j] != true)
4827 && mode_lib->vba.NextPrefetchMode < mode_lib->vba.MaxPrefetchMode);
4829 if (mode_lib->vba.PrefetchSupported[i][j] == true
4830 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
4831 mode_lib->vba.BandwidthAvailableForImmediateFlip =
4832 mode_lib->vba.ReturnBWPerState[i];
4833 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4834 mode_lib->vba.BandwidthAvailableForImmediateFlip =
4835 mode_lib->vba.BandwidthAvailableForImmediateFlip
4836 - mode_lib->vba.cursor_bw[k]
4838 mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.qual_row_bw[k],
4839 mode_lib->vba.PrefetchBW[k]);
4841 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4842 mode_lib->vba.ImmediateFlipBytes[k] = 0.0;
4843 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4844 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4845 mode_lib->vba.ImmediateFlipBytes[k] =
4846 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k]
4847 + mode_lib->vba.MetaRowBytes[k]
4848 + mode_lib->vba.DPTEBytesPerRow[k];
4851 mode_lib->vba.TotImmediateFlipBytes = 0.0;
4852 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4853 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4854 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4855 mode_lib->vba.TotImmediateFlipBytes =
4856 mode_lib->vba.TotImmediateFlipBytes
4857 + mode_lib->vba.ImmediateFlipBytes[k];
4861 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4862 CalculateFlipSchedule(
4864 mode_lib->vba.ExtraLatency,
4865 mode_lib->vba.UrgentLatencyPixelDataOnly,
4866 mode_lib->vba.GPUVMMaxPageTableLevels,
4867 mode_lib->vba.GPUVMEnable,
4868 mode_lib->vba.BandwidthAvailableForImmediateFlip,
4869 mode_lib->vba.TotImmediateFlipBytes,
4870 mode_lib->vba.SourcePixelFormat[k],
4871 mode_lib->vba.ImmediateFlipBytes[k],
4872 mode_lib->vba.HTotal[k]
4873 / mode_lib->vba.PixelClock[k],
4874 mode_lib->vba.VRatio[k],
4875 mode_lib->vba.Tno_bw[k],
4876 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k],
4877 mode_lib->vba.MetaRowBytes[k],
4878 mode_lib->vba.DPTEBytesPerRow[k],
4879 mode_lib->vba.DCCEnable[k],
4880 mode_lib->vba.dpte_row_height[k],
4881 mode_lib->vba.meta_row_height[k],
4882 mode_lib->vba.qual_row_bw[k],
4883 &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
4884 &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
4885 &mode_lib->vba.final_flip_bw[k],
4886 &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
4888 mode_lib->vba.total_dcn_read_bw_with_flip = 0.0;
4889 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4890 mode_lib->vba.total_dcn_read_bw_with_flip =
4891 mode_lib->vba.total_dcn_read_bw_with_flip
4892 + mode_lib->vba.cursor_bw[k]
4894 mode_lib->vba.prefetch_vm_bw[k],
4895 mode_lib->vba.prefetch_row_bw[k],
4896 mode_lib->vba.final_flip_bw[k]
4898 mode_lib->vba.ReadBandwidth[k],
4899 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k]));
4901 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = true;
4902 if (mode_lib->vba.total_dcn_read_bw_with_flip
4903 > mode_lib->vba.ReturnBWPerState[i]) {
4904 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4906 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4907 if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) {
4908 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4912 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4917 /*Vertical Active BW support*/
4918 mode_lib->vba.MaxTotalVActiveRDBandwidth = 0;
4919 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++)
4920 mode_lib->vba.MaxTotalVActiveRDBandwidth = mode_lib->vba.MaxTotalVActiveRDBandwidth + mode_lib->vba.ReadBandwidth[k];
4921 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4922 mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i] = dml_min(mode_lib->vba.ReturnBusWidth *
4923 mode_lib->vba.DCFCLKPerState[i], mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000) *
4924 mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation / 100;
4925 if (mode_lib->vba.MaxTotalVActiveRDBandwidth <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i])
4926 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i] = true;
4928 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i] = false;
4931 /*PTE Buffer Size Check*/
4933 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4934 for (j = 0; j < 2; j++) {
4935 locals->PTEBufferSizeNotExceeded[i][j] = true;
4936 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4937 if (locals->PTEBufferSizeNotExceededY[i][j][k] == false
4938 || locals->PTEBufferSizeNotExceededC[i][j][k] == false) {
4939 locals->PTEBufferSizeNotExceeded[i][j] = false;
4944 /*Cursor Support Check*/
4945 mode_lib->vba.CursorSupport = true;
4946 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4947 for (j = 0; j < 2; j++) {
4948 if (mode_lib->vba.CursorWidth[k][j] > 0.0) {
4951 mode_lib->vba.CursorBufferSize
4952 - mode_lib->vba.CursorChunkSize,
4953 mode_lib->vba.CursorChunkSize) * 1024.0
4954 / (mode_lib->vba.CursorWidth[k][j]
4955 * mode_lib->vba.CursorBPP[k][j]
4958 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
4959 / mode_lib->vba.VRatio[k] < mode_lib->vba.UrgentLatencyPixelDataOnly
4960 || (mode_lib->vba.CursorBPP[k][j] == 64.0
4961 && mode_lib->vba.Cursor64BppSupport == false)) {
4962 mode_lib->vba.CursorSupport = false;
4967 /*Valid Pitch Check*/
4969 mode_lib->vba.PitchSupport = true;
4970 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4971 locals->AlignedYPitch[k] = dml_ceil(
4972 dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.ViewportWidth[k]),
4973 locals->MacroTileWidthY[k]);
4974 if (locals->AlignedYPitch[k] > mode_lib->vba.PitchY[k]) {
4975 mode_lib->vba.PitchSupport = false;
4977 if (mode_lib->vba.DCCEnable[k] == true) {
4978 locals->AlignedDCCMetaPitch[k] = dml_ceil(
4980 mode_lib->vba.DCCMetaPitchY[k],
4981 mode_lib->vba.ViewportWidth[k]),
4982 64.0 * locals->Read256BlockWidthY[k]);
4984 locals->AlignedDCCMetaPitch[k] = mode_lib->vba.DCCMetaPitchY[k];
4986 if (locals->AlignedDCCMetaPitch[k] > mode_lib->vba.DCCMetaPitchY[k]) {
4987 mode_lib->vba.PitchSupport = false;
4989 if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
4990 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
4991 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
4992 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
4993 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
4994 locals->AlignedCPitch[k] = dml_ceil(
4996 mode_lib->vba.PitchC[k],
4997 mode_lib->vba.ViewportWidth[k] / 2.0),
4998 locals->MacroTileWidthC[k]);
5000 locals->AlignedCPitch[k] = mode_lib->vba.PitchC[k];
5002 if (locals->AlignedCPitch[k] > mode_lib->vba.PitchC[k]) {
5003 mode_lib->vba.PitchSupport = false;
5006 /*Mode Support, Voltage State and SOC Configuration*/
5008 for (i = mode_lib->vba.soc.num_states; i >= 0; i--) {
5009 for (j = 0; j < 2; j++) {
5010 enum dm_validation_status status = DML_VALIDATION_OK;
5012 if (mode_lib->vba.ScaleRatioAndTapsSupport != true) {
5013 status = DML_FAIL_SCALE_RATIO_TAP;
5014 } else if (mode_lib->vba.SourceFormatPixelAndScanSupport != true) {
5015 status = DML_FAIL_SOURCE_PIXEL_FORMAT;
5016 } else if (locals->ViewportSizeSupport[i] != true) {
5017 status = DML_FAIL_VIEWPORT_SIZE;
5018 } else if (locals->DIOSupport[i] != true) {
5019 status = DML_FAIL_DIO_SUPPORT;
5020 } else if (locals->NotEnoughDSCUnits[i] != false) {
5021 status = DML_FAIL_NOT_ENOUGH_DSC;
5022 } else if (locals->DSCCLKRequiredMoreThanSupported[i] != false) {
5023 status = DML_FAIL_DSC_CLK_REQUIRED;
5024 } else if (locals->UrgentLatencySupport[i][j] != true) {
5025 status = DML_FAIL_URGENT_LATENCY;
5026 } else if (locals->ROBSupport[i] != true) {
5027 status = DML_FAIL_REORDERING_BUFFER;
5028 } else if (locals->DISPCLK_DPPCLK_Support[i][j] != true) {
5029 status = DML_FAIL_DISPCLK_DPPCLK;
5030 } else if (locals->TotalAvailablePipesSupport[i][j] != true) {
5031 status = DML_FAIL_TOTAL_AVAILABLE_PIPES;
5032 } else if (mode_lib->vba.NumberOfOTGSupport != true) {
5033 status = DML_FAIL_NUM_OTG;
5034 } else if (mode_lib->vba.WritebackModeSupport != true) {
5035 status = DML_FAIL_WRITEBACK_MODE;
5036 } else if (mode_lib->vba.WritebackLatencySupport != true) {
5037 status = DML_FAIL_WRITEBACK_LATENCY;
5038 } else if (mode_lib->vba.WritebackScaleRatioAndTapsSupport != true) {
5039 status = DML_FAIL_WRITEBACK_SCALE_RATIO_TAP;
5040 } else if (mode_lib->vba.CursorSupport != true) {
5041 status = DML_FAIL_CURSOR_SUPPORT;
5042 } else if (mode_lib->vba.PitchSupport != true) {
5043 status = DML_FAIL_PITCH_SUPPORT;
5044 } else if (locals->PrefetchSupported[i][j] != true) {
5045 status = DML_FAIL_PREFETCH_SUPPORT;
5046 } else if (locals->TotalVerticalActiveBandwidthSupport[i] != true) {
5047 status = DML_FAIL_TOTAL_V_ACTIVE_BW;
5048 } else if (locals->VRatioInPrefetchSupported[i][j] != true) {
5049 status = DML_FAIL_V_RATIO_PREFETCH;
5050 } else if (locals->PTEBufferSizeNotExceeded[i][j] != true) {
5051 status = DML_FAIL_PTE_BUFFER_SIZE;
5052 } else if (mode_lib->vba.NonsupportedDSCInputBPC != false) {
5053 status = DML_FAIL_DSC_INPUT_BPC;
5056 if (status == DML_VALIDATION_OK) {
5057 locals->ModeSupport[i][j] = true;
5059 locals->ModeSupport[i][j] = false;
5061 locals->ValidationStatus[i] = status;
5065 unsigned int MaximumMPCCombine = 0;
5066 mode_lib->vba.VoltageLevel = mode_lib->vba.soc.num_states + 1;
5067 for (i = mode_lib->vba.VoltageOverrideLevel; i <= mode_lib->vba.soc.num_states; i++) {
5068 if (locals->ModeSupport[i][0] == true || locals->ModeSupport[i][1] == true) {
5069 mode_lib->vba.VoltageLevel = i;
5070 if (locals->ModeSupport[i][1] == true && (locals->ModeSupport[i][0] == false
5071 || mode_lib->vba.WhenToDoMPCCombine == dm_mpc_always_when_possible)) {
5072 MaximumMPCCombine = 1;
5074 MaximumMPCCombine = 0;
5079 mode_lib->vba.ImmediateFlipSupport =
5080 locals->ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5081 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5082 mode_lib->vba.DPPPerPlane[k] = locals->NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5083 locals->DPPCLK[k] = locals->RequiredDPPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5085 mode_lib->vba.DISPCLK = locals->RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5086 mode_lib->vba.maxMpcComb = MaximumMPCCombine;
5088 mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKPerState[mode_lib->vba.VoltageLevel];
5089 mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
5090 mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
5091 mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
5092 mode_lib->vba.ReturnBW = locals->ReturnBWPerState[mode_lib->vba.VoltageLevel];
5093 mode_lib->vba.FabricAndDRAMBandwidth = locals->FabricAndDRAMBandwidthPerState[mode_lib->vba.VoltageLevel];
5094 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5095 if (mode_lib->vba.BlendingAndTiming[k] == k) {
5096 mode_lib->vba.ODMCombineEnabled[k] =
5097 locals->ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
5099 mode_lib->vba.ODMCombineEnabled[k] = 0;
5101 mode_lib->vba.DSCEnabled[k] =
5102 locals->RequiresDSC[mode_lib->vba.VoltageLevel][k];
5103 mode_lib->vba.OutputBpp[k] =
5104 locals->OutputBppPerState[mode_lib->vba.VoltageLevel][k];