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