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