]> git.ipfire.org Git - thirdparty/linux.git/blame - drivers/gpu/drm/amd/display/dc/dml2/display_mode_core.c
projects / thirdparty / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/amd/display: Fix a handful of spelling mistakes in dml_print output
[thirdparty/linux.git] / drivers / gpu / drm / amd / display / dc / dml2 / display_mode_core.c
CommitLineData
7966f319
QZ		 1/* SPDX-License-Identifier: MIT */
2/*
3 * Copyright 2023 Advanced Micro Devices, Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 */
24
25#include "display_mode_core.h"
26#include "display_mode_util.h"
27#include "display_mode_lib_defines.h"
28
29#include "dml_assert.h"
30
31#define DML2_MAX_FMT_420_BUFFER_WIDTH 4096
32// ---------------------------
33// Declaration Begins
34// ---------------------------
35static void CalculateBytePerPixelAndBlockSizes(
36 enum dml_source_format_class SourcePixelFormat,
37 enum dml_swizzle_mode SurfaceTiling,
38 // Output
39 dml_uint_t *BytePerPixelY,
40 dml_uint_t *BytePerPixelC,
41 dml_float_t *BytePerPixelDETY,
42 dml_float_t *BytePerPixelDETC,
43 dml_uint_t *BlockHeight256BytesY,
44 dml_uint_t *BlockHeight256BytesC,
45 dml_uint_t *BlockWidth256BytesY,
46 dml_uint_t *BlockWidth256BytesC,
47 dml_uint_t *MacroTileHeightY,
48 dml_uint_t *MacroTileHeightC,
49 dml_uint_t *MacroTileWidthY,
50 dml_uint_t *MacroTileWidthC);
51
52static dml_float_t CalculateWriteBackDISPCLK(
53 enum dml_source_format_class WritebackPixelFormat,
54 dml_float_t PixelClock,
55 dml_float_t WritebackHRatio,
56 dml_float_t WritebackVRatio,
57 dml_uint_t WritebackHTaps,
58 dml_uint_t WritebackVTaps,
59 dml_uint_t WritebackSourceWidth,
60 dml_uint_t WritebackDestinationWidth,
61 dml_uint_t HTotal,
62 dml_uint_t WritebackLineBufferSize,
63 dml_float_t DISPCLKDPPCLKVCOSpeed);
64
65static void CalculateVMRowAndSwath(
66 struct display_mode_lib_scratch_st *s,
67 struct CalculateVMRowAndSwath_params_st *p);
68
69static void CalculateOutputLink(
70 dml_float_t PHYCLKPerState,
71 dml_float_t PHYCLKD18PerState,
72 dml_float_t PHYCLKD32PerState,
73 dml_float_t Downspreading,
74 dml_bool_t IsMainSurfaceUsingTheIndicatedTiming,
75 enum dml_output_encoder_class Output,
76 enum dml_output_format_class OutputFormat,
77 dml_uint_t HTotal,
78 dml_uint_t HActive,
79 dml_float_t PixelClockBackEnd,
80 dml_float_t ForcedOutputLinkBPP,
81 dml_uint_t DSCInputBitPerComponent,
82 dml_uint_t NumberOfDSCSlices,
83 dml_float_t AudioSampleRate,
84 dml_uint_t AudioSampleLayout,
85 enum dml_odm_mode ODMModeNoDSC,
86 enum dml_odm_mode ODMModeDSC,
87 enum dml_dsc_enable DSCEnable,
88 dml_uint_t OutputLinkDPLanes,
89 enum dml_output_link_dp_rate OutputLinkDPRate,
90
91 // Output
92 dml_bool_t *RequiresDSC,
93 dml_bool_t *RequiresFEC,
94 dml_float_t *OutBpp,
95 enum dml_output_type_and_rate__type *OutputType,
96 enum dml_output_type_and_rate__rate *OutputRate,
97 dml_uint_t *RequiredSlots);
98
99static void CalculateODMMode(
100 dml_uint_t MaximumPixelsPerLinePerDSCUnit,
101 dml_uint_t HActive,
102 enum dml_output_encoder_class Output,
103 enum dml_output_format_class OutputFormat,
104 enum dml_odm_use_policy ODMUse,
105 dml_float_t StateDispclk,
106 dml_float_t MaxDispclk,
107 dml_bool_t DSCEnable,
108 dml_uint_t TotalNumberOfActiveDPP,
109 dml_uint_t MaxNumDPP,
110 dml_float_t PixelClock,
111 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
112 dml_float_t DISPCLKRampingMargin,
113 dml_float_t DISPCLKDPPCLKVCOSpeed,
114
115 // Output
116 dml_bool_t *TotalAvailablePipesSupport,
117 dml_uint_t *NumberOfDPP,
118 enum dml_odm_mode *ODMMode,
119 dml_float_t *RequiredDISPCLKPerSurface);
120
121static dml_float_t CalculateRequiredDispclk(
122 enum dml_odm_mode ODMMode,
123 dml_float_t PixelClock,
124 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
125 dml_float_t DISPCLKRampingMargin,
126 dml_float_t DISPCLKDPPCLKVCOSpeed,
127 dml_float_t MaxDispclkSingle);
128
129static void CalculateSinglePipeDPPCLKAndSCLThroughput(
130 dml_float_t HRatio,
131 dml_float_t HRatioChroma,
132 dml_float_t VRatio,
133 dml_float_t VRatioChroma,
134 dml_float_t MaxDCHUBToPSCLThroughput,
135 dml_float_t MaxPSCLToLBThroughput,
136 dml_float_t PixelClock,
137 enum dml_source_format_class SourcePixelFormat,
138 dml_uint_t HTaps,
139 dml_uint_t HTapsChroma,
140 dml_uint_t VTaps,
141 dml_uint_t VTapsChroma,
142
143 // Output
144 dml_float_t *PSCL_THROUGHPUT,
145 dml_float_t *PSCL_THROUGHPUT_CHROMA,
146 dml_float_t *DPPCLKUsingSingleDPP);
147
148static void CalculateDPPCLK(
149 dml_uint_t NumberOfActiveSurfaces,
150 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
151 dml_float_t DISPCLKDPPCLKVCOSpeed,
152 dml_float_t DPPCLKUsingSingleDPP[],
153 dml_uint_t DPPPerSurface[],
154
155 // Output
156 dml_float_t *GlobalDPPCLK,
157 dml_float_t Dppclk[]);
158
159static void CalculateMALLUseForStaticScreen(
160 dml_uint_t NumberOfActiveSurfaces,
161 dml_uint_t MALLAllocatedForDCNFinal,
162 enum dml_use_mall_for_static_screen_mode *UseMALLForStaticScreen,
163 dml_uint_t SurfaceSizeInMALL[],
164 dml_bool_t one_row_per_frame_fits_in_buffer[],
165
166 // Output
167 dml_bool_t UsesMALLForStaticScreen[]);
168
169static dml_uint_t dscceComputeDelay(
170 dml_uint_t bpc,
171 dml_float_t BPP,
172 dml_uint_t sliceWidth,
173 dml_uint_t numSlices,
174 enum dml_output_format_class pixelFormat,
175 enum dml_output_encoder_class Output);
176
177static dml_uint_t dscComputeDelay(enum dml_output_format_class pixelFormat,
178 enum dml_output_encoder_class Output);
179
180static dml_bool_t CalculatePrefetchSchedule(struct display_mode_lib_scratch_st *scratch,
181 struct CalculatePrefetchSchedule_params_st *p);
182
183static dml_float_t RoundToDFSGranularity(dml_float_t Clock, dml_bool_t round_up, dml_float_t VCOSpeed);
184
185static void CalculateDCCConfiguration(
186 dml_bool_t DCCEnabled,
187 dml_bool_t DCCProgrammingAssumesScanDirectionUnknown,
188 enum dml_source_format_class SourcePixelFormat,
189 dml_uint_t SurfaceWidthLuma,
190 dml_uint_t SurfaceWidthChroma,
191 dml_uint_t SurfaceHeightLuma,
192 dml_uint_t SurfaceHeightChroma,
193 dml_uint_t nomDETInKByte,
194 dml_uint_t RequestHeight256ByteLuma,
195 dml_uint_t RequestHeight256ByteChroma,
196 enum dml_swizzle_mode TilingFormat,
197 dml_uint_t BytePerPixelY,
198 dml_uint_t BytePerPixelC,
199 dml_float_t BytePerPixelDETY,
200 dml_float_t BytePerPixelDETC,
201 enum dml_rotation_angle SourceScan,
202 // Output
203 dml_uint_t *MaxUncompressedBlockLuma,
204 dml_uint_t *MaxUncompressedBlockChroma,
205 dml_uint_t *MaxCompressedBlockLuma,
206 dml_uint_t *MaxCompressedBlockChroma,
207 dml_uint_t *IndependentBlockLuma,
208 dml_uint_t *IndependentBlockChroma);
209
210static dml_uint_t CalculatePrefetchSourceLines(
211 dml_float_t VRatio,
212 dml_uint_t VTaps,
213 dml_bool_t Interlace,
214 dml_bool_t ProgressiveToInterlaceUnitInOPP,
215 dml_uint_t SwathHeight,
216 enum dml_rotation_angle SourceScan,
217 dml_bool_t ViewportStationary,
218 dml_uint_t SwathWidth,
219 dml_uint_t ViewportHeight,
220 dml_uint_t ViewportXStart,
221 dml_uint_t ViewportYStart,
222
223 // Output
224 dml_uint_t *VInitPreFill,
225 dml_uint_t *MaxNumSwath);
226
227static dml_uint_t CalculateVMAndRowBytes(
228 dml_bool_t ViewportStationary,
229 dml_bool_t DCCEnable,
230 dml_uint_t NumberOfDPPs,
231 dml_uint_t BlockHeight256Bytes,
232 dml_uint_t BlockWidth256Bytes,
233 enum dml_source_format_class SourcePixelFormat,
234 dml_uint_t SurfaceTiling,
235 dml_uint_t BytePerPixel,
236 enum dml_rotation_angle SourceScan,
237 dml_uint_t SwathWidth,
238 dml_uint_t ViewportHeight,
239 dml_uint_t ViewportXStart,
240 dml_uint_t ViewportYStart,
241 dml_bool_t GPUVMEnable,
242 dml_uint_t GPUVMMaxPageTableLevels,
243 dml_uint_t GPUVMMinPageSizeKBytes,
244 dml_uint_t PTEBufferSizeInRequests,
245 dml_uint_t Pitch,
246 dml_uint_t DCCMetaPitch,
247 dml_uint_t MacroTileWidth,
248 dml_uint_t MacroTileHeight,
249
250 // Output
251 dml_uint_t *MetaRowByte,
252 dml_uint_t *PixelPTEBytesPerRow,
253 dml_uint_t *PixelPTEBytesPerRowStorage, // for PTE buffer size check
254 dml_uint_t *dpte_row_width_ub,
255 dml_uint_t *dpte_row_height,
256 dml_uint_t *dpte_row_height_linear,
257 dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
258 dml_uint_t *dpte_row_width_ub_one_row_per_frame,
259 dml_uint_t *dpte_row_height_one_row_per_frame,
260 dml_uint_t *MetaRequestWidth,
261 dml_uint_t *MetaRequestHeight,
262 dml_uint_t *meta_row_width,
263 dml_uint_t *meta_row_height,
264 dml_uint_t *PixelPTEReqWidth,
265 dml_uint_t *PixelPTEReqHeight,
266 dml_uint_t *PTERequestSize,
267 dml_uint_t *DPDE0BytesFrame,
268 dml_uint_t *MetaPTEBytesFrame);
269
270static dml_float_t CalculateTWait(
271 dml_uint_t PrefetchMode,
272 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
273 dml_bool_t SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
274 dml_bool_t DRRDisplay,
275 dml_float_t DRAMClockChangeLatency,
276 dml_float_t FCLKChangeLatency,
277 dml_float_t UrgentLatency,
278 dml_float_t SREnterPlusExitTime);
279
280static void CalculatePrefetchMode(
281 enum dml_prefetch_modes AllowForPStateChangeOrStutterInVBlank,
282 dml_uint_t *MinPrefetchMode,
283 dml_uint_t *MaxPrefetchMode);
284
285static void CalculateRowBandwidth(
286 dml_bool_t GPUVMEnable,
287 enum dml_source_format_class SourcePixelFormat,
288 dml_float_t VRatio,
289 dml_float_t VRatioChroma,
290 dml_bool_t DCCEnable,
291 dml_float_t LineTime,
292 dml_uint_t MetaRowByteLuma,
293 dml_uint_t MetaRowByteChroma,
294 dml_uint_t meta_row_height_luma,
295 dml_uint_t meta_row_height_chroma,
296 dml_uint_t PixelPTEBytesPerRowLuma,
297 dml_uint_t PixelPTEBytesPerRowChroma,
298 dml_uint_t dpte_row_height_luma,
299 dml_uint_t dpte_row_height_chroma,
300 // Output
301 dml_float_t *meta_row_bw,
302 dml_float_t *dpte_row_bw);
303
304static void CalculateFlipSchedule(
305 dml_float_t HostVMInefficiencyFactor,
306 dml_float_t UrgentExtraLatency,
307 dml_float_t UrgentLatency,
308 dml_uint_t GPUVMMaxPageTableLevels,
309 dml_bool_t HostVMEnable,
310 dml_uint_t HostVMMaxNonCachedPageTableLevels,
311 dml_bool_t GPUVMEnable,
312 dml_uint_t HostVMMinPageSize,
313 dml_float_t PDEAndMetaPTEBytesPerFrame,
314 dml_float_t MetaRowBytes,
315 dml_float_t DPTEBytesPerRow,
316 dml_float_t BandwidthAvailableForImmediateFlip,
317 dml_uint_t TotImmediateFlipBytes,
318 enum dml_source_format_class SourcePixelFormat,
319 dml_float_t LineTime,
320 dml_float_t VRatio,
321 dml_float_t VRatioChroma,
322 dml_float_t Tno_bw,
323 dml_bool_t DCCEnable,
324 dml_uint_t dpte_row_height,
325 dml_uint_t meta_row_height,
326 dml_uint_t dpte_row_height_chroma,
327 dml_uint_t meta_row_height_chroma,
328 dml_bool_t use_one_row_for_frame_flip,
329
330 // Output
331 dml_float_t *DestinationLinesToRequestVMInImmediateFlip,
332 dml_float_t *DestinationLinesToRequestRowInImmediateFlip,
333 dml_float_t *final_flip_bw,
334 dml_bool_t *ImmediateFlipSupportedForPipe);
335
336static dml_float_t CalculateWriteBackDelay(
337 enum dml_source_format_class WritebackPixelFormat,
338 dml_float_t WritebackHRatio,
339 dml_float_t WritebackVRatio,
340 dml_uint_t WritebackVTaps,
341 dml_uint_t WritebackDestinationWidth,
342 dml_uint_t WritebackDestinationHeight,
343 dml_uint_t WritebackSourceHeight,
344 dml_uint_t HTotal);
345
346static void CalculateVUpdateAndDynamicMetadataParameters(
347 dml_uint_t MaxInterDCNTileRepeaters,
348 dml_float_t Dppclk,
349 dml_float_t DISPCLK,
350 dml_float_t DCFClkDeepSleep,
351 dml_float_t PixelClock,
352 dml_uint_t HTotal,
353 dml_uint_t VBlank,
354 dml_uint_t DynamicMetadataTransmittedBytes,
355 dml_uint_t DynamicMetadataLinesBeforeActiveRequired,
356 dml_uint_t InterlaceEnable,
357 dml_bool_t ProgressiveToInterlaceUnitInOPP,
358 dml_float_t *TSetup,
359 dml_float_t *Tdmbf,
360 dml_float_t *Tdmec,
361 dml_float_t *Tdmsks,
362 dml_uint_t *VUpdateOffsetPix,
363 dml_uint_t *VUpdateWidthPix,
364 dml_uint_t *VReadyOffsetPix);
365
366static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct dml_display_cfg_st *display_cfg, dml_bool_t ptoi_supported);
367
368static dml_float_t TruncToValidBPP(
369 dml_float_t LinkBitRate,
370 dml_uint_t Lanes,
371 dml_uint_t HTotal,
372 dml_uint_t HActive,
373 dml_float_t PixelClock,
374 dml_float_t DesiredBPP,
375 dml_bool_t DSCEnable,
376 enum dml_output_encoder_class Output,
377 enum dml_output_format_class Format,
378 dml_uint_t DSCInputBitPerComponent,
379 dml_uint_t DSCSlices,
380 dml_uint_t AudioRate,
381 dml_uint_t AudioLayout,
382 enum dml_odm_mode ODMModeNoDSC,
383 enum dml_odm_mode ODMModeDSC,
384 // Output
385 dml_uint_t *RequiredSlotsSingle);
386
387static void CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
388 struct display_mode_lib_scratch_st *s,
389 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *p);
390
391static void CalculateDCFCLKDeepSleep(
392 dml_uint_t NumberOfActiveSurfaces,
393 dml_uint_t BytePerPixelY[],
394 dml_uint_t BytePerPixelC[],
395 dml_float_t VRatio[],
396 dml_float_t VRatioChroma[],
397 dml_uint_t SwathWidthY[],
398 dml_uint_t SwathWidthC[],
399 dml_uint_t DPPPerSurface[],
400 dml_float_t HRatio[],
401 dml_float_t HRatioChroma[],
402 dml_float_t PixelClock[],
403 dml_float_t PSCL_THROUGHPUT[],
404 dml_float_t PSCL_THROUGHPUT_CHROMA[],
405 dml_float_t Dppclk[],
406 dml_float_t ReadBandwidthLuma[],
407 dml_float_t ReadBandwidthChroma[],
408 dml_uint_t ReturnBusWidth,
409
410 // Output
411 dml_float_t *DCFCLKDeepSleep);
412
413static void CalculateUrgentBurstFactor(
414 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
415 dml_uint_t swath_width_luma_ub,
416 dml_uint_t swath_width_chroma_ub,
417 dml_uint_t SwathHeightY,
418 dml_uint_t SwathHeightC,
419 dml_float_t LineTime,
420 dml_float_t UrgentLatency,
421 dml_float_t CursorBufferSize,
422 dml_uint_t CursorWidth,
423 dml_uint_t CursorBPP,
424 dml_float_t VRatio,
425 dml_float_t VRatioC,
426 dml_float_t BytePerPixelInDETY,
427 dml_float_t BytePerPixelInDETC,
428 dml_uint_t DETBufferSizeY,
429 dml_uint_t DETBufferSizeC,
430 // Output
431 dml_float_t *UrgentBurstFactorCursor,
432 dml_float_t *UrgentBurstFactorLuma,
433 dml_float_t *UrgentBurstFactorChroma,
434 dml_bool_t *NotEnoughUrgentLatencyHiding);
435
436static dml_float_t RequiredDTBCLK(
437 dml_bool_t DSCEnable,
438 dml_float_t PixelClock,
439 enum dml_output_format_class OutputFormat,
440 dml_float_t OutputBpp,
441 dml_uint_t DSCSlices,
442 dml_uint_t HTotal,
443 dml_uint_t HActive,
444 dml_uint_t AudioRate,
445 dml_uint_t AudioLayoutSingle);
446
447static void UseMinimumDCFCLK(
448 struct display_mode_lib_scratch_st *scratch,
449 struct UseMinimumDCFCLK_params_st *p);
450
451static void CalculatePixelDeliveryTimes(
452 dml_uint_t NumberOfActiveSurfaces,
453 dml_float_t VRatio[],
454 dml_float_t VRatioChroma[],
455 dml_float_t VRatioPrefetchY[],
456 dml_float_t VRatioPrefetchC[],
457 dml_uint_t swath_width_luma_ub[],
458 dml_uint_t swath_width_chroma_ub[],
459 dml_uint_t DPPPerSurface[],
460 dml_float_t HRatio[],
461 dml_float_t HRatioChroma[],
462 dml_float_t PixelClock[],
463 dml_float_t PSCL_THROUGHPUT[],
464 dml_float_t PSCL_THROUGHPUT_CHROMA[],
465 dml_float_t Dppclk[],
466 dml_uint_t BytePerPixelC[],
467 enum dml_rotation_angle SourceScan[],
468 dml_uint_t NumberOfCursors[],
469 dml_uint_t CursorWidth[],
470 dml_uint_t CursorBPP[],
471 dml_uint_t BlockWidth256BytesY[],
472 dml_uint_t BlockHeight256BytesY[],
473 dml_uint_t BlockWidth256BytesC[],
474 dml_uint_t BlockHeight256BytesC[],
475
476 // Output
477 dml_float_t DisplayPipeLineDeliveryTimeLuma[],
478 dml_float_t DisplayPipeLineDeliveryTimeChroma[],
479 dml_float_t DisplayPipeLineDeliveryTimeLumaPrefetch[],
480 dml_float_t DisplayPipeLineDeliveryTimeChromaPrefetch[],
481 dml_float_t DisplayPipeRequestDeliveryTimeLuma[],
482 dml_float_t DisplayPipeRequestDeliveryTimeChroma[],
483 dml_float_t DisplayPipeRequestDeliveryTimeLumaPrefetch[],
484 dml_float_t DisplayPipeRequestDeliveryTimeChromaPrefetch[],
485 dml_float_t CursorRequestDeliveryTime[],
486 dml_float_t CursorRequestDeliveryTimePrefetch[]);
487
488static void CalculateMetaAndPTETimes(
489 dml_bool_t use_one_row_for_frame[],
490 dml_uint_t NumberOfActiveSurfaces,
491 dml_bool_t GPUVMEnable,
492 dml_uint_t MetaChunkSize,
493 dml_uint_t MinMetaChunkSizeBytes,
494 dml_uint_t HTotal[],
495 dml_float_t VRatio[],
496 dml_float_t VRatioChroma[],
497 dml_float_t DestinationLinesToRequestRowInVBlank[],
498 dml_float_t DestinationLinesToRequestRowInImmediateFlip[],
499 dml_bool_t DCCEnable[],
500 dml_float_t PixelClock[],
501 dml_uint_t BytePerPixelY[],
502 dml_uint_t BytePerPixelC[],
503 enum dml_rotation_angle SourceScan[],
504 dml_uint_t dpte_row_height[],
505 dml_uint_t dpte_row_height_chroma[],
506 dml_uint_t meta_row_width[],
507 dml_uint_t meta_row_width_chroma[],
508 dml_uint_t meta_row_height[],
509 dml_uint_t meta_row_height_chroma[],
510 dml_uint_t meta_req_width[],
511 dml_uint_t meta_req_width_chroma[],
512 dml_uint_t meta_req_height[],
513 dml_uint_t meta_req_height_chroma[],
514 dml_uint_t dpte_group_bytes[],
515 dml_uint_t PTERequestSizeY[],
516 dml_uint_t PTERequestSizeC[],
517 dml_uint_t PixelPTEReqWidthY[],
518 dml_uint_t PixelPTEReqHeightY[],
519 dml_uint_t PixelPTEReqWidthC[],
520 dml_uint_t PixelPTEReqHeightC[],
521 dml_uint_t dpte_row_width_luma_ub[],
522 dml_uint_t dpte_row_width_chroma_ub[],
523
524 // Output
525 dml_float_t DST_Y_PER_PTE_ROW_NOM_L[],
526 dml_float_t DST_Y_PER_PTE_ROW_NOM_C[],
527 dml_float_t DST_Y_PER_META_ROW_NOM_L[],
528 dml_float_t DST_Y_PER_META_ROW_NOM_C[],
529 dml_float_t TimePerMetaChunkNominal[],
530 dml_float_t TimePerChromaMetaChunkNominal[],
531 dml_float_t TimePerMetaChunkVBlank[],
532 dml_float_t TimePerChromaMetaChunkVBlank[],
533 dml_float_t TimePerMetaChunkFlip[],
534 dml_float_t TimePerChromaMetaChunkFlip[],
535 dml_float_t time_per_pte_group_nom_luma[],
536 dml_float_t time_per_pte_group_vblank_luma[],
537 dml_float_t time_per_pte_group_flip_luma[],
538 dml_float_t time_per_pte_group_nom_chroma[],
539 dml_float_t time_per_pte_group_vblank_chroma[],
540 dml_float_t time_per_pte_group_flip_chroma[]);
541
542static void CalculateVMGroupAndRequestTimes(
543 dml_uint_t NumberOfActiveSurfaces,
544 dml_bool_t GPUVMEnable,
545 dml_uint_t GPUVMMaxPageTableLevels,
546 dml_uint_t HTotal[],
547 dml_uint_t BytePerPixelC[],
548 dml_float_t DestinationLinesToRequestVMInVBlank[],
549 dml_float_t DestinationLinesToRequestVMInImmediateFlip[],
550 dml_bool_t DCCEnable[],
551 dml_float_t PixelClock[],
552 dml_uint_t dpte_row_width_luma_ub[],
553 dml_uint_t dpte_row_width_chroma_ub[],
554 dml_uint_t vm_group_bytes[],
555 dml_uint_t dpde0_bytes_per_frame_ub_l[],
556 dml_uint_t dpde0_bytes_per_frame_ub_c[],
557 dml_uint_t meta_pte_bytes_per_frame_ub_l[],
558 dml_uint_t meta_pte_bytes_per_frame_ub_c[],
559
560 // Output
561 dml_float_t TimePerVMGroupVBlank[],
562 dml_float_t TimePerVMGroupFlip[],
563 dml_float_t TimePerVMRequestVBlank[],
564 dml_float_t TimePerVMRequestFlip[]);
565
566static void CalculateStutterEfficiency(
567 struct display_mode_lib_scratch_st *scratch,
568 struct CalculateStutterEfficiency_params_st *p);
569
570static void CalculateSwathAndDETConfiguration(
571 struct display_mode_lib_scratch_st *scratch,
572 struct CalculateSwathAndDETConfiguration_params_st *p);
573
574static void CalculateSwathWidth(
575 dml_bool_t ForceSingleDPP,
576 dml_uint_t NumberOfActiveSurfaces,
577 enum dml_source_format_class SourcePixelFormat[],
578 enum dml_rotation_angle SourceScan[],
579 dml_bool_t ViewportStationary[],
580 dml_uint_t ViewportWidth[],
581 dml_uint_t ViewportHeight[],
582 dml_uint_t ViewportXStart[],
583 dml_uint_t ViewportYStart[],
584 dml_uint_t ViewportXStartC[],
585 dml_uint_t ViewportYStartC[],
586 dml_uint_t SurfaceWidthY[],
587 dml_uint_t SurfaceWidthC[],
588 dml_uint_t SurfaceHeightY[],
589 dml_uint_t SurfaceHeightC[],
590 enum dml_odm_mode ODMMode[],
591 dml_uint_t BytePerPixY[],
592 dml_uint_t BytePerPixC[],
593 dml_uint_t Read256BytesBlockHeightY[],
594 dml_uint_t Read256BytesBlockHeightC[],
595 dml_uint_t Read256BytesBlockWidthY[],
596 dml_uint_t Read256BytesBlockWidthC[],
597 dml_uint_t BlendingAndTiming[],
598 dml_uint_t HActive[],
599 dml_float_t HRatio[],
600 dml_uint_t DPPPerSurface[],
601
602 // Output
603 dml_uint_t SwathWidthSingleDPPY[],
604 dml_uint_t SwathWidthSingleDPPC[],
605 dml_uint_t SwathWidthY[],
606 dml_uint_t SwathWidthC[],
607 dml_uint_t MaximumSwathHeightY[],
608 dml_uint_t MaximumSwathHeightC[],
609 dml_uint_t swath_width_luma_ub[],
610 dml_uint_t swath_width_chroma_ub[]);
611
612static dml_float_t CalculateExtraLatency(
613 dml_uint_t RoundTripPingLatencyCycles,
614 dml_uint_t ReorderingBytes,
615 dml_float_t DCFCLK,
616 dml_uint_t TotalNumberOfActiveDPP,
617 dml_uint_t PixelChunkSizeInKByte,
618 dml_uint_t TotalNumberOfDCCActiveDPP,
619 dml_uint_t MetaChunkSize,
620 dml_float_t ReturnBW,
621 dml_bool_t GPUVMEnable,
622 dml_bool_t HostVMEnable,
623 dml_uint_t NumberOfActiveSurfaces,
624 dml_uint_t NumberOfDPP[],
625 dml_uint_t dpte_group_bytes[],
626 dml_float_t HostVMInefficiencyFactor,
627 dml_uint_t HostVMMinPageSize,
628 dml_uint_t HostVMMaxNonCachedPageTableLevels);
629
630static dml_uint_t CalculateExtraLatencyBytes(
631 dml_uint_t ReorderingBytes,
632 dml_uint_t TotalNumberOfActiveDPP,
633 dml_uint_t PixelChunkSizeInKByte,
634 dml_uint_t TotalNumberOfDCCActiveDPP,
635 dml_uint_t MetaChunkSize,
636 dml_bool_t GPUVMEnable,
637 dml_bool_t HostVMEnable,
638 dml_uint_t NumberOfActiveSurfaces,
639 dml_uint_t NumberOfDPP[],
640 dml_uint_t dpte_group_bytes[],
641 dml_float_t HostVMInefficiencyFactor,
642 dml_uint_t HostVMMinPageSize,
643 dml_uint_t HostVMMaxNonCachedPageTableLevels);
644
645static dml_float_t CalculateUrgentLatency(
646 dml_float_t UrgentLatencyPixelDataOnly,
647 dml_float_t UrgentLatencyPixelMixedWithVMData,
648 dml_float_t UrgentLatencyVMDataOnly,
649 dml_bool_t DoUrgentLatencyAdjustment,
650 dml_float_t UrgentLatencyAdjustmentFabricClockComponent,
651 dml_float_t UrgentLatencyAdjustmentFabricClockReference,
652 dml_float_t FabricClockSingle);
653
654static dml_bool_t UnboundedRequest(
655 enum dml_unbounded_requesting_policy UseUnboundedRequestingFinal,
656 dml_uint_t TotalNumberOfActiveDPP,
657 dml_bool_t NoChromaOrLinear,
658 enum dml_output_encoder_class Output);
659
660static void CalculateSurfaceSizeInMall(
661 dml_uint_t NumberOfActiveSurfaces,
662 dml_uint_t MALLAllocatedForDCN,
663 enum dml_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
664 dml_bool_t DCCEnable[],
665 dml_bool_t ViewportStationary[],
666 dml_uint_t ViewportXStartY[],
667 dml_uint_t ViewportYStartY[],
668 dml_uint_t ViewportXStartC[],
669 dml_uint_t ViewportYStartC[],
670 dml_uint_t ViewportWidthY[],
671 dml_uint_t ViewportHeightY[],
672 dml_uint_t BytesPerPixelY[],
673 dml_uint_t ViewportWidthC[],
674 dml_uint_t ViewportHeightC[],
675 dml_uint_t BytesPerPixelC[],
676 dml_uint_t SurfaceWidthY[],
677 dml_uint_t SurfaceWidthC[],
678 dml_uint_t SurfaceHeightY[],
679 dml_uint_t SurfaceHeightC[],
680 dml_uint_t Read256BytesBlockWidthY[],
681 dml_uint_t Read256BytesBlockWidthC[],
682 dml_uint_t Read256BytesBlockHeightY[],
683 dml_uint_t Read256BytesBlockHeightC[],
684 dml_uint_t ReadBlockWidthY[],
685 dml_uint_t ReadBlockWidthC[],
686 dml_uint_t ReadBlockHeightY[],
687 dml_uint_t ReadBlockHeightC[],
688
689 // Output
690 dml_uint_t SurfaceSizeInMALL[],
691 dml_bool_t *ExceededMALLSize);
692
693static void CalculateDETBufferSize(
694 dml_uint_t DETSizeOverride[],
695 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
696 dml_bool_t ForceSingleDPP,
697 dml_uint_t NumberOfActiveSurfaces,
698 dml_bool_t UnboundedRequestEnabled,
699 dml_uint_t nomDETInKByte,
700 dml_uint_t MaxTotalDETInKByte,
701 dml_uint_t ConfigReturnBufferSizeInKByte,
702 dml_uint_t MinCompressedBufferSizeInKByte,
703 dml_uint_t ConfigReturnBufferSegmentSizeInkByte,
704 dml_uint_t CompressedBufferSegmentSizeInkByteFinal,
705 enum dml_source_format_class SourcePixelFormat[],
706 dml_float_t ReadBandwidthLuma[],
707 dml_float_t ReadBandwidthChroma[],
708 dml_uint_t RotesY[],
709 dml_uint_t RoundedUpMaxSwathSizeBytesC[],
710 dml_uint_t DPPPerSurface[],
711 // Output
712 dml_uint_t DETBufferSizeInKByte[],
713 dml_uint_t *CompressedBufferSizeInkByte);
714
715static void CalculateMaxDETAndMinCompressedBufferSize(
716 dml_uint_t ConfigReturnBufferSizeInKByte,
717 dml_uint_t ConfigReturnBufferSegmentSizeInKByte,
718 dml_uint_t ROBBufferSizeInKByte,
719 dml_uint_t MaxNumDPP,
720 dml_bool_t nomDETInKByteOverrideEnable,
721 dml_uint_t nomDETInKByteOverrideValue,
722
723 // Output
724 dml_uint_t *MaxTotalDETInKByte,
725 dml_uint_t *nomDETInKByte,
726 dml_uint_t *MinCompressedBufferSizeInKByte);
727
728static dml_uint_t DSCDelayRequirement(
729 dml_bool_t DSCEnabled,
730 enum dml_odm_mode ODMMode,
731 dml_uint_t DSCInputBitPerComponent,
732 dml_float_t OutputBpp,
733 dml_uint_t HActive,
734 dml_uint_t HTotal,
735 dml_uint_t NumberOfDSCSlices,
736 enum dml_output_format_class OutputFormat,
737 enum dml_output_encoder_class Output,
738 dml_float_t PixelClock,
739 dml_float_t PixelClockBackEnd);
740
741static dml_bool_t CalculateVActiveBandwithSupport(
742 dml_uint_t NumberOfActiveSurfaces,
743 dml_float_t ReturnBW,
744 dml_bool_t NotUrgentLatencyHiding[],
745 dml_float_t ReadBandwidthLuma[],
746 dml_float_t ReadBandwidthChroma[],
747 dml_float_t cursor_bw[],
748 dml_float_t meta_row_bandwidth[],
749 dml_float_t dpte_row_bandwidth[],
750 dml_uint_t NumberOfDPP[],
751 dml_float_t UrgentBurstFactorLuma[],
752 dml_float_t UrgentBurstFactorChroma[],
753 dml_float_t UrgentBurstFactorCursor[]);
754
755static void CalculatePrefetchBandwithSupport(
756 dml_uint_t NumberOfActiveSurfaces,
757 dml_float_t ReturnBW,
758 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
759 dml_bool_t NotUrgentLatencyHiding[],
760 dml_float_t ReadBandwidthLuma[],
761 dml_float_t ReadBandwidthChroma[],
762 dml_float_t PrefetchBandwidthLuma[],
763 dml_float_t PrefetchBandwidthChroma[],
764 dml_float_t cursor_bw[],
765 dml_float_t meta_row_bandwidth[],
766 dml_float_t dpte_row_bandwidth[],
767 dml_float_t cursor_bw_pre[],
768 dml_float_t prefetch_vmrow_bw[],
769 dml_uint_t NumberOfDPP[],
770 dml_float_t UrgentBurstFactorLuma[],
771 dml_float_t UrgentBurstFactorChroma[],
772 dml_float_t UrgentBurstFactorCursor[],
773 dml_float_t UrgentBurstFactorLumaPre[],
774 dml_float_t UrgentBurstFactorChromaPre[],
775 dml_float_t UrgentBurstFactorCursorPre[],
776
777 // Output
778 dml_float_t *PrefetchBandwidth,
779 dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch,
780 dml_float_t *FractionOfUrgentBandwidth,
781 dml_bool_t *PrefetchBandwidthSupport);
782
783static dml_float_t CalculateBandwidthAvailableForImmediateFlip(
784 dml_uint_t NumberOfActiveSurfaces,
785 dml_float_t ReturnBW,
786 dml_float_t ReadBandwidthLuma[],
787 dml_float_t ReadBandwidthChroma[],
788 dml_float_t PrefetchBandwidthLuma[],
789 dml_float_t PrefetchBandwidthChroma[],
790 dml_float_t cursor_bw[],
791 dml_float_t cursor_bw_pre[],
792 dml_uint_t NumberOfDPP[],
793 dml_float_t UrgentBurstFactorLuma[],
794 dml_float_t UrgentBurstFactorChroma[],
795 dml_float_t UrgentBurstFactorCursor[],
796 dml_float_t UrgentBurstFactorLumaPre[],
797 dml_float_t UrgentBurstFactorChromaPre[],
798 dml_float_t UrgentBurstFactorCursorPre[]);
799
800static void CalculateImmediateFlipBandwithSupport(
801 dml_uint_t NumberOfActiveSurfaces,
802 dml_float_t ReturnBW,
803 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
804 enum dml_immediate_flip_requirement ImmediateFlipRequirement[],
805 dml_float_t final_flip_bw[],
806 dml_float_t ReadBandwidthLuma[],
807 dml_float_t ReadBandwidthChroma[],
808 dml_float_t PrefetchBandwidthLuma[],
809 dml_float_t PrefetchBandwidthChroma[],
810 dml_float_t cursor_bw[],
811 dml_float_t meta_row_bandwidth[],
812 dml_float_t dpte_row_bandwidth[],
813 dml_float_t cursor_bw_pre[],
814 dml_float_t prefetch_vmrow_bw[],
815 dml_uint_t NumberOfDPP[],
816 dml_float_t UrgentBurstFactorLuma[],
817 dml_float_t UrgentBurstFactorChroma[],
818 dml_float_t UrgentBurstFactorCursor[],
819 dml_float_t UrgentBurstFactorLumaPre[],
820 dml_float_t UrgentBurstFactorChromaPre[],
821 dml_float_t UrgentBurstFactorCursorPre[],
822
823 // Output
824 dml_float_t *TotalBandwidth,
825 dml_float_t *TotalBandwidthNotIncludingMALLPrefetch,
826 dml_float_t *FractionOfUrgentBandwidth,
827 dml_bool_t *ImmediateFlipBandwidthSupport);
828
829// ---------------------------
830// Declaration Ends
831// ---------------------------
832
833static dml_uint_t dscceComputeDelay(
834 dml_uint_t bpc,
835 dml_float_t BPP,
836 dml_uint_t sliceWidth,
837 dml_uint_t numSlices,
838 enum dml_output_format_class pixelFormat,
839 enum dml_output_encoder_class Output)
840{
841 // valid bpc = source bits per component in the set of {8, 10, 12}
842 // valid bpp = increments of 1/16 of a bit
843 // min = 6/7/8 in N420/N422/444, respectively
844 // max = such that compression is 1:1
845 //valid sliceWidth = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
846 //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
847 //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
848
849 // fixed value
850 dml_uint_t rcModelSize = 8192;
851
852 // N422/N420 operate at 2 pixels per clock
853 dml_uint_t pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, L,
854 Delay, pixels;
855
856 if (pixelFormat == dml_420)
857 pixelsPerClock = 2;
858 // #all other modes operate at 1 pixel per clock
859 else if (pixelFormat == dml_444)
860 pixelsPerClock = 1;
861 else if (pixelFormat == dml_n422)
862 pixelsPerClock = 2;
863 else
864 pixelsPerClock = 1;
865
866 //initial transmit delay as per PPS
867 initalXmitDelay = (dml_uint_t)(dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock, 1));
868
869 //compute ssm delay
870 if (bpc == 8)
871 D = 81;
872 else if (bpc == 10)
873 D = 89;
874 else
875 D = 113;
876
877 //divide by pixel per cycle to compute slice width as seen by DSC
878 w = sliceWidth / pixelsPerClock;
879
880 //422 mode has an additional cycle of delay
881 if (pixelFormat == dml_420 || pixelFormat == dml_444 || pixelFormat == dml_n422)
882 s = 0;
883 else
884 s = 1;
885
886 //main calculation for the dscce
887 ix = initalXmitDelay + 45;
888 wx = (w + 2) / 3;
889 p = 3 * wx - w;
890 l0 = ix / w;
891 a = ix + p * l0;
892 ax = (a + 2) / 3 + D + 6 + 1;
893 L = (ax + wx - 1) / wx;
894 if ((ix % w) == 0 && p != 0)
895 lstall = 1;
896 else
897 lstall = 0;
898 Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22;
899
900 //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
901 pixels = Delay * 3 * pixelsPerClock;
902
903#ifdef __DML_VBA_DEBUG__
904 dml_print("DML::%s: bpc: %u\n", __func__, bpc);
905 dml_print("DML::%s: BPP: %f\n", __func__, BPP);
906 dml_print("DML::%s: sliceWidth: %u\n", __func__, sliceWidth);
907 dml_print("DML::%s: numSlices: %u\n", __func__, numSlices);
908 dml_print("DML::%s: pixelFormat: %u\n", __func__, pixelFormat);
909 dml_print("DML::%s: Output: %u\n", __func__, Output);
910 dml_print("DML::%s: pixels: %u\n", __func__, pixels);
911#endif
912 return pixels;
913}
914
915static dml_uint_t dscComputeDelay(enum dml_output_format_class pixelFormat, enum dml_output_encoder_class Output)
916{
917 dml_uint_t Delay = 0;
918
919 if (pixelFormat == dml_420) {
920 // sfr
921 Delay = Delay + 2;
922 // dsccif
923 Delay = Delay + 0;
924 // dscc - input deserializer
925 Delay = Delay + 3;
926 // dscc gets pixels every other cycle
927 Delay = Delay + 2;
928 // dscc - input cdc fifo
929 Delay = Delay + 12;
930 // dscc gets pixels every other cycle
931 Delay = Delay + 13;
932 // dscc - cdc uncertainty
933 Delay = Delay + 2;
934 // dscc - output cdc fifo
935 Delay = Delay + 7;
936 // dscc gets pixels every other cycle
937 Delay = Delay + 3;
938 // dscc - cdc uncertainty
939 Delay = Delay + 2;
940 // dscc - output serializer
941 Delay = Delay + 1;
942 // sft
943 Delay = Delay + 1;
944 } else if (pixelFormat == dml_n422) {
945 // sfr
946 Delay = Delay + 2;
947 // dsccif
948 Delay = Delay + 1;
949 // dscc - input deserializer
950 Delay = Delay + 5;
951 // dscc - input cdc fifo
952 Delay = Delay + 25;
953 // dscc - cdc uncertainty
954 Delay = Delay + 2;
955 // dscc - output cdc fifo
956 Delay = Delay + 10;
957 // dscc - cdc uncertainty
958 Delay = Delay + 2;
959 // dscc - output serializer
960 Delay = Delay + 1;
961 // sft
962 Delay = Delay + 1;
963 } else {
964 // sfr
965 Delay = Delay + 2;
966 // dsccif
967 Delay = Delay + 0;
968 // dscc - input deserializer
969 Delay = Delay + 3;
970 // dscc - input cdc fifo
971 Delay = Delay + 12;
972 // dscc - cdc uncertainty
973 Delay = Delay + 2;
974 // dscc - output cdc fifo
975 Delay = Delay + 7;
976 // dscc - output serializer
977 Delay = Delay + 1;
978 // dscc - cdc uncertainty
979 Delay = Delay + 2;
980 // sft
981 Delay = Delay + 1;
982 }
983#ifdef __DML_VBA_DEBUG__
984 dml_print("DML::%s: pixelFormat = %u\n", __func__, pixelFormat);
985 dml_print("DML::%s: Delay = %u\n", __func__, Delay);
986#endif
987
988 return Delay;
989}
990
991static dml_bool_t CalculatePrefetchSchedule(struct display_mode_lib_scratch_st *scratch,
992 struct CalculatePrefetchSchedule_params_st *p)
993{
994 struct CalculatePrefetchSchedule_locals_st *s = &scratch->CalculatePrefetchSchedule_locals;
995
996 s->MyError = false;
997 s->DPPCycles = 0;
998 s->DISPCLKCycles = 0;
999 s->DSTTotalPixelsAfterScaler = 0.0;
1000 s->LineTime = 0.0;
1001 s->dst_y_prefetch_equ = 0.0;
1002 s->prefetch_bw_oto = 0.0;
1003 s->Tvm_oto = 0.0;
1004 s->Tr0_oto = 0.0;
1005 s->Tvm_oto_lines = 0.0;
1006 s->Tr0_oto_lines = 0.0;
1007 s->dst_y_prefetch_oto = 0.0;
1008 s->TimeForFetchingMetaPTE = 0.0;
1009 s->TimeForFetchingRowInVBlank = 0.0;
1010 s->LinesToRequestPrefetchPixelData = 0.0;
1011 s->HostVMDynamicLevelsTrips = 0;
1012 s->trip_to_mem = 0.0;
1013 s->Tvm_trips = 0.0;
1014 s->Tr0_trips = 0.0;
1015 s->Tvm_trips_rounded = 0.0;
1016 s->Tr0_trips_rounded = 0.0;
1017 s->max_Tsw = 0.0;
1018 s->Lsw_oto = 0.0;
1019 s->Tpre_rounded = 0.0;
1020 s->prefetch_bw_equ = 0.0;
1021 s->Tvm_equ = 0.0;
1022 s->Tr0_equ = 0.0;
1023 s->Tdmbf = 0.0;
1024 s->Tdmec = 0.0;
1025 s->Tdmsks = 0.0;
1026 s->prefetch_sw_bytes = 0.0;
1027 s->prefetch_bw_pr = 0.0;
1028 s->bytes_pp = 0.0;
1029 s->dep_bytes = 0.0;
1030 s->min_Lsw_oto = 0.0;
1031 s->Tsw_est1 = 0.0;
1032 s->Tsw_est3 = 0.0;
1033
1034 if (p->GPUVMEnable == true && p->HostVMEnable == true) {
1035 s->HostVMDynamicLevelsTrips = p->HostVMMaxNonCachedPageTableLevels;
1036 } else {
1037 s->HostVMDynamicLevelsTrips = 0;
1038 }
1039#ifdef __DML_VBA_DEBUG__
1040 dml_print("DML::%s: GPUVMEnable = %u\n", __func__, p->GPUVMEnable);
1041 dml_print("DML::%s: GPUVMPageTableLevels = %u\n", __func__, p->GPUVMPageTableLevels);
1042 dml_print("DML::%s: DCCEnable = %u\n", __func__, p->myPipe->DCCEnable);
1043 dml_print("DML::%s: VStartup = %u\n", __func__, p->VStartup);
1044 dml_print("DML::%s: MaxVStartup = %u\n", __func__, p->MaxVStartup);
1045 dml_print("DML::%s: HostVMEnable = %u\n", __func__, p->HostVMEnable);
1046 dml_print("DML::%s: HostVMInefficiencyFactor= %f\n", __func__, p->HostVMInefficiencyFactor);
1047 dml_print("DML::%s: myPipe->Dppclk = %f\n", __func__, p->myPipe->Dppclk);
1048#endif
1049 CalculateVUpdateAndDynamicMetadataParameters(
1050 p->MaxInterDCNTileRepeaters,
1051 p->myPipe->Dppclk,
1052 p->myPipe->Dispclk,
1053 p->myPipe->DCFClkDeepSleep,
1054 p->myPipe->PixelClock,
1055 p->myPipe->HTotal,
1056 p->myPipe->VBlank,
1057 p->DynamicMetadataTransmittedBytes,
1058 p->DynamicMetadataLinesBeforeActiveRequired,
1059 p->myPipe->InterlaceEnable,
1060 p->myPipe->ProgressiveToInterlaceUnitInOPP,
1061 p->TSetup,
1062
1063 // Output
1064 &s->Tdmbf,
1065 &s->Tdmec,
1066 &s->Tdmsks,
1067 p->VUpdateOffsetPix,
1068 p->VUpdateWidthPix,
1069 p->VReadyOffsetPix);
1070
1071 s->LineTime = p->myPipe->HTotal / p->myPipe->PixelClock;
1072 s->trip_to_mem = p->UrgentLatency;
1073 s->Tvm_trips = p->UrgentExtraLatency + s->trip_to_mem * (p->GPUVMPageTableLevels * (s->HostVMDynamicLevelsTrips + 1) - 1);
1074
1075 if (p->DynamicMetadataVMEnabled == true) {
1076 *p->Tdmdl = p->TWait + s->Tvm_trips + s->trip_to_mem;
1077 } else {
1078 *p->Tdmdl = p->TWait + p->UrgentExtraLatency;
1079 }
1080
1081#ifdef __DML_VBA_ALLOW_DELTA__
1082 if (DynamicMetadataEnable == false) {
1083 *Tdmdl = 0.0;
1084 }
1085#endif
1086
1087 if (p->DynamicMetadataEnable == true) {
1088 if (p->VStartup * s->LineTime < *p->TSetup + *p->Tdmdl + s->Tdmbf + s->Tdmec + s->Tdmsks) {
1089 *p->NotEnoughTimeForDynamicMetadata = true;
1090 dml_print("DML::%s: Not Enough Time for Dynamic Meta!\n", __func__);
1091 dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, s->Tdmbf);
1092 dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, s->Tdmec);
1093 dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", __func__, s->Tdmsks);
1094 dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", __func__, *p->Tdmdl);
1095 } else {
1096 *p->NotEnoughTimeForDynamicMetadata = false;
1097 }
1098 } else {
1099 *p->NotEnoughTimeForDynamicMetadata = false;
1100 }
1101
1102 *p->Tdmdl_vm = (p->DynamicMetadataEnable == true && p->DynamicMetadataVMEnabled == true && p->GPUVMEnable == true ? p->TWait + s->Tvm_trips : 0);
1103
1104 if (p->myPipe->ScalerEnabled)
1105 s->DPPCycles = (dml_uint_t)(p->DPPCLKDelaySubtotalPlusCNVCFormater + p->DPPCLKDelaySCL);
1106 else
1107 s->DPPCycles = (dml_uint_t)(p->DPPCLKDelaySubtotalPlusCNVCFormater + p->DPPCLKDelaySCLLBOnly);
1108
1109 s->DPPCycles = (dml_uint_t)(s->DPPCycles + p->myPipe->NumberOfCursors * p->DPPCLKDelayCNVCCursor);
1110
1111 s->DISPCLKCycles = (dml_uint_t)p->DISPCLKDelaySubtotal;
1112
1113 if (p->myPipe->Dppclk == 0.0 || p->myPipe->Dispclk == 0.0)
1114 return true;
1115
1116 *p->DSTXAfterScaler = (dml_uint_t) dml_round(s->DPPCycles * p->myPipe->PixelClock / p->myPipe->Dppclk + s->DISPCLKCycles * p->myPipe->PixelClock / p->myPipe->Dispclk + p->DSCDelay, 1.0);
1117 *p->DSTXAfterScaler = (dml_uint_t) dml_round(*p->DSTXAfterScaler + (p->myPipe->ODMMode != dml_odm_mode_bypass ? 18 : 0) + (p->myPipe->DPPPerSurface - 1) * p->DPP_RECOUT_WIDTH +
1118 ((p->myPipe->ODMMode == dml_odm_mode_split_1to2 || p->myPipe->ODMMode == dml_odm_mode_mso_1to2) ? (dml_float_t)p->myPipe->HActive / 2.0 : 0) +
1119 ((p->myPipe->ODMMode == dml_odm_mode_mso_1to4) ? (dml_float_t)p->myPipe->HActive * 3.0 / 4.0 : 0), 1.0);
1120
1121#ifdef __DML_VBA_DEBUG__
1122 dml_print("DML::%s: DPPCycles = %u\n", __func__, s->DPPCycles);
1123 dml_print("DML::%s: PixelClock = %f\n", __func__, p->myPipe->PixelClock);
1124 dml_print("DML::%s: Dppclk = %f\n", __func__, p->myPipe->Dppclk);
1125 dml_print("DML::%s: DISPCLKCycles = %u\n", __func__, s->DISPCLKCycles);
1126 dml_print("DML::%s: DISPCLK = %f\n", __func__, p->myPipe->Dispclk);
1127 dml_print("DML::%s: DSCDelay = %u\n", __func__, p->DSCDelay);
1128 dml_print("DML::%s: ODMMode = %u\n", __func__, p->myPipe->ODMMode);
1129 dml_print("DML::%s: DPP_RECOUT_WIDTH = %u\n", __func__, p->DPP_RECOUT_WIDTH);
1130 dml_print("DML::%s: DSTXAfterScaler = %u\n", __func__, *p->DSTXAfterScaler);
1131#endif
1132
1133 if (p->OutputFormat == dml_420 || (p->myPipe->InterlaceEnable && p->myPipe->ProgressiveToInterlaceUnitInOPP))
1134 *p->DSTYAfterScaler = 1;
1135 else
1136 *p->DSTYAfterScaler = 0;
1137
1138 s->DSTTotalPixelsAfterScaler = *p->DSTYAfterScaler * p->myPipe->HTotal + *p->DSTXAfterScaler;
1139 *p->DSTYAfterScaler = (dml_uint_t)(dml_floor(s->DSTTotalPixelsAfterScaler / p->myPipe->HTotal, 1));
1140 *p->DSTXAfterScaler = (dml_uint_t)(s->DSTTotalPixelsAfterScaler - ((dml_float_t) (*p->DSTYAfterScaler * p->myPipe->HTotal)));
1141#ifdef __DML_VBA_DEBUG__
1142 dml_print("DML::%s: DSTXAfterScaler = %u (final)\n", __func__, *p->DSTXAfterScaler);
1143 dml_print("DML::%s: DSTYAfterScaler = %u (final)\n", __func__, *p->DSTYAfterScaler);
1144#endif
1145
1146 s->MyError = false;
1147
1148 s->Tr0_trips = s->trip_to_mem * (s->HostVMDynamicLevelsTrips + 1);
1149
1150 if (p->GPUVMEnable == true) {
1151 s->Tvm_trips_rounded = dml_ceil(4.0 * s->Tvm_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1152 s->Tr0_trips_rounded = dml_ceil(4.0 * s->Tr0_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1153 if (p->GPUVMPageTableLevels >= 3) {
1154 *p->Tno_bw = p->UrgentExtraLatency + s->trip_to_mem * (dml_float_t) ((p->GPUVMPageTableLevels - 2) * (s->HostVMDynamicLevelsTrips + 1) - 1);
1155 } else if (p->GPUVMPageTableLevels == 1 && p->myPipe->DCCEnable != true) {
1156 s->Tr0_trips_rounded = dml_ceil(4.0 * p->UrgentExtraLatency / s->LineTime, 1.0) / 4.0 * s->LineTime;
1157 *p->Tno_bw = p->UrgentExtraLatency;
1158 } else {
1159 *p->Tno_bw = 0;
1160 }
1161 } else if (p->myPipe->DCCEnable == true) {
1162 s->Tvm_trips_rounded = s->LineTime / 4.0;
1163 s->Tr0_trips_rounded = dml_ceil(4.0 * s->Tr0_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1164 *p->Tno_bw = 0;
1165 } else {
1166 s->Tvm_trips_rounded = s->LineTime / 4.0;
1167 s->Tr0_trips_rounded = s->LineTime / 2.0;
1168 *p->Tno_bw = 0;
1169 }
1170 s->Tvm_trips_rounded = dml_max(s->Tvm_trips_rounded, s->LineTime / 4.0);
1171 s->Tr0_trips_rounded = dml_max(s->Tr0_trips_rounded, s->LineTime / 4.0);
1172
1173 if (p->myPipe->SourcePixelFormat == dml_420_8 || p->myPipe->SourcePixelFormat == dml_420_10 || p->myPipe->SourcePixelFormat == dml_420_12) {
1174 s->bytes_pp = p->myPipe->BytePerPixelY + p->myPipe->BytePerPixelC / 4;
1175 } else {
1176 s->bytes_pp = p->myPipe->BytePerPixelY + p->myPipe->BytePerPixelC;
1177 }
1178
1179 s->prefetch_bw_pr = s->bytes_pp * p->myPipe->PixelClock / (dml_float_t)p->myPipe->DPPPerSurface;
1180 if (p->myPipe->VRatio < 1.0)
1181 s->prefetch_bw_pr = p->myPipe->VRatio * s->prefetch_bw_pr;
1182
1183 s->max_Tsw = (dml_max(p->PrefetchSourceLinesY, p->PrefetchSourceLinesC) * s->LineTime);
1184
1185 s->prefetch_sw_bytes = p->PrefetchSourceLinesY * p->swath_width_luma_ub * p->myPipe->BytePerPixelY + p->PrefetchSourceLinesC * p->swath_width_chroma_ub * p->myPipe->BytePerPixelC;
1186 s->prefetch_bw_oto = dml_max(s->prefetch_bw_pr, s->prefetch_sw_bytes / s->max_Tsw);
1187
1188 s->min_Lsw_oto = dml_max(p->PrefetchSourceLinesY, p->PrefetchSourceLinesC) / __DML_MAX_VRATIO_PRE_OTO__;
1189 s->min_Lsw_oto = dml_max(s->min_Lsw_oto, 1.0);
1190 s->Lsw_oto = dml_ceil(4.0 * dml_max(s->prefetch_sw_bytes / s->prefetch_bw_oto / s->LineTime, s->min_Lsw_oto), 1.0) / 4.0;
1191
1192 if (p->GPUVMEnable == true) {
1193 s->Tvm_oto = dml_max3(
1194 s->Tvm_trips,
1195 *p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->prefetch_bw_oto,
1196 s->LineTime / 4.0);
1197 } else
1198 s->Tvm_oto = s->LineTime / 4.0;
1199
1200 if ((p->GPUVMEnable == true || p->myPipe->DCCEnable == true)) {
1201 s->Tr0_oto = dml_max4(
1202 s->Tr0_trips,
1203 (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_oto,
1204 (s->LineTime - s->Tvm_oto)/2.0,
1205 s->LineTime / 4.0);
1206#ifdef __DML_VBA_DEBUG__
1207 dml_print("DML::%s: Tr0_oto max0 = %f\n", __func__, (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_oto);
1208 dml_print("DML::%s: Tr0_oto max1 = %f\n", __func__, s->Tr0_trips);
1209 dml_print("DML::%s: Tr0_oto max2 = %f\n", __func__, s->LineTime - s->Tvm_oto);
1210 dml_print("DML::%s: Tr0_oto max3 = %f\n", __func__, s->LineTime / 4);
1211#endif
1212 } else
1213 s->Tr0_oto = (s->LineTime - s->Tvm_oto) / 2.0;
1214
1215 s->Tvm_oto_lines = dml_ceil(4.0 * s->Tvm_oto / s->LineTime, 1) / 4.0;
1216 s->Tr0_oto_lines = dml_ceil(4.0 * s->Tr0_oto / s->LineTime, 1) / 4.0;
1217 s->dst_y_prefetch_oto = s->Tvm_oto_lines + 2 * s->Tr0_oto_lines + s->Lsw_oto;
1218
1219 s->dst_y_prefetch_equ = p->VStartup - (*p->TSetup + dml_max(p->TWait + p->TCalc, *p->Tdmdl)) / s->LineTime - (*p->DSTYAfterScaler + (dml_float_t) *p->DSTXAfterScaler / (dml_float_t)p->myPipe->HTotal);
1220
1221#ifdef __DML_VBA_DEBUG__
1222 dml_print("DML::%s: HTotal = %u\n", __func__, p->myPipe->HTotal);
1223 dml_print("DML::%s: min_Lsw_oto = %f\n", __func__, s->min_Lsw_oto);
1224 dml_print("DML::%s: *Tno_bw = %f\n", __func__, *p->Tno_bw);
1225 dml_print("DML::%s: UrgentExtraLatency = %f\n", __func__, p->UrgentExtraLatency);
1226 dml_print("DML::%s: trip_to_mem = %f\n", __func__, s->trip_to_mem);
1227 dml_print("DML::%s: BytePerPixelY = %u\n", __func__, p->myPipe->BytePerPixelY);
1228 dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1229 dml_print("DML::%s: swath_width_luma_ub = %u\n", __func__, p->swath_width_luma_ub);
1230 dml_print("DML::%s: BytePerPixelC = %u\n", __func__, p->myPipe->BytePerPixelC);
1231 dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, p->PrefetchSourceLinesC);
1232 dml_print("DML::%s: swath_width_chroma_ub = %u\n", __func__, p->swath_width_chroma_ub);
1233 dml_print("DML::%s: prefetch_sw_bytes = %f\n", __func__, s->prefetch_sw_bytes);
1234 dml_print("DML::%s: bytes_pp = %f\n", __func__, s->bytes_pp);
1235 dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, p->PDEAndMetaPTEBytesFrame);
1236 dml_print("DML::%s: MetaRowByte = %u\n", __func__, p->MetaRowByte);
1237 dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, p->PixelPTEBytesPerRow);
1238 dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, p->HostVMInefficiencyFactor);
1239 dml_print("DML::%s: Tvm_trips = %f\n", __func__, s->Tvm_trips);
1240 dml_print("DML::%s: Tr0_trips = %f\n", __func__, s->Tr0_trips);
1241 dml_print("DML::%s: prefetch_bw_oto = %f\n", __func__, s->prefetch_bw_oto);
1242 dml_print("DML::%s: Tr0_oto = %f\n", __func__, s->Tr0_oto);
1243 dml_print("DML::%s: Tvm_oto = %f\n", __func__, s->Tvm_oto);
1244 dml_print("DML::%s: Tvm_oto_lines = %f\n", __func__, s->Tvm_oto_lines);
1245 dml_print("DML::%s: Tr0_oto_lines = %f\n", __func__, s->Tr0_oto_lines);
1246 dml_print("DML::%s: Lsw_oto = %f\n", __func__, s->Lsw_oto);
1247 dml_print("DML::%s: dst_y_prefetch_oto = %f\n", __func__, s->dst_y_prefetch_oto);
1248 dml_print("DML::%s: dst_y_prefetch_equ = %f\n", __func__, s->dst_y_prefetch_equ);
1249#endif
1250
1251 s->dst_y_prefetch_equ = dml_floor(4.0 * (s->dst_y_prefetch_equ + 0.125), 1) / 4.0;
1252 s->Tpre_rounded = s->dst_y_prefetch_equ * s->LineTime;
1253
1254 dml_print("DML::%s: dst_y_prefetch_equ: %f (after round)\n", __func__, s->dst_y_prefetch_equ);
1255
1256 dml_print("DML::%s: LineTime: %f\n", __func__, s->LineTime);
1257 dml_print("DML::%s: VStartup: %u\n", __func__, p->VStartup);
1258 dml_print("DML::%s: Tvstartup: %fus - time between vstartup and first pixel of active\n", __func__, p->VStartup * s->LineTime);
1259 dml_print("DML::%s: TSetup: %fus - time from vstartup to vready\n", __func__, *p->TSetup);
1260 dml_print("DML::%s: TCalc: %fus - time for calculations in dchub starting at vready\n", __func__, p->TCalc);
1261 dml_print("DML::%s: TWait: %fus - time for fabric to become ready max(pstate exit,cstate enter/exit, urgent latency) after TCalc\n", __func__, p->TWait);
1262 dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, s->Tdmbf);
1263 dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, s->Tdmec);
1264 dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", __func__, s->Tdmsks);
1265 dml_print("DML::%s: Tdmdl_vm: %fus - time for vm stages of dmd \n", __func__, *p->Tdmdl_vm);
1266 dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", __func__, *p->Tdmdl);
1267 dml_print("DML::%s: DSTXAfterScaler: %u pixels - number of pixel clocks pipeline and buffer delay after scaler \n", __func__, *p->DSTXAfterScaler);
1268 dml_print("DML::%s: DSTYAfterScaler: %u lines - number of lines of pipeline and buffer delay after scaler \n", __func__, *p->DSTYAfterScaler);
1269
1270 s->dep_bytes = dml_max(p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor, p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor);
1271
1272 if (s->prefetch_sw_bytes < s->dep_bytes) {
1273 s->prefetch_sw_bytes = 2 * s->dep_bytes;
1274 }
1275
1276 *p->DestinationLinesToRequestVMInVBlank = 0;
1277 *p->DestinationLinesToRequestRowInVBlank = 0;
1278 *p->VRatioPrefetchY = 0;
1279 *p->VRatioPrefetchC = 0;
1280 *p->RequiredPrefetchPixDataBWLuma = 0;
1281 if (s->dst_y_prefetch_equ > 1) {
1282
1283 if (s->Tpre_rounded - *p->Tno_bw > 0) {
1284 s->PrefetchBandwidth1 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + 2 * p->MetaRowByte
1285 + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor
1286 + s->prefetch_sw_bytes)
1287 / (s->Tpre_rounded - *p->Tno_bw);
1288 s->Tsw_est1 = s->prefetch_sw_bytes / s->PrefetchBandwidth1;
1289 } else
1290 s->PrefetchBandwidth1 = 0;
1291
1292 if (p->VStartup == p->MaxVStartup && (s->Tsw_est1 / s->LineTime < s->min_Lsw_oto) && s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.75 * s->LineTime - *p->Tno_bw > 0) {
1293 s->PrefetchBandwidth1 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + 2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) /
1294 (s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.75 * s->LineTime - *p->Tno_bw);
1295 }
1296
1297 if (s->Tpre_rounded - *p->Tno_bw - 2 * s->Tr0_trips_rounded > 0)
1298 s->PrefetchBandwidth2 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + s->prefetch_sw_bytes) /
1299 (s->Tpre_rounded - *p->Tno_bw - 2 * s->Tr0_trips_rounded);
1300 else
1301 s->PrefetchBandwidth2 = 0;
1302
1303 if (s->Tpre_rounded - s->Tvm_trips_rounded > 0) {
1304 s->PrefetchBandwidth3 = (2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor + s->prefetch_sw_bytes) /
1305 (s->Tpre_rounded - s->Tvm_trips_rounded);
1306 s->Tsw_est3 = s->prefetch_sw_bytes / s->PrefetchBandwidth3;
1307 }
1308 else
1309 s->PrefetchBandwidth3 = 0;
1310
1311
1312 if (p->VStartup == p->MaxVStartup && (s->Tsw_est3 / s->LineTime < s->min_Lsw_oto) && s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.5 * s->LineTime - s->Tvm_trips_rounded > 0) {
1313 s->PrefetchBandwidth3 = (2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / (s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.5 * s->LineTime - s->Tvm_trips_rounded);
1314 }
1315
1316 if (s->Tpre_rounded - s->Tvm_trips_rounded - 2 * s->Tr0_trips_rounded > 0)
1317 s->PrefetchBandwidth4 = s->prefetch_sw_bytes / (s->Tpre_rounded - s->Tvm_trips_rounded - 2 * s->Tr0_trips_rounded);
1318 else
1319 s->PrefetchBandwidth4 = 0;
1320
1321#ifdef __DML_VBA_DEBUG__
1322 dml_print("DML::%s: Tpre_rounded: %f\n", __func__, s->Tpre_rounded);
1323 dml_print("DML::%s: Tno_bw: %f\n", __func__, *p->Tno_bw);
1324 dml_print("DML::%s: Tvm_trips_rounded: %f\n", __func__, s->Tvm_trips_rounded);
1325 dml_print("DML::%s: Tsw_est1: %f\n", __func__, s->Tsw_est1);
1326 dml_print("DML::%s: Tsw_est3: %f\n", __func__, s->Tsw_est3);
1327 dml_print("DML::%s: PrefetchBandwidth1: %f\n", __func__, s->PrefetchBandwidth1);
1328 dml_print("DML::%s: PrefetchBandwidth2: %f\n", __func__, s->PrefetchBandwidth2);
1329 dml_print("DML::%s: PrefetchBandwidth3: %f\n", __func__, s->PrefetchBandwidth3);
1330 dml_print("DML::%s: PrefetchBandwidth4: %f\n", __func__, s->PrefetchBandwidth4);
1331#endif
1332 {
1333 dml_bool_t Case1OK;
1334 dml_bool_t Case2OK;
1335 dml_bool_t Case3OK;
1336
1337 if (s->PrefetchBandwidth1 > 0) {
1338 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth1 >= s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth1 >= s->Tr0_trips_rounded) {
1339 Case1OK = true;
1340 } else {
1341 Case1OK = false;
1342 }
1343 } else {
1344 Case1OK = false;
1345 }
1346
1347 if (s->PrefetchBandwidth2 > 0) {
1348 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth2 >= s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth2 < s->Tr0_trips_rounded) {
1349 Case2OK = true;
1350 } else {
1351 Case2OK = false;
1352 }
1353 } else {
1354 Case2OK = false;
1355 }
1356
1357 if (s->PrefetchBandwidth3 > 0) {
1358 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth3 < s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth3 >= s->Tr0_trips_rounded) {
1359 Case3OK = true;
1360 } else {
1361 Case3OK = false;
1362 }
1363 } else {
1364 Case3OK = false;
1365 }
1366
1367 if (Case1OK) {
1368 s->prefetch_bw_equ = s->PrefetchBandwidth1;
1369 } else if (Case2OK) {
1370 s->prefetch_bw_equ = s->PrefetchBandwidth2;
1371 } else if (Case3OK) {
1372 s->prefetch_bw_equ = s->PrefetchBandwidth3;
1373 } else {
1374 s->prefetch_bw_equ = s->PrefetchBandwidth4;
1375 }
1376
1377#ifdef __DML_VBA_DEBUG__
1378 dml_print("DML::%s: Case1OK: %u\n", __func__, Case1OK);
1379 dml_print("DML::%s: Case2OK: %u\n", __func__, Case2OK);
1380 dml_print("DML::%s: Case3OK: %u\n", __func__, Case3OK);
1381 dml_print("DML::%s: prefetch_bw_equ: %f\n", __func__, s->prefetch_bw_equ);
1382#endif
1383
1384 if (s->prefetch_bw_equ > 0) {
1385 if (p->GPUVMEnable == true) {
1386 s->Tvm_equ = dml_max3(*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->prefetch_bw_equ, s->Tvm_trips, s->LineTime / 4);
1387 } else {
1388 s->Tvm_equ = s->LineTime / 4;
1389 }
1390
1391 if ((p->GPUVMEnable == true || p->myPipe->DCCEnable == true)) {
1392 s->Tr0_equ = dml_max4((p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_equ, s->Tr0_trips, (s->LineTime - s->Tvm_equ) / 2, s->LineTime / 4);
1393 } else {
1394 s->Tr0_equ = (s->LineTime - s->Tvm_equ) / 2;
1395 }
1396 } else {
1397 s->Tvm_equ = 0;
1398 s->Tr0_equ = 0;
1399 dml_print("DML::%s: prefetch_bw_equ equals 0!\n", __func__);
1400 }
1401 }
1402
1403
1404 if (s->dst_y_prefetch_oto < s->dst_y_prefetch_equ) {
1405 *p->DestinationLinesForPrefetch = s->dst_y_prefetch_oto;
1406 s->TimeForFetchingMetaPTE = s->Tvm_oto;
1407 s->TimeForFetchingRowInVBlank = s->Tr0_oto;
1408
1409 *p->DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1410 *p->DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1411 } else {
1412 *p->DestinationLinesForPrefetch = s->dst_y_prefetch_equ;
1413 s->TimeForFetchingMetaPTE = s->Tvm_equ;
1414 s->TimeForFetchingRowInVBlank = s->Tr0_equ;
1415
1416 if (p->VStartup == p->MaxVStartup && p->EnhancedPrefetchScheduleAccelerationFinal != 0) {
1417 *p->DestinationLinesToRequestVMInVBlank = dml_floor(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1418 *p->DestinationLinesToRequestRowInVBlank = dml_floor(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1419 } else {
1420 *p->DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1421 *p->DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1422 }
1423 }
1424
1425 s->LinesToRequestPrefetchPixelData = *p->DestinationLinesForPrefetch - *p->DestinationLinesToRequestVMInVBlank - 2 * *p->DestinationLinesToRequestRowInVBlank;
1426
1427#ifdef __DML_VBA_DEBUG__
1428 dml_print("DML::%s: DestinationLinesForPrefetch = %f\n", __func__, *p->DestinationLinesForPrefetch);
1429 dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1430 dml_print("DML::%s: TimeForFetchingRowInVBlank = %f\n", __func__, s->TimeForFetchingRowInVBlank);
1431 dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1432 dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1433 dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1434 dml_print("DML::%s: LinesToRequestPrefetchPixelData = %f\n", __func__, s->LinesToRequestPrefetchPixelData);
1435#endif
1436
1437 if (s->LinesToRequestPrefetchPixelData >= 1 && s->prefetch_bw_equ > 0) {
1438 *p->VRatioPrefetchY = (dml_float_t)p->PrefetchSourceLinesY / s->LinesToRequestPrefetchPixelData;
1439 *p->VRatioPrefetchY = dml_max(*p->VRatioPrefetchY, 1.0);
1440#ifdef __DML_VBA_DEBUG__
1441 dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *p->VRatioPrefetchY);
1442 dml_print("DML::%s: SwathHeightY = %u\n", __func__, p->SwathHeightY);
1443 dml_print("DML::%s: VInitPreFillY = %u\n", __func__, p->VInitPreFillY);
1444#endif
1445 if ((p->SwathHeightY > 4) && (p->VInitPreFillY > 3)) {
1446 if (s->LinesToRequestPrefetchPixelData > (p->VInitPreFillY - 3.0) / 2.0) {
1447 *p->VRatioPrefetchY = dml_max(*p->VRatioPrefetchY,
1448 (dml_float_t)p->MaxNumSwathY * p->SwathHeightY / (s->LinesToRequestPrefetchPixelData - (p->VInitPreFillY - 3.0) / 2.0));
1449 } else {
1450 s->MyError = true;
1451 dml_print("DML::%s: MyErr set. LinesToRequestPrefetchPixelData=%f VinitPreFillY=%u\n", __func__, s->LinesToRequestPrefetchPixelData, p->VInitPreFillY);
1452 *p->VRatioPrefetchY = 0;
1453 }
1454#ifdef __DML_VBA_DEBUG__
1455 dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *p->VRatioPrefetchY);
1456 dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1457 dml_print("DML::%s: MaxNumSwathY = %u\n", __func__, p->MaxNumSwathY);
1458#endif
1459 }
1460
1461 *p->VRatioPrefetchC = (dml_float_t)p->PrefetchSourceLinesC / s->LinesToRequestPrefetchPixelData;
1462 *p->VRatioPrefetchC = dml_max(*p->VRatioPrefetchC, 1.0);
1463
1464#ifdef __DML_VBA_DEBUG__
1465 dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *p->VRatioPrefetchC);
1466 dml_print("DML::%s: SwathHeightC = %u\n", __func__, p->SwathHeightC);
1467 dml_print("DML::%s: VInitPreFillC = %u\n", __func__, p->VInitPreFillC);
1468#endif
1469 if ((p->SwathHeightC > 4) && (p->VInitPreFillC > 3)) {
1470 if (s->LinesToRequestPrefetchPixelData > (p->VInitPreFillC - 3.0) / 2.0) {
1471 *p->VRatioPrefetchC = dml_max(*p->VRatioPrefetchC, (dml_float_t)p->MaxNumSwathC * p->SwathHeightC / (s->LinesToRequestPrefetchPixelData - (p->VInitPreFillC - 3.0) / 2.0));
1472 } else {
1473 s->MyError = true;
1474 dml_print("DML::%s: MyErr set. LinesToRequestPrefetchPixelData=%f VInitPreFillC=%u\n", __func__, s->LinesToRequestPrefetchPixelData, p->VInitPreFillC);
1475 *p->VRatioPrefetchC = 0;
1476 }
1477#ifdef __DML_VBA_DEBUG__
1478 dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *p->VRatioPrefetchC);
1479 dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, p->PrefetchSourceLinesC);
1480 dml_print("DML::%s: MaxNumSwathC = %u\n", __func__, p->MaxNumSwathC);
1481#endif
1482 }
1483
1484 *p->RequiredPrefetchPixDataBWLuma = (dml_float_t)p->PrefetchSourceLinesY / s->LinesToRequestPrefetchPixelData
1485 * p->myPipe->BytePerPixelY
1486 * p->swath_width_luma_ub / s->LineTime;
1487
1488#ifdef __DML_VBA_DEBUG__
1489 dml_print("DML::%s: BytePerPixelY = %u\n", __func__, p->myPipe->BytePerPixelY);
1490 dml_print("DML::%s: swath_width_luma_ub = %u\n", __func__, p->swath_width_luma_ub);
1491 dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1492 dml_print("DML::%s: RequiredPrefetchPixDataBWLuma = %f\n", __func__, *p->RequiredPrefetchPixDataBWLuma);
1493#endif
1494 *p->RequiredPrefetchPixDataBWChroma = (dml_float_t)p->PrefetchSourceLinesC / s->LinesToRequestPrefetchPixelData
1495 *p->myPipe->BytePerPixelC
1496 *p->swath_width_chroma_ub / s->LineTime;
1497 } else {
1498 s->MyError = true;
1499 dml_print("DML:%s: MyErr set. LinesToRequestPrefetchPixelData: %f, should be > 0\n", __func__, s->LinesToRequestPrefetchPixelData);
1500 *p->VRatioPrefetchY = 0;
1501 *p->VRatioPrefetchC = 0;
1502 *p->RequiredPrefetchPixDataBWLuma = 0;
1503 *p->RequiredPrefetchPixDataBWChroma = 0;
1504 }
1505
1506 dml_print("DML: Tpre: %fus - sum of time to request meta pte, 2 x data pte + meta data, swaths\n", (dml_float_t)s->LinesToRequestPrefetchPixelData * s->LineTime + 2.0 * s->TimeForFetchingRowInVBlank + s->TimeForFetchingMetaPTE);
1507 dml_print("DML: Tvm: %fus - time to fetch page tables for meta surface\n", s->TimeForFetchingMetaPTE);
1508 dml_print("DML: Tr0: %fus - time to fetch first row of data pagetables and first row of meta data (done in parallel)\n", s->TimeForFetchingRowInVBlank);
1509 dml_print("DML: Tsw: %fus = time to fetch enough pixel data and cursor data to feed the scalers init position and detile\n", (dml_float_t)s->LinesToRequestPrefetchPixelData * s->LineTime);
5509e596 1510 dml_print("DML: To: %fus - time for propagation from scaler to optc\n", (*p->DSTYAfterScaler + ((dml_float_t) (*p->DSTXAfterScaler) / (dml_float_t)p->myPipe->HTotal)) * s->LineTime);
7966f319
QZ		 1511 dml_print("DML: Tvstartup - TSetup - Tcalc - Twait - Tpre - To > 0\n");
1512 dml_print("DML: Tslack(pre): %fus - time left over in schedule\n", p->VStartup * s->LineTime - s->TimeForFetchingMetaPTE - 2 * s->TimeForFetchingRowInVBlank - (*p->DSTYAfterScaler + ((dml_float_t) (*p->DSTXAfterScaler) / (dml_float_t)p->myPipe->HTotal)) * s->LineTime - p->TWait - p->TCalc - *p->TSetup);
1513 dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %u\n", p->PixelPTEBytesPerRow);
1514
1515 } else {
1516 s->MyError = true;
1517 dml_print("DML::%s: MyErr set, dst_y_prefetch_equ = %f (should be > 1)\n", __func__, s->dst_y_prefetch_equ);
1518 s->TimeForFetchingMetaPTE = 0;
1519 s->TimeForFetchingRowInVBlank = 0;
1520 *p->DestinationLinesToRequestVMInVBlank = 0;
1521 *p->DestinationLinesToRequestRowInVBlank = 0;
1522 s->LinesToRequestPrefetchPixelData = 0;
1523 *p->VRatioPrefetchY = 0;
1524 *p->VRatioPrefetchC = 0;
1525 *p->RequiredPrefetchPixDataBWLuma = 0;
1526 *p->RequiredPrefetchPixDataBWChroma = 0;
1527 }
1528
1529 {
1530 dml_float_t prefetch_vm_bw;
1531 dml_float_t prefetch_row_bw;
1532
1533 if (p->PDEAndMetaPTEBytesFrame == 0) {
1534 prefetch_vm_bw = 0;
1535 } else if (*p->DestinationLinesToRequestVMInVBlank > 0) {
1536#ifdef __DML_VBA_DEBUG__
1537 dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, p->PDEAndMetaPTEBytesFrame);
1538 dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, p->HostVMInefficiencyFactor);
1539 dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1540 dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1541#endif
1542 prefetch_vm_bw = p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / (*p->DestinationLinesToRequestVMInVBlank * s->LineTime);
1543#ifdef __DML_VBA_DEBUG__
1544 dml_print("DML::%s: prefetch_vm_bw = %f\n", __func__, prefetch_vm_bw);
1545#endif
1546 } else {
1547 prefetch_vm_bw = 0;
1548 s->MyError = true;
1549 dml_print("DML::%s: MyErr set. DestinationLinesToRequestVMInVBlank=%f (should be > 0)\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1550 }
1551
1552 if (p->MetaRowByte + p->PixelPTEBytesPerRow == 0) {
1553 prefetch_row_bw = 0;
1554 } else if (*p->DestinationLinesToRequestRowInVBlank > 0) {
1555 prefetch_row_bw = (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / (*p->DestinationLinesToRequestRowInVBlank * s->LineTime);
1556
1557#ifdef __DML_VBA_DEBUG__
1558 dml_print("DML::%s: MetaRowByte = %u\n", __func__, p->MetaRowByte);
1559 dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, p->PixelPTEBytesPerRow);
1560 dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1561 dml_print("DML::%s: prefetch_row_bw = %f\n", __func__, prefetch_row_bw);
1562#endif
1563 } else {
1564 prefetch_row_bw = 0;
1565 s->MyError = true;
1566 dml_print("DML::%s: MyErr set. DestinationLinesToRequestRowInVBlank=%f (should be > 0)\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1567 }
1568
1569 *p->prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw);
1570 }
1571
1572 if (s->MyError) {
1573 s->TimeForFetchingMetaPTE = 0;
1574 s->TimeForFetchingRowInVBlank = 0;
1575 *p->DestinationLinesToRequestVMInVBlank = 0;
1576 *p->DestinationLinesToRequestRowInVBlank = 0;
1577 *p->DestinationLinesForPrefetch = 0;
1578 s->LinesToRequestPrefetchPixelData = 0;
1579 *p->VRatioPrefetchY = 0;
1580 *p->VRatioPrefetchC = 0;
1581 *p->RequiredPrefetchPixDataBWLuma = 0;
1582 *p->RequiredPrefetchPixDataBWChroma = 0;
1583 }
1584
1585 return s->MyError;
1586} // CalculatePrefetchSchedule
1587
1588static void CalculateBytePerPixelAndBlockSizes(
1589 enum dml_source_format_class SourcePixelFormat,
1590 enum dml_swizzle_mode SurfaceTiling,
1591
1592 // Output
1593 dml_uint_t *BytePerPixelY,
1594 dml_uint_t *BytePerPixelC,
1595 dml_float_t *BytePerPixelDETY,
1596 dml_float_t *BytePerPixelDETC,
1597 dml_uint_t *BlockHeight256BytesY,
1598 dml_uint_t *BlockHeight256BytesC,
1599 dml_uint_t *BlockWidth256BytesY,
1600 dml_uint_t *BlockWidth256BytesC,
1601 dml_uint_t *MacroTileHeightY,
1602 dml_uint_t *MacroTileHeightC,
1603 dml_uint_t *MacroTileWidthY,
1604 dml_uint_t *MacroTileWidthC)
1605{
1606 if (SourcePixelFormat == dml_444_64) {
1607 *BytePerPixelDETY = 8;
1608 *BytePerPixelDETC = 0;
1609 *BytePerPixelY = 8;
1610 *BytePerPixelC = 0;
1611 } else if (SourcePixelFormat == dml_444_32 || SourcePixelFormat == dml_rgbe) {
1612 *BytePerPixelDETY = 4;
1613 *BytePerPixelDETC = 0;
1614 *BytePerPixelY = 4;
1615 *BytePerPixelC = 0;
1616 } else if (SourcePixelFormat == dml_444_16 || SourcePixelFormat == dml_mono_16) {
1617 *BytePerPixelDETY = 2;
1618 *BytePerPixelDETC = 0;
1619 *BytePerPixelY = 2;
1620 *BytePerPixelC = 0;
1621 } else if (SourcePixelFormat == dml_444_8 || SourcePixelFormat == dml_mono_8) {
1622 *BytePerPixelDETY = 1;
1623 *BytePerPixelDETC = 0;
1624 *BytePerPixelY = 1;
1625 *BytePerPixelC = 0;
1626 } else if (SourcePixelFormat == dml_rgbe_alpha) {
1627 *BytePerPixelDETY = 4;
1628 *BytePerPixelDETC = 1;
1629 *BytePerPixelY = 4;
1630 *BytePerPixelC = 1;
1631 } else if (SourcePixelFormat == dml_420_8) {
1632 *BytePerPixelDETY = 1;
1633 *BytePerPixelDETC = 2;
1634 *BytePerPixelY = 1;
1635 *BytePerPixelC = 2;
1636 } else if (SourcePixelFormat == dml_420_12) {
1637 *BytePerPixelDETY = 2;
1638 *BytePerPixelDETC = 4;
1639 *BytePerPixelY = 2;
1640 *BytePerPixelC = 4;
1641 } else {
1642 *BytePerPixelDETY = (dml_float_t) (4.0 / 3);
1643 *BytePerPixelDETC = (dml_float_t) (8.0 / 3);
1644 *BytePerPixelY = 2;
1645 *BytePerPixelC = 4;
1646 }
1647#ifdef __DML_VBA_DEBUG__
1648 dml_print("DML::%s: SourcePixelFormat = %u\n", __func__, SourcePixelFormat);
1649 dml_print("DML::%s: BytePerPixelDETY = %f\n", __func__, *BytePerPixelDETY);
1650 dml_print("DML::%s: BytePerPixelDETC = %f\n", __func__, *BytePerPixelDETC);
1651 dml_print("DML::%s: BytePerPixelY = %u\n", __func__, *BytePerPixelY);
1652 dml_print("DML::%s: BytePerPixelC = %u\n", __func__, *BytePerPixelC);
1653#endif
1654 if ((SourcePixelFormat == dml_444_64 || SourcePixelFormat == dml_444_32
1655 || SourcePixelFormat == dml_444_16
1656 || SourcePixelFormat == dml_444_8
1657 || SourcePixelFormat == dml_mono_16
1658 || SourcePixelFormat == dml_mono_8
1659 || SourcePixelFormat == dml_rgbe)) {
1660 if (SurfaceTiling == dml_sw_linear) {
1661 *BlockHeight256BytesY = 1;
1662 } else if (SourcePixelFormat == dml_444_64) {
1663 *BlockHeight256BytesY = 4;
1664 } else if (SourcePixelFormat == dml_444_8) {
1665 *BlockHeight256BytesY = 16;
1666 } else {
1667 *BlockHeight256BytesY = 8;
1668 }
1669 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
1670 *BlockHeight256BytesC = 0;
1671 *BlockWidth256BytesC = 0;
1672 } else {
1673 if (SurfaceTiling == dml_sw_linear) {
1674 *BlockHeight256BytesY = 1;
1675 *BlockHeight256BytesC = 1;
1676 } else if (SourcePixelFormat == dml_rgbe_alpha) {
1677 *BlockHeight256BytesY = 8;
1678 *BlockHeight256BytesC = 16;
1679 } else if (SourcePixelFormat == dml_420_8) {
1680 *BlockHeight256BytesY = 16;
1681 *BlockHeight256BytesC = 8;
1682 } else {
1683 *BlockHeight256BytesY = 8;
1684 *BlockHeight256BytesC = 8;
1685 }
1686 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
1687 *BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC;
1688 }
1689#ifdef __DML_VBA_DEBUG__
1690 dml_print("DML::%s: BlockWidth256BytesY = %u\n", __func__, *BlockWidth256BytesY);
1691 dml_print("DML::%s: BlockHeight256BytesY = %u\n", __func__, *BlockHeight256BytesY);
1692 dml_print("DML::%s: BlockWidth256BytesC = %u\n", __func__, *BlockWidth256BytesC);
1693 dml_print("DML::%s: BlockHeight256BytesC = %u\n", __func__, *BlockHeight256BytesC);
1694#endif
1695
1696 if (SurfaceTiling == dml_sw_linear) {
1697 *MacroTileHeightY = *BlockHeight256BytesY;
1698 *MacroTileWidthY = 256 / *BytePerPixelY / *MacroTileHeightY;
1699 *MacroTileHeightC = *BlockHeight256BytesC;
1700 if (*MacroTileHeightC == 0) {
1701 *MacroTileWidthC = 0;
1702 } else {
1703 *MacroTileWidthC = 256 / *BytePerPixelC / *MacroTileHeightC;
1704 }
1705 } else if (SurfaceTiling == dml_sw_64kb_d || SurfaceTiling == dml_sw_64kb_d_t || SurfaceTiling == dml_sw_64kb_d_x || SurfaceTiling == dml_sw_64kb_r_x) {
1706 *MacroTileHeightY = 16 * *BlockHeight256BytesY;
1707 *MacroTileWidthY = 65536 / *BytePerPixelY / *MacroTileHeightY;
1708 *MacroTileHeightC = 16 * *BlockHeight256BytesC;
1709 if (*MacroTileHeightC == 0) {
1710 *MacroTileWidthC = 0;
1711 } else {
1712 *MacroTileWidthC = 65536 / *BytePerPixelC / *MacroTileHeightC;
1713 }
1714 } else {
1715 *MacroTileHeightY = 32 * *BlockHeight256BytesY;
1716 *MacroTileWidthY = 65536 * 4 / *BytePerPixelY / *MacroTileHeightY;
1717 *MacroTileHeightC = 32 * *BlockHeight256BytesC;
1718 if (*MacroTileHeightC == 0) {
1719 *MacroTileWidthC = 0;
1720 } else {
1721 *MacroTileWidthC = 65536 * 4 / *BytePerPixelC / *MacroTileHeightC;
1722 }
1723 }
1724
1725#ifdef __DML_VBA_DEBUG__
1726 dml_print("DML::%s: MacroTileWidthY = %u\n", __func__, *MacroTileWidthY);
1727 dml_print("DML::%s: MacroTileHeightY = %u\n", __func__, *MacroTileHeightY);
1728 dml_print("DML::%s: MacroTileWidthC = %u\n", __func__, *MacroTileWidthC);
1729 dml_print("DML::%s: MacroTileHeightC = %u\n", __func__, *MacroTileHeightC);
1730#endif
1731} // CalculateBytePerPixelAndBlockSizes
1732
1733static dml_float_t CalculateTWait(
1734 dml_uint_t PrefetchMode,
1735 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
1736 dml_bool_t SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
1737 dml_bool_t DRRDisplay,
1738 dml_float_t DRAMClockChangeLatency,
1739 dml_float_t FCLKChangeLatency,
1740 dml_float_t UrgentLatency,
1741 dml_float_t SREnterPlusExitTime)
1742{
1743 dml_float_t TWait = 0.0;
1744
1745 if (PrefetchMode == 0 &&
1746 !(UseMALLForPStateChange == dml_use_mall_pstate_change_full_frame) && !(UseMALLForPStateChange == dml_use_mall_pstate_change_sub_viewport) &&
1747 !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe) && !(SynchronizeDRRDisplaysForUCLKPStateChangeFinal && DRRDisplay)) {
1748 TWait = dml_max3(DRAMClockChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
1749 } else if (PrefetchMode <= 1 && !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe)) {
1750 TWait = dml_max3(FCLKChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
1751 } else if (PrefetchMode <= 2 && !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe)) {
1752 TWait = dml_max(SREnterPlusExitTime, UrgentLatency);
1753 } else {
1754 TWait = UrgentLatency;
1755 }
1756
1757#ifdef __DML_VBA_DEBUG__
1758 dml_print("DML::%s: PrefetchMode = %u\n", __func__, PrefetchMode);
1759 dml_print("DML::%s: TWait = %f\n", __func__, TWait);
1760#endif
1761 return TWait;
1762} // CalculateTWait
1763
1764
1765/// @brief Calculate the "starting point" for prefetch calculation
1766/// if AllowForPStateChangeOrStutterInVBlank is set as a particular requirement, then the mode evalulation
1767/// will only be done at the given mode. If no specific requirement (i.e. *_if_possible), then will just go from
1768/// try all the prefetch mode in decreasing order of "difficulty" (start from 0 which means all power saving
1769/// features).
1770static void CalculatePrefetchMode(
1771 enum dml_prefetch_modes AllowForPStateChangeOrStutterInVBlank,
1772 dml_uint_t *MinPrefetchMode,
1773 dml_uint_t *MaxPrefetchMode)
1774{
1775 if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_uclk_fclk_and_stutter_if_possible) {
1776 *MinPrefetchMode = 0; // consider all pwr saving features
1777 *MaxPrefetchMode = 3; // consider just urgent latency
1778 } else {
1779 if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_none) {
1780 *MinPrefetchMode = 3;
1781 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_stutter) {
1782 *MinPrefetchMode = 2;
1783 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_fclk_and_stutter) {
1784 *MinPrefetchMode = 1;
1785 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_uclk_fclk_and_stutter) {
1786 *MinPrefetchMode = 0;
1787 } else {
1788 dml_print("ERROR: Invalid AllowForPStateChangeOrStutterInVBlank setting! val=%u\n", AllowForPStateChangeOrStutterInVBlank);
1789 ASSERT(0);
1790 }
1791 *MaxPrefetchMode = *MinPrefetchMode;
1792 }
1793} // CalculatePrefetchMode
1794
1795static dml_float_t CalculateWriteBackDISPCLK(
1796 enum dml_source_format_class WritebackPixelFormat,
1797 dml_float_t PixelClock,
1798 dml_float_t WritebackHRatio,
1799 dml_float_t WritebackVRatio,
1800 dml_uint_t WritebackHTaps,
1801 dml_uint_t WritebackVTaps,
1802 dml_uint_t WritebackSourceWidth,
1803 dml_uint_t WritebackDestinationWidth,
1804 dml_uint_t HTotal,
1805 dml_uint_t WritebackLineBufferSize,
1806 dml_float_t DISPCLKDPPCLKVCOSpeed)
1807{
1808 dml_float_t DISPCLK_H, DISPCLK_V, DISPCLK_HB;
1809
1810 DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio;
1811 DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / (dml_float_t) HTotal;
1812 DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / (dml_float_t) WritebackSourceWidth;
1813 return RoundToDFSGranularity(dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB), 1, DISPCLKDPPCLKVCOSpeed);
1814}
1815
1816static dml_float_t CalculateWriteBackDelay(
1817 enum dml_source_format_class WritebackPixelFormat,
1818 dml_float_t WritebackHRatio,
1819 dml_float_t WritebackVRatio,
1820 dml_uint_t WritebackVTaps,
1821 dml_uint_t WritebackDestinationWidth,
1822 dml_uint_t WritebackDestinationHeight,
1823 dml_uint_t WritebackSourceHeight,
1824 dml_uint_t HTotal)
1825{
1826 dml_float_t CalculateWriteBackDelay;
1827 dml_float_t Line_length;
1828 dml_float_t Output_lines_last_notclamped;
1829 dml_float_t WritebackVInit;
1830
1831 WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2;
1832 Line_length = dml_max((dml_float_t) WritebackDestinationWidth, dml_ceil((dml_float_t)WritebackDestinationWidth / 6.0, 1.0) * WritebackVTaps);
1833 Output_lines_last_notclamped = WritebackDestinationHeight - 1 - dml_ceil(((dml_float_t)WritebackSourceHeight - (dml_float_t) WritebackVInit) / (dml_float_t)WritebackVRatio, 1.0);
1834 if (Output_lines_last_notclamped < 0) {
1835 CalculateWriteBackDelay = 0;
1836 } else {
1837 CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length + (HTotal - WritebackDestinationWidth) + 80;
1838 }
1839 return CalculateWriteBackDelay;
1840}
1841
1842static void CalculateVUpdateAndDynamicMetadataParameters(
1843 dml_uint_t MaxInterDCNTileRepeaters,
1844 dml_float_t Dppclk,
1845 dml_float_t Dispclk,
1846 dml_float_t DCFClkDeepSleep,
1847 dml_float_t PixelClock,
1848 dml_uint_t HTotal,
1849 dml_uint_t VBlank,
1850 dml_uint_t DynamicMetadataTransmittedBytes,
1851 dml_uint_t DynamicMetadataLinesBeforeActiveRequired,
1852 dml_uint_t InterlaceEnable,
1853 dml_bool_t ProgressiveToInterlaceUnitInOPP,
1854
1855 // Output
1856 dml_float_t *TSetup,
1857 dml_float_t *Tdmbf,
1858 dml_float_t *Tdmec,
1859 dml_float_t *Tdmsks,
1860 dml_uint_t *VUpdateOffsetPix,
1861 dml_uint_t *VUpdateWidthPix,
1862 dml_uint_t *VReadyOffsetPix)
1863{
1864 dml_float_t TotalRepeaterDelayTime;
1865 TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / Dppclk + 3 / Dispclk);
1866 *VUpdateWidthPix = (dml_uint_t)(dml_ceil((14.0 / DCFClkDeepSleep + 12.0 / Dppclk + TotalRepeaterDelayTime) * PixelClock, 1.0));
1867 *VReadyOffsetPix = (dml_uint_t)(dml_ceil(dml_max(150.0 / Dppclk, TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / Dppclk) * PixelClock, 1.0));
1868 *VUpdateOffsetPix = (dml_uint_t)(dml_ceil(HTotal / 4.0, 1.0));
1869 *TSetup = (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock;
1870 *Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / Dispclk;
1871 *Tdmec = HTotal / PixelClock;
1872
1873 if (DynamicMetadataLinesBeforeActiveRequired == 0) {
1874 *Tdmsks = VBlank * HTotal / PixelClock / 2.0;
1875 } else {
1876 *Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock;
1877 }
1878 if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false) {
1879 *Tdmsks = *Tdmsks / 2;
1880 }
1881#ifdef __DML_VBA_DEBUG__
1882 dml_print("DML::%s: DynamicMetadataLinesBeforeActiveRequired = %u\n", __func__, DynamicMetadataLinesBeforeActiveRequired);
1883 dml_print("DML::%s: VBlank = %u\n", __func__, VBlank);
1884 dml_print("DML::%s: HTotal = %u\n", __func__, HTotal);
1885 dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock);
1886 dml_print("DML::%s: Dppclk = %f\n", __func__, Dppclk);
1887 dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, DCFClkDeepSleep);
1888 dml_print("DML::%s: MaxInterDCNTileRepeaters = %u\n", __func__, MaxInterDCNTileRepeaters);
1889 dml_print("DML::%s: TotalRepeaterDelayTime = %f\n", __func__, TotalRepeaterDelayTime);
1890
1891 dml_print("DML::%s: VUpdateWidthPix = %u\n", __func__, *VUpdateWidthPix);
1892 dml_print("DML::%s: VReadyOffsetPix = %u\n", __func__, *VReadyOffsetPix);
1893 dml_print("DML::%s: VUpdateOffsetPix = %u\n", __func__, *VUpdateOffsetPix);
1894
1895 dml_print("DML::%s: Tdmsks = %f\n", __func__, *Tdmsks);
1896#endif
1897}
1898
1899static void CalculateRowBandwidth(
1900 dml_bool_t GPUVMEnable,
1901 enum dml_source_format_class SourcePixelFormat,
1902 dml_float_t VRatio,
1903 dml_float_t VRatioChroma,
1904 dml_bool_t DCCEnable,
1905 dml_float_t LineTime,
1906 dml_uint_t MetaRowByteLuma,
1907 dml_uint_t MetaRowByteChroma,
1908 dml_uint_t meta_row_height_luma,
1909 dml_uint_t meta_row_height_chroma,
1910 dml_uint_t PixelPTEBytesPerRowLuma,
1911 dml_uint_t PixelPTEBytesPerRowChroma,
1912 dml_uint_t dpte_row_height_luma,
1913 dml_uint_t dpte_row_height_chroma,
1914 // Output
1915 dml_float_t *meta_row_bw,
1916 dml_float_t *dpte_row_bw)
1917{
1918 if (DCCEnable != true) {
1919 *meta_row_bw = 0;
1920 } else if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12 || SourcePixelFormat == dml_rgbe_alpha) {
1921 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
1922 + VRatioChroma * MetaRowByteChroma
1923 / (meta_row_height_chroma * LineTime);
1924 } else {
1925 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
1926 }
1927
1928 if (GPUVMEnable != true) {
1929 *dpte_row_bw = 0;
1930 } else if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12 || SourcePixelFormat == dml_rgbe_alpha) {
1931 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
1932 + VRatioChroma * PixelPTEBytesPerRowChroma
1933 / (dpte_row_height_chroma * LineTime);
1934 } else {
1935 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
1936 }
1937}
1938
1939/// @brief Determine immediate flip schedule given bw remaining after considering the prefetch schedule
1940/// @param BandwidthAvailableForImmediateFlip Bandwidth available for iflip for all planes
1941static void CalculateFlipSchedule(
1942 dml_float_t HostVMInefficiencyFactor,
1943 dml_float_t UrgentExtraLatency,
1944 dml_float_t UrgentLatency,
1945 dml_uint_t GPUVMMaxPageTableLevels,
1946 dml_bool_t HostVMEnable,
1947 dml_uint_t HostVMMaxNonCachedPageTableLevels,
1948 dml_bool_t GPUVMEnable,
1949 dml_uint_t HostVMMinPageSize,
1950 dml_float_t PDEAndMetaPTEBytesPerFrame,
1951 dml_float_t MetaRowBytes,
1952 dml_float_t DPTEBytesPerRow,
1953 dml_float_t BandwidthAvailableForImmediateFlip,
1954 dml_uint_t TotImmediateFlipBytes,
1955 enum dml_source_format_class SourcePixelFormat,
1956 dml_float_t LineTime,
1957 dml_float_t VRatio,
1958 dml_float_t VRatioChroma,
1959 dml_float_t Tno_bw,
1960 dml_bool_t DCCEnable,
1961 dml_uint_t dpte_row_height,
1962 dml_uint_t meta_row_height,
1963 dml_uint_t dpte_row_height_chroma,
1964 dml_uint_t meta_row_height_chroma,
1965 dml_bool_t use_one_row_for_frame_flip,
1966
1967 // Output
1968 dml_float_t *DestinationLinesToRequestVMInImmediateFlip,
1969 dml_float_t *DestinationLinesToRequestRowInImmediateFlip,
1970 dml_float_t *final_flip_bw,
1971 dml_bool_t *ImmediateFlipSupportedForPipe)
1972{
1973 dml_float_t min_row_time = 0.0;
1974 dml_uint_t HostVMDynamicLevelsTrips = 0;
1975 dml_float_t TimeForFetchingMetaPTEImmediateFlip = 0;
1976 dml_float_t TimeForFetchingRowInVBlankImmediateFlip = 0;
1977 dml_float_t ImmediateFlipBW = 0; // @brief The immediate flip bandwidth for this pipe
1978
1979 if (GPUVMEnable == true && HostVMEnable == true) {
1980 HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
1981 } else {
1982 HostVMDynamicLevelsTrips = 0;
1983 }
1984
1985#ifdef __DML_VBA_DEBUG__
1986 dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, TotImmediateFlipBytes);
1987 dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
1988 dml_print("DML::%s: UrgentLatency = %f\n", __func__, UrgentLatency);
1989 dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip);
1990#endif
1991
1992 if (TotImmediateFlipBytes > 0) {
1993 if (use_one_row_for_frame_flip) {
1994 ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + 2.0 * DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / (dml_float_t) TotImmediateFlipBytes;
1995 } else {
1996 ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / (dml_float_t) TotImmediateFlipBytes;
1997 }
1998 if (GPUVMEnable == true) {
1999 TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / ImmediateFlipBW,
2000 UrgentExtraLatency + UrgentLatency * (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1),
2001 LineTime / 4.0);
2002 } else {
2003 TimeForFetchingMetaPTEImmediateFlip = 0;
2004 }
2005 if ((GPUVMEnable == true || DCCEnable == true)) {
2006 TimeForFetchingRowInVBlankImmediateFlip = dml_max3((MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW, UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4.0);
2007 } else {
2008 TimeForFetchingRowInVBlankImmediateFlip = 0;
2009 }
2010
2011 *DestinationLinesToRequestVMInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1.0) / 4.0;
2012 *DestinationLinesToRequestRowInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1.0) / 4.0;
2013
2014 if (GPUVMEnable == true) {
2015 *final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
2016 (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime));
2017 } else if ((GPUVMEnable == true || DCCEnable == true)) {
2018 *final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime);
2019 } else {
2020 *final_flip_bw = 0;
2021 }
2022 } else {
2023 TimeForFetchingMetaPTEImmediateFlip = 0;
2024 TimeForFetchingRowInVBlankImmediateFlip = 0;
2025 *DestinationLinesToRequestVMInImmediateFlip = 0;
2026 *DestinationLinesToRequestRowInImmediateFlip = 0;
2027 *final_flip_bw = 0;
2028 }
2029
2030 if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_rgbe_alpha) {
2031 if (GPUVMEnable == true && DCCEnable != true) {
2032 min_row_time = dml_min(dpte_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma);
2033 } else if (GPUVMEnable != true && DCCEnable == true) {
2034 min_row_time = dml_min(meta_row_height * LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma);
2035 } else {
2036 min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma);
2037 }
2038 } else {
2039 if (GPUVMEnable == true && DCCEnable != true) {
2040 min_row_time = dpte_row_height * LineTime / VRatio;
2041 } else if (GPUVMEnable != true && DCCEnable == true) {
2042 min_row_time = meta_row_height * LineTime / VRatio;
2043 } else {
2044 min_row_time = dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio);
2045 }
2046 }
2047
2048 if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16 || TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip > min_row_time) {
2049 *ImmediateFlipSupportedForPipe = false;
2050 } else {
2051 *ImmediateFlipSupportedForPipe = true;
2052 }
2053
2054#ifdef __DML_VBA_DEBUG__
2055 dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2056 dml_print("DML::%s: DCCEnable = %u\n", __func__, DCCEnable);
2057
2058 dml_print("DML::%s: MetaRowBytes = %f\n", __func__, MetaRowBytes);
2059 dml_print("DML::%s: DPTEBytesPerRow = %f\n", __func__, DPTEBytesPerRow);
2060 dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip);
2061 dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, TotImmediateFlipBytes);
2062 dml_print("DML::%s: ImmediateFlipBW = %f\n", __func__, ImmediateFlipBW);
2063 dml_print("DML::%s: PDEAndMetaPTEBytesPerFrame = %f\n", __func__, PDEAndMetaPTEBytesPerFrame);
2064 dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
2065 dml_print("DML::%s: LineTime = %f\n", __func__, LineTime);
2066 dml_print("DML::%s: final_flip_bw = %f\n", __func__, *final_flip_bw);
2067
2068 dml_print("DML::%s: DestinationLinesToRequestVMInImmediateFlip = %f\n", __func__, *DestinationLinesToRequestVMInImmediateFlip);
2069 dml_print("DML::%s: DestinationLinesToRequestRowInImmediateFlip = %f\n", __func__, *DestinationLinesToRequestRowInImmediateFlip);
2070 dml_print("DML::%s: TimeForFetchingMetaPTEImmediateFlip = %f\n", __func__, TimeForFetchingMetaPTEImmediateFlip);
2071 dml_print("DML::%s: TimeForFetchingRowInVBlankImmediateFlip = %f\n", __func__, TimeForFetchingRowInVBlankImmediateFlip);
2072 dml_print("DML::%s: min_row_time = %f\n", __func__, min_row_time);
2073 dml_print("DML::%s: ImmediateFlipSupportedForPipe = %u\n", __func__, *ImmediateFlipSupportedForPipe);
2074#endif
2075} // CalculateFlipSchedule
2076
2077static dml_float_t RoundToDFSGranularity(dml_float_t Clock, dml_bool_t round_up, dml_float_t VCOSpeed)
2078{
2079 if (Clock <= 0.0)
2080 return 0.0;
2081 else {
2082 if (round_up)
2083 return VCOSpeed * 4.0 / dml_floor(VCOSpeed * 4.0 / Clock, 1.0);
2084 else
2085 return VCOSpeed * 4.0 / dml_ceil(VCOSpeed * 4.0 / Clock, 1.0);
2086 }
2087}
2088
2089static void CalculateDCCConfiguration(
2090 dml_bool_t DCCEnabled,
2091 dml_bool_t DCCProgrammingAssumesScanDirectionUnknown,
2092 enum dml_source_format_class SourcePixelFormat,
2093 dml_uint_t SurfaceWidthLuma,
2094 dml_uint_t SurfaceWidthChroma,
2095 dml_uint_t SurfaceHeightLuma,
2096 dml_uint_t SurfaceHeightChroma,
2097 dml_uint_t nomDETInKByte,
2098 dml_uint_t RequestHeight256ByteLuma,
2099 dml_uint_t RequestHeight256ByteChroma,
2100 enum dml_swizzle_mode TilingFormat,
2101 dml_uint_t BytePerPixelY,
2102 dml_uint_t BytePerPixelC,
2103 dml_float_t BytePerPixelDETY,
2104 dml_float_t BytePerPixelDETC,
2105 enum dml_rotation_angle SourceScan,
2106 // Output
2107 dml_uint_t *MaxUncompressedBlockLuma,
2108 dml_uint_t *MaxUncompressedBlockChroma,
2109 dml_uint_t *MaxCompressedBlockLuma,
2110 dml_uint_t *MaxCompressedBlockChroma,
2111 dml_uint_t *IndependentBlockLuma,
2112 dml_uint_t *IndependentBlockChroma)
2113{
2114 dml_uint_t DETBufferSizeForDCC = nomDETInKByte * 1024;
2115
2116 dml_uint_t yuv420;
2117 dml_uint_t horz_div_l;
2118 dml_uint_t horz_div_c;
2119 dml_uint_t vert_div_l;
2120 dml_uint_t vert_div_c;
2121
2122 dml_uint_t swath_buf_size;
2123 dml_float_t detile_buf_vp_horz_limit;
2124 dml_float_t detile_buf_vp_vert_limit;
2125
2126 dml_uint_t MAS_vp_horz_limit;
2127 dml_uint_t MAS_vp_vert_limit;
2128 dml_uint_t max_vp_horz_width;
2129 dml_uint_t max_vp_vert_height;
2130 dml_uint_t eff_surf_width_l;
2131 dml_uint_t eff_surf_width_c;
2132 dml_uint_t eff_surf_height_l;
2133 dml_uint_t eff_surf_height_c;
2134
2135 dml_uint_t full_swath_bytes_horz_wc_l;
2136 dml_uint_t full_swath_bytes_horz_wc_c;
2137 dml_uint_t full_swath_bytes_vert_wc_l;
2138 dml_uint_t full_swath_bytes_vert_wc_c;
2139
2140 dml_uint_t req128_horz_wc_l;
2141 dml_uint_t req128_horz_wc_c;
2142 dml_uint_t req128_vert_wc_l;
2143 dml_uint_t req128_vert_wc_c;
2144
2145 dml_uint_t segment_order_horz_contiguous_luma;
2146 dml_uint_t segment_order_horz_contiguous_chroma;
2147 dml_uint_t segment_order_vert_contiguous_luma;
2148 dml_uint_t segment_order_vert_contiguous_chroma;
2149
2150 typedef enum{
2151 REQ_256Bytes,
2152 REQ_128BytesNonContiguous,
2153 REQ_128BytesContiguous,
2154 REQ_NA
2155 } RequestType;
2156
2157 RequestType RequestLuma;
2158 RequestType RequestChroma;
2159
2160 yuv420 = ((SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12) ? 1 : 0);
2161 horz_div_l = 1;
2162 horz_div_c = 1;
2163 vert_div_l = 1;
2164 vert_div_c = 1;
2165
2166 if (BytePerPixelY == 1)
2167 vert_div_l = 0;
2168 if (BytePerPixelC == 1)
2169 vert_div_c = 0;
2170
2171 if (BytePerPixelC == 0) {
2172 swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 256;
2173 detile_buf_vp_horz_limit = (dml_float_t) swath_buf_size / ((dml_float_t) RequestHeight256ByteLuma * BytePerPixelY / (1 + horz_div_l));
2174 detile_buf_vp_vert_limit = (dml_float_t) swath_buf_size / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l));
2175 } else {
2176 swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 2 * 256;
2177 detile_buf_vp_horz_limit = (dml_float_t) swath_buf_size / ((dml_float_t) RequestHeight256ByteLuma * BytePerPixelY / (1 + horz_div_l) + (dml_float_t) RequestHeight256ByteChroma * BytePerPixelC / (1 + horz_div_c) / (1 + yuv420));
2178 detile_buf_vp_vert_limit = (dml_float_t) swath_buf_size / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l) + 256.0 / RequestHeight256ByteChroma / (1 + vert_div_c) / (1 + yuv420));
2179 }
2180
2181 if (SourcePixelFormat == dml_420_10) {
2182 detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit;
2183 detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit;
2184 }
2185
2186 detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16);
2187 detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16);
2188
2189 MAS_vp_horz_limit = SourcePixelFormat == dml_rgbe_alpha ? 3840 : 6144;
2190 MAS_vp_vert_limit = SourcePixelFormat == dml_rgbe_alpha ? 3840 : (BytePerPixelY == 8 ? 3072 : 6144);
2191 max_vp_horz_width = (dml_uint_t)(dml_min((dml_float_t) MAS_vp_horz_limit, detile_buf_vp_horz_limit));
2192 max_vp_vert_height = (dml_uint_t)(dml_min((dml_float_t) MAS_vp_vert_limit, detile_buf_vp_vert_limit));
2193 eff_surf_width_l = (SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma);
2194 eff_surf_width_c = eff_surf_width_l / (1 + yuv420);
2195 eff_surf_height_l = (SurfaceHeightLuma > max_vp_vert_height ? max_vp_vert_height : SurfaceHeightLuma);
2196 eff_surf_height_c = eff_surf_height_l / (1 + yuv420);
2197
2198 full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY;
2199 full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma;
2200 if (BytePerPixelC > 0) {
2201 full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma * BytePerPixelC;
2202 full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma;
2203 } else {
2204 full_swath_bytes_horz_wc_c = 0;
2205 full_swath_bytes_vert_wc_c = 0;
2206 }
2207
2208 if (SourcePixelFormat == dml_420_10) {
2209 full_swath_bytes_horz_wc_l = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_horz_wc_l * 2.0 / 3.0, 256.0));
2210 full_swath_bytes_horz_wc_c = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_horz_wc_c * 2.0 / 3.0, 256.0));
2211 full_swath_bytes_vert_wc_l = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_vert_wc_l * 2.0 / 3.0, 256.0));
2212 full_swath_bytes_vert_wc_c = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_vert_wc_c * 2.0 / 3.0, 256.0));
2213 }
2214
2215 if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2216 req128_horz_wc_l = 0;
2217 req128_horz_wc_c = 0;
2218 } else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c && 2 * full_swath_bytes_horz_wc_l + full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2219 req128_horz_wc_l = 0;
2220 req128_horz_wc_c = 1;
2221 } else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c && full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2222 req128_horz_wc_l = 1;
2223 req128_horz_wc_c = 0;
2224 } else {
2225 req128_horz_wc_l = 1;
2226 req128_horz_wc_c = 1;
2227 }
2228
2229 if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2230 req128_vert_wc_l = 0;
2231 req128_vert_wc_c = 0;
2232 } else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c && 2 * full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2233 req128_vert_wc_l = 0;
2234 req128_vert_wc_c = 1;
2235 } else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c && full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2236 req128_vert_wc_l = 1;
2237 req128_vert_wc_c = 0;
2238 } else {
2239 req128_vert_wc_l = 1;
2240 req128_vert_wc_c = 1;
2241 }
2242
2243 if (BytePerPixelY == 2) {
2244 segment_order_horz_contiguous_luma = 0;
2245 segment_order_vert_contiguous_luma = 1;
2246 } else {
2247 segment_order_horz_contiguous_luma = 1;
2248 segment_order_vert_contiguous_luma = 0;
2249 }
2250
2251 if (BytePerPixelC == 2) {
2252 segment_order_horz_contiguous_chroma = 0;
2253 segment_order_vert_contiguous_chroma = 1;
2254 } else {
2255 segment_order_horz_contiguous_chroma = 1;
2256 segment_order_vert_contiguous_chroma = 0;
2257 }
2258#ifdef __DML_VBA_DEBUG__
2259 dml_print("DML::%s: DCCEnabled = %u\n", __func__, DCCEnabled);
2260 dml_print("DML::%s: nomDETInKByte = %u\n", __func__, nomDETInKByte);
2261 dml_print("DML::%s: DETBufferSizeForDCC = %u\n", __func__, DETBufferSizeForDCC);
2262 dml_print("DML::%s: req128_horz_wc_l = %u\n", __func__, req128_horz_wc_l);
2263 dml_print("DML::%s: req128_horz_wc_c = %u\n", __func__, req128_horz_wc_c);
2264 dml_print("DML::%s: full_swath_bytes_horz_wc_l = %u\n", __func__, full_swath_bytes_horz_wc_l);
2265 dml_print("DML::%s: full_swath_bytes_vert_wc_c = %u\n", __func__, full_swath_bytes_vert_wc_c);
2266 dml_print("DML::%s: segment_order_horz_contiguous_luma = %u\n", __func__, segment_order_horz_contiguous_luma);
2267 dml_print("DML::%s: segment_order_horz_contiguous_chroma = %u\n", __func__, segment_order_horz_contiguous_chroma);
2268#endif
2269
2270 if (DCCProgrammingAssumesScanDirectionUnknown == true) {
2271 if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0) {
2272 RequestLuma = REQ_256Bytes;
2273 } else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0) || (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0)) {
2274 RequestLuma = REQ_128BytesNonContiguous;
2275 } else {
2276 RequestLuma = REQ_128BytesContiguous;
2277 }
2278 if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0) {
2279 RequestChroma = REQ_256Bytes;
2280 } else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0) || (req128_vert_wc_c == 1 && segment_order_vert_contiguous_chroma == 0)) {
2281 RequestChroma = REQ_128BytesNonContiguous;
2282 } else {
2283 RequestChroma = REQ_128BytesContiguous;
2284 }
2285 } else if (!dml_is_vertical_rotation(SourceScan)) {
2286 if (req128_horz_wc_l == 0) {
2287 RequestLuma = REQ_256Bytes;
2288 } else if (segment_order_horz_contiguous_luma == 0) {
2289 RequestLuma = REQ_128BytesNonContiguous;
2290 } else {
2291 RequestLuma = REQ_128BytesContiguous;
2292 }
2293 if (req128_horz_wc_c == 0) {
2294 RequestChroma = REQ_256Bytes;
2295 } else if (segment_order_horz_contiguous_chroma == 0) {
2296 RequestChroma = REQ_128BytesNonContiguous;
2297 } else {
2298 RequestChroma = REQ_128BytesContiguous;
2299 }
2300 } else {
2301 if (req128_vert_wc_l == 0) {
2302 RequestLuma = REQ_256Bytes;
2303 } else if (segment_order_vert_contiguous_luma == 0) {
2304 RequestLuma = REQ_128BytesNonContiguous;
2305 } else {
2306 RequestLuma = REQ_128BytesContiguous;
2307 }
2308 if (req128_vert_wc_c == 0) {
2309 RequestChroma = REQ_256Bytes;
2310 } else if (segment_order_vert_contiguous_chroma == 0) {
2311 RequestChroma = REQ_128BytesNonContiguous;
2312 } else {
2313 RequestChroma = REQ_128BytesContiguous;
2314 }
2315 }
2316
2317 if (RequestLuma == REQ_256Bytes) {
2318 *MaxUncompressedBlockLuma = 256;
2319 *MaxCompressedBlockLuma = 256;
2320 *IndependentBlockLuma = 0;
2321 } else if (RequestLuma == REQ_128BytesContiguous) {
2322 *MaxUncompressedBlockLuma = 256;
2323 *MaxCompressedBlockLuma = 128;
2324 *IndependentBlockLuma = 128;
2325 } else {
2326 *MaxUncompressedBlockLuma = 256;
2327 *MaxCompressedBlockLuma = 64;
2328 *IndependentBlockLuma = 64;
2329 }
2330
2331 if (RequestChroma == REQ_256Bytes) {
2332 *MaxUncompressedBlockChroma = 256;
2333 *MaxCompressedBlockChroma = 256;
2334 *IndependentBlockChroma = 0;
2335 } else if (RequestChroma == REQ_128BytesContiguous) {
2336 *MaxUncompressedBlockChroma = 256;
2337 *MaxCompressedBlockChroma = 128;
2338 *IndependentBlockChroma = 128;
2339 } else {
2340 *MaxUncompressedBlockChroma = 256;
2341 *MaxCompressedBlockChroma = 64;
2342 *IndependentBlockChroma = 64;
2343 }
2344
2345 if (DCCEnabled != true || BytePerPixelC == 0) {
2346 *MaxUncompressedBlockChroma = 0;
2347 *MaxCompressedBlockChroma = 0;
2348 *IndependentBlockChroma = 0;
2349 }
2350
2351 if (DCCEnabled != true) {
2352 *MaxUncompressedBlockLuma = 0;
2353 *MaxCompressedBlockLuma = 0;
2354 *IndependentBlockLuma = 0;
2355 }
2356
2357#ifdef __DML_VBA_DEBUG__
2358 dml_print("DML::%s: MaxUncompressedBlockLuma = %u\n", __func__, *MaxUncompressedBlockLuma);
2359 dml_print("DML::%s: MaxCompressedBlockLuma = %u\n", __func__, *MaxCompressedBlockLuma);
2360 dml_print("DML::%s: IndependentBlockLuma = %u\n", __func__, *IndependentBlockLuma);
2361 dml_print("DML::%s: MaxUncompressedBlockChroma = %u\n", __func__, *MaxUncompressedBlockChroma);
2362 dml_print("DML::%s: MaxCompressedBlockChroma = %u\n", __func__, *MaxCompressedBlockChroma);
2363 dml_print("DML::%s: IndependentBlockChroma = %u\n", __func__, *IndependentBlockChroma);
2364#endif
2365
2366} // CalculateDCCConfiguration
2367
2368static dml_uint_t CalculatePrefetchSourceLines(
2369 dml_float_t VRatio,
2370 dml_uint_t VTaps,
2371 dml_bool_t Interlace,
2372 dml_bool_t ProgressiveToInterlaceUnitInOPP,
2373 dml_uint_t SwathHeight,
2374 enum dml_rotation_angle SourceScan,
2375 dml_bool_t ViewportStationary,
2376 dml_uint_t SwathWidth,
2377 dml_uint_t ViewportHeight,
2378 dml_uint_t ViewportXStart,
2379 dml_uint_t ViewportYStart,
2380
2381 // Output
2382 dml_uint_t *VInitPreFill,
2383 dml_uint_t *MaxNumSwath)
2384{
2385
2386 dml_uint_t vp_start_rot = 0;
2387 dml_uint_t sw0_tmp = 0;
2388 dml_uint_t MaxPartialSwath = 0;
2389 dml_float_t numLines = 0;
2390
2391#ifdef __DML_VBA_DEBUG__
2392 dml_print("DML::%s: VRatio = %f\n", __func__, VRatio);
2393 dml_print("DML::%s: VTaps = %u\n", __func__, VTaps);
2394 dml_print("DML::%s: ViewportXStart = %u\n", __func__, ViewportXStart);
2395 dml_print("DML::%s: ViewportYStart = %u\n", __func__, ViewportYStart);
2396 dml_print("DML::%s: ViewportStationary = %u\n", __func__, ViewportStationary);
2397 dml_print("DML::%s: SwathHeight = %u\n", __func__, SwathHeight);
2398#endif
2399 if (ProgressiveToInterlaceUnitInOPP)
2400 *VInitPreFill = (dml_uint_t)(dml_floor((VRatio + (dml_float_t) VTaps + 1) / 2.0, 1));
2401 else
2402 *VInitPreFill = (dml_uint_t)(dml_floor((VRatio + (dml_float_t) VTaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1));
2403
2404 if (ViewportStationary) {
2405 if (SourceScan == dml_rotation_180 || SourceScan == dml_rotation_180m) {
2406 vp_start_rot = SwathHeight - (((dml_uint_t) (ViewportYStart + ViewportHeight - 1) % SwathHeight) + 1);
2407 } else if (SourceScan == dml_rotation_270 || SourceScan == dml_rotation_90m) {
2408 vp_start_rot = ViewportXStart;
2409 } else if (SourceScan == dml_rotation_90 || SourceScan == dml_rotation_270m) {
2410 vp_start_rot = SwathHeight - (((dml_uint_t)(ViewportYStart + SwathWidth - 1) % SwathHeight) + 1);
2411 } else {
2412 vp_start_rot = ViewportYStart;
2413 }
2414 sw0_tmp = SwathHeight - (vp_start_rot % SwathHeight);
2415 if (sw0_tmp < *VInitPreFill) {
2416 *MaxNumSwath = (dml_uint_t)(dml_ceil((*VInitPreFill - sw0_tmp) / (dml_float_t) SwathHeight, 1) + 1);
2417 } else {
2418 *MaxNumSwath = 1;
2419 }
2420 MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (vp_start_rot + *VInitPreFill - 1) % SwathHeight));
2421 } else {
2422 *MaxNumSwath = (dml_uint_t)(dml_ceil((*VInitPreFill - 1.0) / (dml_float_t) SwathHeight, 1) + 1);
2423 if (*VInitPreFill > 1) {
2424 MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (*VInitPreFill - 2) % SwathHeight));
2425 } else {
2426 MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (*VInitPreFill + SwathHeight - 2) % SwathHeight));
2427 }
2428 }
2429 numLines = *MaxNumSwath * SwathHeight + MaxPartialSwath;
2430
2431#ifdef __DML_VBA_DEBUG__
2432 dml_print("DML::%s: vp_start_rot = %u\n", __func__, vp_start_rot);
2433 dml_print("DML::%s: VInitPreFill = %u\n", __func__, *VInitPreFill);
2434 dml_print("DML::%s: MaxPartialSwath = %u\n", __func__, MaxPartialSwath);
2435 dml_print("DML::%s: MaxNumSwath = %u\n", __func__, *MaxNumSwath);
2436 dml_print("DML::%s: Prefetch source lines = %3.2f\n", __func__, numLines);
2437#endif
2438 return (dml_uint_t)(numLines);
2439
2440} // CalculatePrefetchSourceLines
2441
2442static dml_uint_t CalculateVMAndRowBytes(
2443 dml_bool_t ViewportStationary,
2444 dml_bool_t DCCEnable,
2445 dml_uint_t NumberOfDPPs,
2446 dml_uint_t BlockHeight256Bytes,
2447 dml_uint_t BlockWidth256Bytes,
2448 enum dml_source_format_class SourcePixelFormat,
2449 dml_uint_t SurfaceTiling,
2450 dml_uint_t BytePerPixel,
2451 enum dml_rotation_angle SourceScan,
2452 dml_uint_t SwathWidth,
2453 dml_uint_t ViewportHeight,
2454 dml_uint_t ViewportXStart,
2455 dml_uint_t ViewportYStart,
2456 dml_bool_t GPUVMEnable,
2457 dml_uint_t GPUVMMaxPageTableLevels,
2458 dml_uint_t GPUVMMinPageSizeKBytes,
2459 dml_uint_t PTEBufferSizeInRequests,
2460 dml_uint_t Pitch,
2461 dml_uint_t DCCMetaPitch,
2462 dml_uint_t MacroTileWidth,
2463 dml_uint_t MacroTileHeight,
2464
2465 // Output
2466 dml_uint_t *MetaRowByte,
2467 dml_uint_t *PixelPTEBytesPerRow, // for bandwidth calculation
2468 dml_uint_t *PixelPTEBytesPerRowStorage, // for PTE buffer size check
2469 dml_uint_t *dpte_row_width_ub,
2470 dml_uint_t *dpte_row_height,
2471 dml_uint_t *dpte_row_height_linear,
2472 dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
2473 dml_uint_t *dpte_row_width_ub_one_row_per_frame,
2474 dml_uint_t *dpte_row_height_one_row_per_frame,
2475 dml_uint_t *MetaRequestWidth,
2476 dml_uint_t *MetaRequestHeight,
2477 dml_uint_t *meta_row_width,
2478 dml_uint_t *meta_row_height,
2479 dml_uint_t *PixelPTEReqWidth,
2480 dml_uint_t *PixelPTEReqHeight,
2481 dml_uint_t *PTERequestSize,
2482 dml_uint_t *DPDE0BytesFrame,
2483 dml_uint_t *MetaPTEBytesFrame)
2484{
2485 dml_uint_t MPDEBytesFrame;
2486 dml_uint_t DCCMetaSurfaceBytes;
2487 dml_uint_t ExtraDPDEBytesFrame;
2488 dml_uint_t PDEAndMetaPTEBytesFrame;
2489 dml_uint_t MacroTileSizeBytes;
2490 dml_uint_t vp_height_meta_ub;
2491 dml_uint_t vp_height_dpte_ub;
2492
2493 dml_uint_t PixelPTEReqWidth_linear = 0; // VBA_DELTA. VBA doesn't calculate this
2494
2495 *MetaRequestHeight = 8 * BlockHeight256Bytes;
2496 *MetaRequestWidth = 8 * BlockWidth256Bytes;
2497 if (SurfaceTiling == dml_sw_linear) {
2498 *meta_row_height = 32;
2499 *meta_row_width = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth));
2500 } else if (!dml_is_vertical_rotation(SourceScan)) {
2501 *meta_row_height = *MetaRequestHeight;
2502 if (ViewportStationary && NumberOfDPPs == 1) {
2503 *meta_row_width = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth));
2504 } else {
2505 *meta_row_width = (dml_uint_t)(dml_ceil(SwathWidth - 1, *MetaRequestWidth) + *MetaRequestWidth);
2506 }
2507 *MetaRowByte = (dml_uint_t)(*meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0);
2508 } else {
2509 *meta_row_height = *MetaRequestWidth;
2510 if (ViewportStationary && NumberOfDPPs == 1) {
2511 *meta_row_width = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + *MetaRequestHeight - 1, *MetaRequestHeight) - dml_floor(ViewportYStart, *MetaRequestHeight));
2512 } else {
2513 *meta_row_width = (dml_uint_t)(dml_ceil(SwathWidth - 1, *MetaRequestHeight) + *MetaRequestHeight);
2514 }
2515 *MetaRowByte = (dml_uint_t)(*meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0);
2516 }
2517
2518 if (ViewportStationary && (NumberOfDPPs == 1 || !dml_is_vertical_rotation(SourceScan))) {
2519 vp_height_meta_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + 64 * BlockHeight256Bytes - 1, 64 * BlockHeight256Bytes) - dml_floor(ViewportYStart, 64 * BlockHeight256Bytes));
2520 } else if (!dml_is_vertical_rotation(SourceScan)) {
2521 vp_height_meta_ub = (dml_uint_t)(dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes);
2522 } else {
2523 vp_height_meta_ub = (dml_uint_t)(dml_ceil(SwathWidth - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes);
2524 }
2525
2526 DCCMetaSurfaceBytes = (dml_uint_t)(DCCMetaPitch * vp_height_meta_ub * BytePerPixel / 256.0);
2527
2528 if (GPUVMEnable == true) {
2529 *MetaPTEBytesFrame = (dml_uint_t)((dml_ceil((dml_float_t) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / (8 * 4.0 * 1024), 1) + 1) * 64);
2530 MPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 1);
2531 } else {
2532 *MetaPTEBytesFrame = 0;
2533 MPDEBytesFrame = 0;
2534 }
2535
2536 if (DCCEnable != true) {
2537 *MetaPTEBytesFrame = 0;
2538 MPDEBytesFrame = 0;
2539 *MetaRowByte = 0;
2540 }
2541
2542 MacroTileSizeBytes = MacroTileWidth * BytePerPixel * MacroTileHeight;
2543
2544 if (ViewportStationary && (NumberOfDPPs == 1 || !dml_is_vertical_rotation(SourceScan))) {
2545 vp_height_dpte_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + MacroTileHeight - 1, MacroTileHeight) - dml_floor(ViewportYStart, MacroTileHeight));
2546 } else if (!dml_is_vertical_rotation(SourceScan)) {
2547 vp_height_dpte_ub = (dml_uint_t)(dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight);
2548 } else {
2549 vp_height_dpte_ub = (dml_uint_t)(dml_ceil(SwathWidth - 1, MacroTileHeight) + MacroTileHeight);
2550 }
2551
2552 if (GPUVMEnable == true && GPUVMMaxPageTableLevels > 1) {
2553 *DPDE0BytesFrame = (dml_uint_t)(64 * (dml_ceil((dml_float_t) (Pitch * vp_height_dpte_ub * BytePerPixel - MacroTileSizeBytes) / (dml_float_t) (8 * 2097152), 1) + 1));
2554 ExtraDPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 2);
2555 } else {
2556 *DPDE0BytesFrame = 0;
2557 ExtraDPDEBytesFrame = 0;
2558 }
2559
2560 PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame + ExtraDPDEBytesFrame;
2561
2562#ifdef __DML_VBA_DEBUG__
2563 dml_print("DML::%s: DCCEnable = %u\n", __func__, DCCEnable);
2564 dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2565 dml_print("DML::%s: SwModeLinear = %u\n", __func__, SurfaceTiling == dml_sw_linear);
2566 dml_print("DML::%s: BytePerPixel = %u\n", __func__, BytePerPixel);
2567 dml_print("DML::%s: GPUVMMaxPageTableLevels = %u\n", __func__, GPUVMMaxPageTableLevels);
2568 dml_print("DML::%s: BlockHeight256Bytes = %u\n", __func__, BlockHeight256Bytes);
2569 dml_print("DML::%s: BlockWidth256Bytes = %u\n", __func__, BlockWidth256Bytes);
2570 dml_print("DML::%s: MacroTileHeight = %u\n", __func__, MacroTileHeight);
2571 dml_print("DML::%s: MacroTileWidth = %u\n", __func__, MacroTileWidth);
2572 dml_print("DML::%s: MetaPTEBytesFrame = %u\n", __func__, *MetaPTEBytesFrame);
2573 dml_print("DML::%s: MPDEBytesFrame = %u\n", __func__, MPDEBytesFrame);
2574 dml_print("DML::%s: DPDE0BytesFrame = %u\n", __func__, *DPDE0BytesFrame);
2575 dml_print("DML::%s: ExtraDPDEBytesFrame= %u\n", __func__, ExtraDPDEBytesFrame);
2576 dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, PDEAndMetaPTEBytesFrame);
2577 dml_print("DML::%s: ViewportHeight = %u\n", __func__, ViewportHeight);
2578 dml_print("DML::%s: SwathWidth = %u\n", __func__, SwathWidth);
2579 dml_print("DML::%s: vp_height_dpte_ub = %u\n", __func__, vp_height_dpte_ub);
2580#endif
2581
2582 if (SurfaceTiling == dml_sw_linear) {
2583 *PixelPTEReqHeight = 1;
2584 *PixelPTEReqWidth = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2585 PixelPTEReqWidth_linear = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2586 *PTERequestSize = 64;
2587 } else if (GPUVMMinPageSizeKBytes == 4) {
2588 *PixelPTEReqHeight = 16 * BlockHeight256Bytes;
2589 *PixelPTEReqWidth = 16 * BlockWidth256Bytes;
2590 *PTERequestSize = 128;
2591 } else {
2592 *PixelPTEReqHeight = MacroTileHeight;
2593 *PixelPTEReqWidth = 8 * 1024 * GPUVMMinPageSizeKBytes / (MacroTileHeight * BytePerPixel);
2594 *PTERequestSize = 64;
2595 }
2596#ifdef __DML_VBA_DEBUG__
2597 dml_print("DML::%s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
2598 dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u (after HostVM factor)\n", __func__, PDEAndMetaPTEBytesFrame);
2599 dml_print("DML::%s: PixelPTEReqHeight = %u\n", __func__, *PixelPTEReqHeight);
2600 dml_print("DML::%s: PixelPTEReqWidth = %u\n", __func__, *PixelPTEReqWidth);
2601 dml_print("DML::%s: PixelPTEReqWidth_linear = %u\n", __func__, PixelPTEReqWidth_linear);
2602 dml_print("DML::%s: PTERequestSize = %u\n", __func__, *PTERequestSize);
2603 dml_print("DML::%s: Pitch = %u\n", __func__, Pitch);
2604#endif
2605
2606 *dpte_row_height_one_row_per_frame = vp_height_dpte_ub;
2607 *dpte_row_width_ub_one_row_per_frame = (dml_uint_t)((dml_ceil(((dml_float_t)Pitch * (dml_float_t) *dpte_row_height_one_row_per_frame / (dml_float_t) *PixelPTEReqHeight - 1) / (dml_float_t) *PixelPTEReqWidth, 1) + 1) * (dml_float_t) *PixelPTEReqWidth);
2608 *PixelPTEBytesPerRow_one_row_per_frame = (dml_uint_t)((dml_float_t) *dpte_row_width_ub_one_row_per_frame / (dml_float_t) *PixelPTEReqWidth * *PTERequestSize);
2609
2610 if (SurfaceTiling == dml_sw_linear) {
2611 *dpte_row_height = (dml_uint_t)(dml_min(128, 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1)));
2612 dml_print("DML::%s: dpte_row_height term 1 = %u\n", __func__, PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch);
2613 dml_print("DML::%s: dpte_row_height term 2 = %f\n", __func__, dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch));
2614 dml_print("DML::%s: dpte_row_height term 3 = %f\n", __func__, dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
2615 dml_print("DML::%s: dpte_row_height term 4 = %u\n", __func__, 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
2616 dml_print("DML::%s: dpte_row_height = %u\n", __func__, *dpte_row_height);
2617
2618 *dpte_row_width_ub = (dml_uint_t)(dml_ceil(((dml_float_t) Pitch * (dml_float_t) *dpte_row_height - 1), (dml_float_t) *PixelPTEReqWidth) + *PixelPTEReqWidth);
2619 *PixelPTEBytesPerRow = (dml_uint_t)((dml_float_t) *dpte_row_width_ub / (dml_float_t) *PixelPTEReqWidth * *PTERequestSize);
2620
2621 // VBA_DELTA, VBA doesn't have programming value for pte row height linear.
2622 *dpte_row_height_linear = 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * PixelPTEReqWidth_linear / Pitch), 1);
2623 if (*dpte_row_height_linear > 128)
2624 *dpte_row_height_linear = 128;
2625
2626#ifdef __DML_VBA_DEBUG__
2627 dml_print("DML::%s: dpte_row_width_ub = %u (linear)\n", __func__, *dpte_row_width_ub);
2628#endif
2629
2630 } else if (!dml_is_vertical_rotation(SourceScan)) {
2631 *dpte_row_height = *PixelPTEReqHeight;
2632
2633 if (GPUVMMinPageSizeKBytes > 64) {
2634 *dpte_row_width_ub = (dml_uint_t)((dml_ceil(((dml_float_t) Pitch * (dml_float_t) *dpte_row_height / (dml_float_t) *PixelPTEReqHeight - 1) / (dml_float_t) *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth);
2635 } else if (ViewportStationary && (NumberOfDPPs == 1)) {
2636 *dpte_row_width_ub = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *PixelPTEReqWidth - 1, *PixelPTEReqWidth) - dml_floor(ViewportXStart, *PixelPTEReqWidth));
2637 } else {
2638 *dpte_row_width_ub = (dml_uint_t)((dml_ceil((dml_float_t) (SwathWidth - 1) / (dml_float_t)*PixelPTEReqWidth, 1) + 1.0) * *PixelPTEReqWidth);
2639 }
2640#ifdef __DML_VBA_DEBUG__
2641 dml_print("DML::%s: dpte_row_width_ub = %u (tiled horz)\n", __func__, *dpte_row_width_ub);
2642#endif
2643
2644 ASSERT(*PixelPTEReqWidth);
2645 if (*PixelPTEReqWidth != 0)
2646 *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
2647 } else {
2648 *dpte_row_height = (dml_uint_t)(dml_min(*PixelPTEReqWidth, MacroTileWidth));
2649
2650 if (ViewportStationary && (NumberOfDPPs == 1)) {
2651 *dpte_row_width_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + *PixelPTEReqHeight - 1, *PixelPTEReqHeight) - dml_floor(ViewportYStart, *PixelPTEReqHeight));
2652 } else {
2653 *dpte_row_width_ub = (dml_uint_t)((dml_ceil((dml_float_t) (SwathWidth - 1) / (dml_float_t) *PixelPTEReqHeight, 1) + 1) * *PixelPTEReqHeight);
2654 }
2655
2656 *PixelPTEBytesPerRow = (dml_uint_t)((dml_float_t) *dpte_row_width_ub / (dml_float_t) *PixelPTEReqHeight * *PTERequestSize);
2657#ifdef __DML_VBA_DEBUG__
2658 dml_print("DML::%s: dpte_row_width_ub = %u (tiled vert)\n", __func__, *dpte_row_width_ub);
2659#endif
2660 }
2661
2662 if (GPUVMEnable != true)
2663 *PixelPTEBytesPerRow = 0;
2664
2665 *PixelPTEBytesPerRowStorage = *PixelPTEBytesPerRow;
2666
2667#ifdef __DML_VBA_DEBUG__
2668 dml_print("DML::%s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
2669 dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2670 dml_print("DML::%s: dpte_row_height = %u\n", __func__, *dpte_row_height);
2671 dml_print("DML::%s: dpte_row_height_linear = %u\n", __func__, *dpte_row_height_linear);
2672 dml_print("DML::%s: dpte_row_width_ub = %u\n", __func__, *dpte_row_width_ub);
2673 dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, *PixelPTEBytesPerRow);
2674 dml_print("DML::%s: PixelPTEBytesPerRowStorage = %u\n", __func__, *PixelPTEBytesPerRowStorage);
2675 dml_print("DML::%s: PTEBufferSizeInRequests = %u\n", __func__, PTEBufferSizeInRequests);
2676 dml_print("DML::%s: dpte_row_height_one_row_per_frame = %u\n", __func__, *dpte_row_height_one_row_per_frame);
2677 dml_print("DML::%s: dpte_row_width_ub_one_row_per_frame = %u\n", __func__, *dpte_row_width_ub_one_row_per_frame);
2678 dml_print("DML::%s: PixelPTEBytesPerRow_one_row_per_frame = %u\n", __func__, *PixelPTEBytesPerRow_one_row_per_frame);
2679#endif
2680
2681 dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n", *MetaPTEBytesFrame);
2682
2683 return PDEAndMetaPTEBytesFrame;
2684} // CalculateVMAndRowBytes
2685
2686static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct dml_display_cfg_st *display_cfg, dml_bool_t ptoi_supported)
2687{
2688 dml_uint_t num_active_planes = dml_get_num_active_planes(display_cfg);
2689
2690 //Progressive To Interlace Unit Effect
2691 for (dml_uint_t k = 0; k < num_active_planes; ++k) {
2692 display_cfg->output.PixelClockBackEnd[k] = display_cfg->timing.PixelClock[k];
2693 if (display_cfg->timing.Interlace[k] == 1 && ptoi_supported == true) {
2694 display_cfg->timing.PixelClock[k] = 2 * display_cfg->timing.PixelClock[k];
2695 }
2696 }
2697}
2698
2699static dml_float_t TruncToValidBPP(
2700 dml_float_t LinkBitRate,
2701 dml_uint_t Lanes,
2702 dml_uint_t HTotal,
2703 dml_uint_t HActive,
2704 dml_float_t PixelClock,
2705 dml_float_t DesiredBPP,
2706 dml_bool_t DSCEnable,
2707 enum dml_output_encoder_class Output,
2708 enum dml_output_format_class Format,
2709 dml_uint_t DSCInputBitPerComponent,
2710 dml_uint_t DSCSlices,
2711 dml_uint_t AudioRate,
2712 dml_uint_t AudioLayout,
2713 enum dml_odm_mode ODMModeNoDSC,
2714 enum dml_odm_mode ODMModeDSC,
2715
2716 // Output
2717 dml_uint_t *RequiredSlots)
2718{
2719 dml_float_t MaxLinkBPP;
2720 dml_uint_t MinDSCBPP;
2721 dml_float_t MaxDSCBPP;
2722 dml_uint_t NonDSCBPP0;
2723 dml_uint_t NonDSCBPP1;
2724 dml_uint_t NonDSCBPP2;
2725
2726 if (Format == dml_420) {
2727 NonDSCBPP0 = 12;
2728 NonDSCBPP1 = 15;
2729 NonDSCBPP2 = 18;
2730 MinDSCBPP = 6;
2731 MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1 / 16;
2732 } else if (Format == dml_444) {
2733 NonDSCBPP0 = 24;
2734 NonDSCBPP1 = 30;
2735 NonDSCBPP2 = 36;
2736 MinDSCBPP = 8;
2737 MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16;
2738 } else {
2739 if (Output == dml_hdmi) {
2740 NonDSCBPP0 = 24;
2741 NonDSCBPP1 = 24;
2742 NonDSCBPP2 = 24;
2743 } else {
2744 NonDSCBPP0 = 16;
2745 NonDSCBPP1 = 20;
2746 NonDSCBPP2 = 24;
2747 }
2748 if (Format == dml_n422) {
2749 MinDSCBPP = 7;
2750 MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0;
2751 } else {
2752 MinDSCBPP = 8;
2753 MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0;
2754 }
2755 }
2756
2757 if (Output == dml_dp2p0) {
2758 MaxLinkBPP = LinkBitRate * Lanes / PixelClock * 128.0 / 132.0 * 383.0 / 384.0 * 65536.0 / 65540.0;
2759 } else if (DSCEnable && Output == dml_dp) {
2760 MaxLinkBPP = LinkBitRate / 10.0 * 8.0 * Lanes / PixelClock * (1 - 2.4 / 100);
2761 } else {
2762 MaxLinkBPP = LinkBitRate / 10.0 * 8.0 * Lanes / PixelClock;
2763 }
2764
2765 if (DSCEnable) {
2766 if (ODMModeDSC == dml_odm_mode_combine_4to1) {
2767 MaxLinkBPP = dml_min(MaxLinkBPP, 16);
2768 } else if (ODMModeDSC == dml_odm_mode_combine_2to1) {
2769 MaxLinkBPP = dml_min(MaxLinkBPP, 32);
2770 } else if (ODMModeDSC == dml_odm_mode_split_1to2) {
2771 MaxLinkBPP = 2 * MaxLinkBPP;
2772 }
2773 } else {
2774 if (ODMModeNoDSC == dml_odm_mode_combine_4to1) {
2775 MaxLinkBPP = dml_min(MaxLinkBPP, 16);
2776 } else if (ODMModeNoDSC == dml_odm_mode_combine_2to1) {
2777 MaxLinkBPP = dml_min(MaxLinkBPP, 32);
2778 } else if (ODMModeNoDSC == dml_odm_mode_split_1to2) {
2779 MaxLinkBPP = 2 * MaxLinkBPP;
2780 }
2781 }
2782
2783 if (DesiredBPP == 0) {
2784 if (DSCEnable) {
2785 if (MaxLinkBPP < MinDSCBPP) {
2786 return __DML_DPP_INVALID__;
2787 } else if (MaxLinkBPP >= MaxDSCBPP) {
2788 return MaxDSCBPP;
2789 } else {
2790 return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0;
2791 }
2792 } else {
2793 if (MaxLinkBPP >= NonDSCBPP2) {
2794 return NonDSCBPP2;
2795 } else if (MaxLinkBPP >= NonDSCBPP1) {
2796 return NonDSCBPP1;
2797 } else if (MaxLinkBPP >= NonDSCBPP0) {
2798 return NonDSCBPP0;
2799 } else {
2800 return __DML_DPP_INVALID__;
2801 }
2802 }
2803 } else {
2804 if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 || DesiredBPP == NonDSCBPP0)) ||
2805 (DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP))) {
2806 return __DML_DPP_INVALID__;
2807 } else {
2808 return DesiredBPP;
2809 }
2810 }
2811
2812 *RequiredSlots = (dml_uint_t)(dml_ceil(DesiredBPP / MaxLinkBPP * 64, 1));
2813
2814 return __DML_DPP_INVALID__;
2815} // TruncToValidBPP
2816
2817static void CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
2818 struct display_mode_lib_scratch_st *scratch,
2819 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *p)
2820{
2821 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_locals_st *s = &scratch->CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_locals;
2822
2823 s->TotalActiveWriteback = 0;
2824 p->Watermark->UrgentWatermark = p->mmSOCParameters.UrgentLatency + p->mmSOCParameters.ExtraLatency;
2825 p->Watermark->USRRetrainingWatermark = p->mmSOCParameters.UrgentLatency + p->mmSOCParameters.ExtraLatency + p->mmSOCParameters.USRRetrainingLatency + p->mmSOCParameters.SMNLatency;
2826 p->Watermark->DRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->Watermark->UrgentWatermark;
2827 p->Watermark->FCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->Watermark->UrgentWatermark;
2828 p->Watermark->StutterExitWatermark = p->mmSOCParameters.SRExitTime + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2829 p->Watermark->StutterEnterPlusExitWatermark = p->mmSOCParameters.SREnterPlusExitTime + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2830 p->Watermark->Z8StutterExitWatermark = p->mmSOCParameters.SRExitZ8Time + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2831 p->Watermark->Z8StutterEnterPlusExitWatermark = p->mmSOCParameters.SREnterPlusExitZ8Time + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2832
2833#ifdef __DML_VBA_DEBUG__
2834 dml_print("DML::%s: UrgentLatency = %f\n", __func__, p->mmSOCParameters.UrgentLatency);
2835 dml_print("DML::%s: ExtraLatency = %f\n", __func__, p->mmSOCParameters.ExtraLatency);
2836 dml_print("DML::%s: DRAMClockChangeLatency = %f\n", __func__, p->mmSOCParameters.DRAMClockChangeLatency);
2837 dml_print("DML::%s: UrgentWatermark = %f\n", __func__, p->Watermark->UrgentWatermark);
2838 dml_print("DML::%s: USRRetrainingWatermark = %f\n", __func__, p->Watermark->USRRetrainingWatermark);
2839 dml_print("DML::%s: DRAMClockChangeWatermark = %f\n", __func__, p->Watermark->DRAMClockChangeWatermark);
2840 dml_print("DML::%s: FCLKChangeWatermark = %f\n", __func__, p->Watermark->FCLKChangeWatermark);
2841 dml_print("DML::%s: StutterExitWatermark = %f\n", __func__, p->Watermark->StutterExitWatermark);
2842 dml_print("DML::%s: StutterEnterPlusExitWatermark = %f\n", __func__, p->Watermark->StutterEnterPlusExitWatermark);
2843 dml_print("DML::%s: Z8StutterExitWatermark = %f\n", __func__, p->Watermark->Z8StutterExitWatermark);
2844 dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, p->Watermark->Z8StutterEnterPlusExitWatermark);
2845#endif
2846
2847 s->TotalActiveWriteback = 0;
2848 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2849 if (p->WritebackEnable[k] == true) {
2850 s->TotalActiveWriteback = s->TotalActiveWriteback + 1;
2851 }
2852 }
2853
2854 if (s->TotalActiveWriteback <= 1) {
2855 p->Watermark->WritebackUrgentWatermark = p->mmSOCParameters.WritebackLatency;
2856 } else {
2857 p->Watermark->WritebackUrgentWatermark = p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024.0 / 32.0 / p->SOCCLK;
2858 }
2859 if (p->USRRetrainingRequiredFinal)
2860 p->Watermark->WritebackUrgentWatermark = p->Watermark->WritebackUrgentWatermark + p->mmSOCParameters.USRRetrainingLatency;
2861
2862 if (s->TotalActiveWriteback <= 1) {
2863 p->Watermark->WritebackDRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.WritebackLatency;
2864 p->Watermark->WritebackFCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->mmSOCParameters.WritebackLatency;
2865 } else {
2866 p->Watermark->WritebackDRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024.0 / 32.0 / p->SOCCLK;
2867 p->Watermark->WritebackFCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024 / 32 / p->SOCCLK;
2868 }
2869
2870 if (p->USRRetrainingRequiredFinal)
2871 p->Watermark->WritebackDRAMClockChangeWatermark = p->Watermark->WritebackDRAMClockChangeWatermark + p->mmSOCParameters.USRRetrainingLatency;
2872
2873 if (p->USRRetrainingRequiredFinal)
2874 p->Watermark->WritebackFCLKChangeWatermark = p->Watermark->WritebackFCLKChangeWatermark + p->mmSOCParameters.USRRetrainingLatency;
2875
2876#ifdef __DML_VBA_DEBUG__
2877 dml_print("DML::%s: WritebackDRAMClockChangeWatermark = %f\n", __func__, p->Watermark->WritebackDRAMClockChangeWatermark);
2878 dml_print("DML::%s: WritebackFCLKChangeWatermark = %f\n", __func__, p->Watermark->WritebackFCLKChangeWatermark);
2879 dml_print("DML::%s: WritebackUrgentWatermark = %f\n", __func__, p->Watermark->WritebackUrgentWatermark);
2880 dml_print("DML::%s: USRRetrainingRequiredFinal = %u\n", __func__, p->USRRetrainingRequiredFinal);
2881 dml_print("DML::%s: USRRetrainingLatency = %f\n", __func__, p->mmSOCParameters.USRRetrainingLatency);
2882#endif
2883
2884 s->TotalPixelBW = 0.0;
2885 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2886 s->TotalPixelBW = s->TotalPixelBW + p->DPPPerSurface[k]
2887 * (p->SwathWidthY[k] * p->BytePerPixelDETY[k] * p->VRatio[k] + p->SwathWidthC[k] * p->BytePerPixelDETC[k] * p->VRatioChroma[k]) / (p->HTotal[k] / p->PixelClock[k]);
2888 }
2889
2890 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2891
2892 s->LBLatencyHidingSourceLinesY[k] = (dml_uint_t)(dml_min((dml_float_t)p->MaxLineBufferLines, dml_floor((dml_float_t)p->LineBufferSize / (dml_float_t)p->LBBitPerPixel[k] / ((dml_float_t)p->SwathWidthY[k] / dml_max(p->HRatio[k], 1.0)), 1)) - (p->VTaps[k] - 1));
2893 s->LBLatencyHidingSourceLinesC[k] = (dml_uint_t)(dml_min((dml_float_t)p->MaxLineBufferLines, dml_floor((dml_float_t)p->LineBufferSize / (dml_float_t)p->LBBitPerPixel[k] / ((dml_float_t)p->SwathWidthC[k] / dml_max(p->HRatioChroma[k], 1.0)), 1)) - (p->VTapsChroma[k] - 1));
2894
2895
2896#ifdef __DML_VBA_DEBUG__
2897 dml_print("DML::%s: k=%u, MaxLineBufferLines = %u\n", __func__, k, p->MaxLineBufferLines);
2898 dml_print("DML::%s: k=%u, LineBufferSize = %u\n", __func__, k, p->LineBufferSize);
2899 dml_print("DML::%s: k=%u, LBBitPerPixel = %u\n", __func__, k, p->LBBitPerPixel[k]);
2900 dml_print("DML::%s: k=%u, HRatio = %f\n", __func__, k, p->HRatio[k]);
2901 dml_print("DML::%s: k=%u, VTaps = %u\n", __func__, k, p->VTaps[k]);
2902#endif
2903
2904 s->EffectiveLBLatencyHidingY = s->LBLatencyHidingSourceLinesY[k] / p->VRatio[k] * (p->HTotal[k] / p->PixelClock[k]);
2905 s->EffectiveLBLatencyHidingC = s->LBLatencyHidingSourceLinesC[k] / p->VRatioChroma[k] * (p->HTotal[k] / p->PixelClock[k]);
2906
2907 s->EffectiveDETBufferSizeY = p->DETBufferSizeY[k];
2908 if (p->UnboundedRequestEnabled) {
2909 s->EffectiveDETBufferSizeY = s->EffectiveDETBufferSizeY + p->CompressedBufferSizeInkByte * 1024 * (p->SwathWidthY[k] * p->BytePerPixelDETY[k] * p->VRatio[k]) / (p->HTotal[k] / p->PixelClock[k]) / s->TotalPixelBW;
2910 }
2911
2912 s->LinesInDETY[k] = (dml_float_t)s->EffectiveDETBufferSizeY / p->BytePerPixelDETY[k] / p->SwathWidthY[k];
2913 s->LinesInDETYRoundedDownToSwath[k] = (dml_uint_t)(dml_floor(s->LinesInDETY[k], p->SwathHeightY[k]));
2914 s->FullDETBufferingTimeY = s->LinesInDETYRoundedDownToSwath[k] * (p->HTotal[k] / p->PixelClock[k]) / p->VRatio[k];
2915
2916 s->ActiveClockChangeLatencyHidingY = s->EffectiveLBLatencyHidingY + s->FullDETBufferingTimeY - ((dml_float_t)p->DSTXAfterScaler[k] / (dml_float_t)p->HTotal[k] + (dml_float_t)p->DSTYAfterScaler[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
2917
2918 if (p->NumberOfActiveSurfaces > 1) {
2919 s->ActiveClockChangeLatencyHidingY = s->ActiveClockChangeLatencyHidingY - (1.0 - 1.0 / (dml_float_t)p->NumberOfActiveSurfaces) * (dml_float_t)p->SwathHeightY[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k] / p->VRatio[k];
2920 }
2921
2922 if (p->BytePerPixelDETC[k] > 0) {
2923 s->LinesInDETC[k] = p->DETBufferSizeC[k] / p->BytePerPixelDETC[k] / p->SwathWidthC[k];
2924 s->LinesInDETCRoundedDownToSwath[k] = (dml_uint_t)(dml_floor(s->LinesInDETC[k], p->SwathHeightC[k]));
2925 s->FullDETBufferingTimeC = s->LinesInDETCRoundedDownToSwath[k] * (p->HTotal[k] / p->PixelClock[k]) / p->VRatioChroma[k];
2926 s->ActiveClockChangeLatencyHidingC = s->EffectiveLBLatencyHidingC + s->FullDETBufferingTimeC - ((dml_float_t)p->DSTXAfterScaler[k] / (dml_float_t)p->HTotal[k] + (dml_float_t)p->DSTYAfterScaler[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
2927 if (p->NumberOfActiveSurfaces > 1) {
2928 s->ActiveClockChangeLatencyHidingC = s->ActiveClockChangeLatencyHidingC - (1.0 - 1.0 / (dml_float_t)p->NumberOfActiveSurfaces) * (dml_float_t)p->SwathHeightC[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k] / p->VRatioChroma[k];
2929 }
2930 s->ActiveClockChangeLatencyHiding = dml_min(s->ActiveClockChangeLatencyHidingY, s->ActiveClockChangeLatencyHidingC);
2931 } else {
2932 s->ActiveClockChangeLatencyHiding = s->ActiveClockChangeLatencyHidingY;
2933 }
2934
2935 s->ActiveDRAMClockChangeLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->UrgentWatermark - p->Watermark->DRAMClockChangeWatermark;
2936 s->ActiveFCLKChangeLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->UrgentWatermark - p->Watermark->FCLKChangeWatermark;
2937 s->USRRetrainingLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->USRRetrainingWatermark;
2938
2939 if (p->WritebackEnable[k]) {
2940 s->WritebackLatencyHiding = (dml_float_t)p->WritebackInterfaceBufferSize * 1024.0 / ((dml_float_t)p->WritebackDestinationWidth[k] * (dml_float_t)p->WritebackDestinationHeight[k] / ((dml_float_t)p->WritebackSourceHeight[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k]) * 4.0);
2941 if (p->WritebackPixelFormat[k] == dml_444_64) {
2942 s->WritebackLatencyHiding = s->WritebackLatencyHiding / 2;
2943 }
2944 s->WritebackDRAMClockChangeLatencyMargin = s->WritebackLatencyHiding - p->Watermark->WritebackDRAMClockChangeWatermark;
2945
2946 s->WritebackFCLKChangeLatencyMargin = s->WritebackLatencyHiding - p->Watermark->WritebackFCLKChangeWatermark;
2947
2948 s->ActiveDRAMClockChangeLatencyMargin[k] = dml_min(s->ActiveDRAMClockChangeLatencyMargin[k], s->WritebackFCLKChangeLatencyMargin);
2949 s->ActiveFCLKChangeLatencyMargin[k] = dml_min(s->ActiveFCLKChangeLatencyMargin[k], s->WritebackDRAMClockChangeLatencyMargin);
2950 }
2951 p->MaxActiveDRAMClockChangeLatencySupported[k] = (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) ? 0 : (s->ActiveDRAMClockChangeLatencyMargin[k] + p->mmSOCParameters.DRAMClockChangeLatency);
2952 p->ActiveDRAMClockChangeLatencyMargin[k] = s->ActiveDRAMClockChangeLatencyMargin[k];
2953 }
2954
2955 *p->USRRetrainingSupport = true;
2956 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2957 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) && (s->USRRetrainingLatencyMargin[k] < 0)) {
2958 *p->USRRetrainingSupport = false;
2959 }
2960 }
2961
2962 s->FoundCriticalSurface = false;
2963 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2964 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) && ((!s->FoundCriticalSurface)
2965 || ((s->ActiveFCLKChangeLatencyMargin[k] + p->mmSOCParameters.FCLKChangeLatency) < *p->MaxActiveFCLKChangeLatencySupported))) {
2966 s->FoundCriticalSurface = true;
2967 *p->MaxActiveFCLKChangeLatencySupported = s->ActiveFCLKChangeLatencyMargin[k] + p->mmSOCParameters.FCLKChangeLatency;
2968 }
2969 }
2970
2971 for (dml_uint_t i = 0; i < p->NumberOfActiveSurfaces; ++i) {
2972 for (dml_uint_t j = 0; j < p->NumberOfActiveSurfaces; ++j) {
2973 if (i == j ||
2974 (p->BlendingAndTiming[i] == i && p->BlendingAndTiming[j] == i) ||
2975 (p->BlendingAndTiming[j] == j && p->BlendingAndTiming[i] == j) ||
2976 (p->BlendingAndTiming[i] == p->BlendingAndTiming[j] && p->BlendingAndTiming[i] != i) ||
2977 (p->SynchronizeTimingsFinal && p->PixelClock[i] == p->PixelClock[j] && p->HTotal[i] == p->HTotal[j] && p->VTotal[i] == p->VTotal[j] && p->VActive[i] == p->VActive[j]) ||
2978 (p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && (p->DRRDisplay[i] || p->DRRDisplay[j]))) {
2979 s->SynchronizedSurfaces[i][j] = true;
2980 } else {
2981 s->SynchronizedSurfaces[i][j] = false;
2982 }
2983 }
2984 }
2985
2986 s->FCLKChangeSupportNumber = 0;
2987 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2988 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) && (s->ActiveFCLKChangeLatencyMargin[k] < 0)) {
2989 if (!(p->PrefetchMode[k] <= 1)) {
2990 s->FCLKChangeSupportNumber = 3;
2991 } else if (s->FCLKChangeSupportNumber == 0) {
2992 s->FCLKChangeSupportNumber = ((p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && p->DRRDisplay[k]) ? 2 : 1);
2993 s->LastSurfaceWithoutMargin = k;
2994 } else if (((s->FCLKChangeSupportNumber == 1) && (p->DRRDisplay[k] || (!s->SynchronizedSurfaces[s->LastSurfaceWithoutMargin][k]))) || (s->FCLKChangeSupportNumber == 2))
2995 s->FCLKChangeSupportNumber = 3;
2996 }
2997 }
2998
2999 if (s->FCLKChangeSupportNumber == 0) {
3000 *p->FCLKChangeSupport = dml_fclock_change_vactive;
3001 } else if ((s->FCLKChangeSupportNumber == 1) || (s->FCLKChangeSupportNumber == 2)) {
3002 *p->FCLKChangeSupport = dml_fclock_change_vblank;
3003 } else {
3004 *p->FCLKChangeSupport = dml_fclock_change_unsupported;
3005 }
3006
3007 s->DRAMClockChangeMethod = 0;
3008 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3009 if (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame)
3010 s->DRAMClockChangeMethod = 1;
3011 else if (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport)
3012 s->DRAMClockChangeMethod = 2;
3013 }
3014
3015 s->DRAMClockChangeSupportNumber = 0;
3016 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3017 if (((s->DRAMClockChangeMethod == 0) && (s->ActiveDRAMClockChangeLatencyMargin[k] < 0)) ||
3018 ((s->DRAMClockChangeMethod == 1) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_full_frame)) ||
3019 ((s->DRAMClockChangeMethod == 2) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_sub_viewport) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe))) {
3020 if (p->PrefetchMode[k] != 0) { // Don't need to support DRAM clock change, PrefetchMode 0 means needs DRAM clock change support
3021 s->DRAMClockChangeSupportNumber = 3;
3022 } else if (s->DRAMClockChangeSupportNumber == 0) {
3023 s->DRAMClockChangeSupportNumber = (p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && p->DRRDisplay[k]) ? 2 : 1;
3024 s->LastSurfaceWithoutMargin = k;
3025 } else if (((s->DRAMClockChangeSupportNumber == 1) && (p->DRRDisplay[k] || !s->SynchronizedSurfaces[s->LastSurfaceWithoutMargin][k])) || (s->DRAMClockChangeSupportNumber == 2)) {
3026 s->DRAMClockChangeSupportNumber = 3;
3027 }
3028 }
3029 }
3030
3031 if (s->DRAMClockChangeMethod == 0) { // No MALL usage
3032 if (s->DRAMClockChangeSupportNumber == 0) {
3033 *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive;
3034 } else if (s->DRAMClockChangeSupportNumber == 1) {
3035 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank;
3036 } else if (s->DRAMClockChangeSupportNumber == 2) {
3037 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr;
3038 } else {
3039 *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3040 }
3041 } else if (s->DRAMClockChangeMethod == 1) { // Any pipe using MALL full frame
3042 if (s->DRAMClockChangeSupportNumber == 0) {
3043 *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive_w_mall_full_frame;
3044 } else if (s->DRAMClockChangeSupportNumber == 1) {
3045 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_w_mall_full_frame;
3046 } else if (s->DRAMClockChangeSupportNumber == 2) {
3047 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr_w_mall_full_frame;
3048 } else {
3049 *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3050 }
3051 } else { // Any pipe using MALL subviewport
3052 if (s->DRAMClockChangeSupportNumber == 0) {
3053 *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive_w_mall_sub_vp;
3054 } else if (s->DRAMClockChangeSupportNumber == 1) {
3055 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_w_mall_sub_vp;
3056 } else if (s->DRAMClockChangeSupportNumber == 2) {
3057 *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr_w_mall_sub_vp;
3058 } else {
3059 *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3060 }
3061 }
3062
3063 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3064 s->dst_y_pstate = (dml_uint_t)(dml_ceil((p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.UrgentLatency) / (p->HTotal[k] / p->PixelClock[k]), 1));
3065 s->src_y_pstate_l = (dml_uint_t)(dml_ceil(s->dst_y_pstate * p->VRatio[k], p->SwathHeightY[k]));
3066 s->src_y_ahead_l = (dml_uint_t)(dml_floor(p->DETBufferSizeY[k] / p->BytePerPixelDETY[k] / p->SwathWidthY[k], p->SwathHeightY[k]) + s->LBLatencyHidingSourceLinesY[k]);
3067 s->sub_vp_lines_l = s->src_y_pstate_l + s->src_y_ahead_l + p->meta_row_height[k];
3068
3069#ifdef __DML_VBA_DEBUG__
3070 dml_print("DML::%s: k=%u, DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
3071 dml_print("DML::%s: k=%u, BytePerPixelDETY = %f\n", __func__, k, p->BytePerPixelDETY[k]);
3072 dml_print("DML::%s: k=%u, SwathWidthY = %u\n", __func__, k, p->SwathWidthY[k]);
3073 dml_print("DML::%s: k=%u, SwathHeightY = %u\n", __func__, k, p->SwathHeightY[k]);
3074 dml_print("DML::%s: k=%u, LBLatencyHidingSourceLinesY = %u\n", __func__, k, s->LBLatencyHidingSourceLinesY[k]);
3075 dml_print("DML::%s: k=%u, dst_y_pstate = %u\n", __func__, k, s->dst_y_pstate);
3076 dml_print("DML::%s: k=%u, src_y_pstate_l = %u\n", __func__, k, s->src_y_pstate_l);
3077 dml_print("DML::%s: k=%u, src_y_ahead_l = %u\n", __func__, k, s->src_y_ahead_l);
3078 dml_print("DML::%s: k=%u, meta_row_height = %u\n", __func__, k, p->meta_row_height[k]);
3079 dml_print("DML::%s: k=%u, sub_vp_lines_l = %u\n", __func__, k, s->sub_vp_lines_l);
3080#endif
3081 p->SubViewportLinesNeededInMALL[k] = s->sub_vp_lines_l;
3082
3083 if (p->BytePerPixelDETC[k] > 0) {
3084 s->src_y_pstate_c = (dml_uint_t)(dml_ceil(s->dst_y_pstate * p->VRatioChroma[k], p->SwathHeightC[k]));
3085 s->src_y_ahead_c = (dml_uint_t)(dml_floor(p->DETBufferSizeC[k] / p->BytePerPixelDETC[k] / p->SwathWidthC[k], p->SwathHeightC[k]) + s->LBLatencyHidingSourceLinesC[k]);
3086 s->sub_vp_lines_c = s->src_y_pstate_c + s->src_y_ahead_c + p->meta_row_height_chroma[k];
3087 p->SubViewportLinesNeededInMALL[k] = (dml_uint_t)(dml_max(s->sub_vp_lines_l, s->sub_vp_lines_c));
3088
3089#ifdef __DML_VBA_DEBUG__
3090 dml_print("DML::%s: k=%u, src_y_pstate_c = %u\n", __func__, k, s->src_y_pstate_c);
3091 dml_print("DML::%s: k=%u, src_y_ahead_c = %u\n", __func__, k, s->src_y_ahead_c);
3092 dml_print("DML::%s: k=%u, meta_row_height_chroma = %u\n", __func__, k, p->meta_row_height_chroma[k]);
3093 dml_print("DML::%s: k=%u, sub_vp_lines_c = %u\n", __func__, k, s->sub_vp_lines_c);
3094#endif
3095 }
3096 }
3097
3098#ifdef __DML_VBA_DEBUG__
3099 dml_print("DML::%s: DRAMClockChangeSupport = %u\n", __func__, *p->DRAMClockChangeSupport);
3100 dml_print("DML::%s: FCLKChangeSupport = %u\n", __func__, *p->FCLKChangeSupport);
3101 dml_print("DML::%s: MaxActiveFCLKChangeLatencySupported = %f\n", __func__, *p->MaxActiveFCLKChangeLatencySupported);
3102 dml_print("DML::%s: USRRetrainingSupport = %u\n", __func__, *p->USRRetrainingSupport);
3103#endif
3104} // CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport
3105
3106static void CalculateDCFCLKDeepSleep(
3107 dml_uint_t NumberOfActiveSurfaces,
3108 dml_uint_t BytePerPixelY[],
3109 dml_uint_t BytePerPixelC[],
3110 dml_float_t VRatio[],
3111 dml_float_t VRatioChroma[],
3112 dml_uint_t SwathWidthY[],
3113 dml_uint_t SwathWidthC[],
3114 dml_uint_t DPPPerSurface[],
3115 dml_float_t HRatio[],
3116 dml_float_t HRatioChroma[],
3117 dml_float_t PixelClock[],
3118 dml_float_t PSCL_THROUGHPUT[],
3119 dml_float_t PSCL_THROUGHPUT_CHROMA[],
3120 dml_float_t Dppclk[],
3121 dml_float_t ReadBandwidthLuma[],
3122 dml_float_t ReadBandwidthChroma[],
3123 dml_uint_t ReturnBusWidth,
3124
3125 // Output
3126 dml_float_t *DCFClkDeepSleep)
3127{
3128 dml_float_t DisplayPipeLineDeliveryTimeLuma;
3129 dml_float_t DisplayPipeLineDeliveryTimeChroma;
3130 dml_float_t DCFClkDeepSleepPerSurface[__DML_NUM_PLANES__];
3131 dml_float_t ReadBandwidth = 0.0;
3132
3133 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3134
3135 if (VRatio[k] <= 1) {
3136 DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3137 } else {
3138 DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3139 }
3140 if (BytePerPixelC[k] == 0) {
3141 DisplayPipeLineDeliveryTimeChroma = 0;
3142 } else {
3143 if (VRatioChroma[k] <= 1) {
3144 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3145 } else {
3146 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3147 }
3148 }
3149
3150 if (BytePerPixelC[k] > 0) {
3151 DCFClkDeepSleepPerSurface[k] = dml_max(__DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma,
3152 __DML_MIN_DCFCLK_FACTOR__ * SwathWidthC[k] * BytePerPixelC[k] / 32.0 / DisplayPipeLineDeliveryTimeChroma);
3153 } else {
3154 DCFClkDeepSleepPerSurface[k] = __DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] / 64.0 / DisplayPipeLineDeliveryTimeLuma;
3155 }
3156 DCFClkDeepSleepPerSurface[k] = dml_max(DCFClkDeepSleepPerSurface[k], PixelClock[k] / 16);
3157
3158#ifdef __DML_VBA_DEBUG__
3159 dml_print("DML::%s: k=%u, PixelClock = %f\n", __func__, k, PixelClock[k]);
3160 dml_print("DML::%s: k=%u, DCFClkDeepSleepPerSurface = %f\n", __func__, k, DCFClkDeepSleepPerSurface[k]);
3161#endif
3162 }
3163
3164 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3165 ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
3166 }
3167
3168 *DCFClkDeepSleep = dml_max(8.0, __DML_MIN_DCFCLK_FACTOR__ * ReadBandwidth / (dml_float_t) ReturnBusWidth);
3169
3170#ifdef __DML_VBA_DEBUG__
3171 dml_print("DML::%s: __DML_MIN_DCFCLK_FACTOR__ = %f\n", __func__, __DML_MIN_DCFCLK_FACTOR__);
3172 dml_print("DML::%s: ReadBandwidth = %f\n", __func__, ReadBandwidth);
3173 dml_print("DML::%s: ReturnBusWidth = %u\n", __func__, ReturnBusWidth);
3174 dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, *DCFClkDeepSleep);
3175#endif
3176
3177 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3178 *DCFClkDeepSleep = dml_max(*DCFClkDeepSleep, DCFClkDeepSleepPerSurface[k]);
3179 }
3180 dml_print("DML::%s: DCFClkDeepSleep = %f (final)\n", __func__, *DCFClkDeepSleep);
3181} // CalculateDCFCLKDeepSleep
3182
3183static void CalculateUrgentBurstFactor(
3184 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
3185 dml_uint_t swath_width_luma_ub,
3186 dml_uint_t swath_width_chroma_ub,
3187 dml_uint_t SwathHeightY,
3188 dml_uint_t SwathHeightC,
3189 dml_float_t LineTime,
3190 dml_float_t UrgentLatency,
3191 dml_float_t CursorBufferSize,
3192 dml_uint_t CursorWidth,
3193 dml_uint_t CursorBPP,
3194 dml_float_t VRatio,
3195 dml_float_t VRatioC,
3196 dml_float_t BytePerPixelInDETY,
3197 dml_float_t BytePerPixelInDETC,
3198 dml_uint_t DETBufferSizeY,
3199 dml_uint_t DETBufferSizeC,
3200 // Output
3201 dml_float_t *UrgentBurstFactorCursor,
3202 dml_float_t *UrgentBurstFactorLuma,
3203 dml_float_t *UrgentBurstFactorChroma,
3204 dml_bool_t *NotEnoughUrgentLatencyHiding)
3205{
3206 dml_float_t LinesInDETLuma;
3207 dml_float_t LinesInDETChroma;
3208 dml_uint_t LinesInCursorBuffer;
3209 dml_float_t CursorBufferSizeInTime;
3210 dml_float_t DETBufferSizeInTimeLuma;
3211 dml_float_t DETBufferSizeInTimeChroma;
3212
3213 *NotEnoughUrgentLatencyHiding = 0;
3214
3215 if (CursorWidth > 0) {
3216 LinesInCursorBuffer = 1 << (dml_uint_t) dml_floor(dml_log2(CursorBufferSize * 1024.0 / (CursorWidth * CursorBPP / 8.0)), 1.0);
3217 if (VRatio > 0) {
3218 CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio;
3219 if (CursorBufferSizeInTime - UrgentLatency <= 0) {
3220 *NotEnoughUrgentLatencyHiding = 1;
3221 *UrgentBurstFactorCursor = 0;
3222 } else {
3223 *UrgentBurstFactorCursor = CursorBufferSizeInTime / (CursorBufferSizeInTime - UrgentLatency);
3224 }
3225 } else {
3226 *UrgentBurstFactorCursor = 1;
3227 }
3228 }
3229
3230 LinesInDETLuma = (UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe ? 1024*1024 : DETBufferSizeY) / BytePerPixelInDETY / swath_width_luma_ub;
3231
3232 if (VRatio > 0) {
3233 DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio;
3234 if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) {
3235 *NotEnoughUrgentLatencyHiding = 1;
3236 *UrgentBurstFactorLuma = 0;
3237 } else {
3238 *UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency);
3239 }
3240 } else {
3241 *UrgentBurstFactorLuma = 1;
3242 }
3243
3244 if (BytePerPixelInDETC > 0) {
3245 LinesInDETChroma = (UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe ? 1024*1024 : DETBufferSizeC) / BytePerPixelInDETC / swath_width_chroma_ub;
3246
3247 if (VRatioC > 0) {
3248 DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatioC;
3249 if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) {
3250 *NotEnoughUrgentLatencyHiding = 1;
3251 *UrgentBurstFactorChroma = 0;
3252 } else {
3253 *UrgentBurstFactorChroma = DETBufferSizeInTimeChroma / (DETBufferSizeInTimeChroma - UrgentLatency);
3254 }
3255 } else {
3256 *UrgentBurstFactorChroma = 1;
3257 }
3258 }
3259} // CalculateUrgentBurstFactor
3260
3261static void CalculatePixelDeliveryTimes(
3262 dml_uint_t NumberOfActiveSurfaces,
3263 dml_float_t VRatio[],
3264 dml_float_t VRatioChroma[],
3265 dml_float_t VRatioPrefetchY[],
3266 dml_float_t VRatioPrefetchC[],
3267 dml_uint_t swath_width_luma_ub[],
3268 dml_uint_t swath_width_chroma_ub[],
3269 dml_uint_t DPPPerSurface[],
3270 dml_float_t HRatio[],
3271 dml_float_t HRatioChroma[],
3272 dml_float_t PixelClock[],
3273 dml_float_t PSCL_THROUGHPUT[],
3274 dml_float_t PSCL_THROUGHPUT_CHROMA[],
3275 dml_float_t Dppclk[],
3276 dml_uint_t BytePerPixelC[],
3277 enum dml_rotation_angle SourceScan[],
3278 dml_uint_t NumberOfCursors[],
3279 dml_uint_t CursorWidth[],
3280 dml_uint_t CursorBPP[],
3281 dml_uint_t BlockWidth256BytesY[],
3282 dml_uint_t BlockHeight256BytesY[],
3283 dml_uint_t BlockWidth256BytesC[],
3284 dml_uint_t BlockHeight256BytesC[],
3285
3286 // Output
3287 dml_float_t DisplayPipeLineDeliveryTimeLuma[],
3288 dml_float_t DisplayPipeLineDeliveryTimeChroma[],
3289 dml_float_t DisplayPipeLineDeliveryTimeLumaPrefetch[],
3290 dml_float_t DisplayPipeLineDeliveryTimeChromaPrefetch[],
3291 dml_float_t DisplayPipeRequestDeliveryTimeLuma[],
3292 dml_float_t DisplayPipeRequestDeliveryTimeChroma[],
3293 dml_float_t DisplayPipeRequestDeliveryTimeLumaPrefetch[],
3294 dml_float_t DisplayPipeRequestDeliveryTimeChromaPrefetch[],
3295 dml_float_t CursorRequestDeliveryTime[],
3296 dml_float_t CursorRequestDeliveryTimePrefetch[])
3297{
3298 dml_float_t req_per_swath_ub;
3299
3300 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3301
3302#ifdef __DML_VBA_DEBUG__
3303 dml_print("DML::%s: k=%u : HRatio = %f\n", __func__, k, HRatio[k]);
3304 dml_print("DML::%s: k=%u : VRatio = %f\n", __func__, k, VRatio[k]);
3305 dml_print("DML::%s: k=%u : HRatioChroma = %f\n", __func__, k, HRatioChroma[k]);
3306 dml_print("DML::%s: k=%u : VRatioChroma = %f\n", __func__, k, VRatioChroma[k]);
3307 dml_print("DML::%s: k=%u : swath_width_luma_ub = %u\n", __func__, k, swath_width_luma_ub[k]);
3308 dml_print("DML::%s: k=%u : swath_width_chroma_ub = %u\n", __func__, k, swath_width_chroma_ub[k]);
3309 dml_print("DML::%s: k=%u : PSCL_THROUGHPUT = %f\n", __func__, k, PSCL_THROUGHPUT[k]);
3310 dml_print("DML::%s: k=%u : PSCL_THROUGHPUT_CHROMA = %f\n", __func__, k, PSCL_THROUGHPUT_CHROMA[k]);
3311 dml_print("DML::%s: k=%u : DPPPerSurface = %u\n", __func__, k, DPPPerSurface[k]);
3312 dml_print("DML::%s: k=%u : PixelClock = %f\n", __func__, k, PixelClock[k]);
3313 dml_print("DML::%s: k=%u : Dppclk = %f\n", __func__, k, Dppclk[k]);
3314#endif
3315
3316 if (VRatio[k] <= 1) {
3317 DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3318 } else {
3319 DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3320 }
3321
3322 if (BytePerPixelC[k] == 0) {
3323 DisplayPipeLineDeliveryTimeChroma[k] = 0;
3324 } else {
3325 if (VRatioChroma[k] <= 1) {
3326 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3327 } else {
3328 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3329 }
3330 }
3331
3332 if (VRatioPrefetchY[k] <= 1) {
3333 DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3334 } else {
3335 DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3336 }
3337
3338 if (BytePerPixelC[k] == 0) {
3339 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
3340 } else {
3341 if (VRatioPrefetchC[k] <= 1) {
3342 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3343 } else {
3344 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3345 }
3346 }
3347#ifdef __DML_VBA_DEBUG__
3348 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeLuma = %f\n", __func__, k, DisplayPipeLineDeliveryTimeLuma[k]);
3349 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeLumaPrefetch = %f\n", __func__, k, DisplayPipeLineDeliveryTimeLumaPrefetch[k]);
3350 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeChroma = %f\n", __func__, k, DisplayPipeLineDeliveryTimeChroma[k]);
3351 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeChromaPrefetch = %f\n", __func__, k, DisplayPipeLineDeliveryTimeChromaPrefetch[k]);
3352#endif
3353 }
3354
3355 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3356 if (!dml_is_vertical_rotation(SourceScan[k])) {
3357 req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k];
3358 } else {
3359 req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k];
3360 }
3361#ifdef __DML_VBA_DEBUG__
3362 dml_print("DML::%s: k=%u : req_per_swath_ub = %f (Luma)\n", __func__, k, req_per_swath_ub);
3363#endif
3364
3365 DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub;
3366 DisplayPipeRequestDeliveryTimeLumaPrefetch[k] = DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub;
3367 if (BytePerPixelC[k] == 0) {
3368 DisplayPipeRequestDeliveryTimeChroma[k] = 0;
3369 DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0;
3370 } else {
3371 if (!dml_is_vertical_rotation(SourceScan[k])) {
3372 req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k];
3373 } else {
3374 req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k];
3375 }
3376#ifdef __DML_VBA_DEBUG__
3377 dml_print("DML::%s: k=%u : req_per_swath_ub = %f (Chroma)\n", __func__, k, req_per_swath_ub);
3378#endif
3379 DisplayPipeRequestDeliveryTimeChroma[k] = DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub;
3380 DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub;
3381 }
3382#ifdef __DML_VBA_DEBUG__
3383 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeLuma = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeLuma[k]);
3384 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeLumaPrefetch = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeLumaPrefetch[k]);
3385 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeChroma = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeChroma[k]);
3386 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeChromaPrefetch = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeChromaPrefetch[k]);
3387#endif
3388 }
3389
3390 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3391 dml_uint_t cursor_req_per_width;
3392 cursor_req_per_width = (dml_uint_t)(dml_ceil((dml_float_t) CursorWidth[k] * (dml_float_t) CursorBPP[k] / 256.0 / 8.0, 1.0));
3393 if (NumberOfCursors[k] > 0) {
3394 if (VRatio[k] <= 1) {
3395 CursorRequestDeliveryTime[k] = (dml_float_t) CursorWidth[k] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
3396 } else {
3397 CursorRequestDeliveryTime[k] = (dml_float_t) CursorWidth[k] / PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
3398 }
3399 if (VRatioPrefetchY[k] <= 1) {
3400 CursorRequestDeliveryTimePrefetch[k] = (dml_float_t) CursorWidth[k] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
3401 } else {
3402 CursorRequestDeliveryTimePrefetch[k] = (dml_float_t) CursorWidth[k] / PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
3403 }
3404 } else {
3405 CursorRequestDeliveryTime[k] = 0;
3406 CursorRequestDeliveryTimePrefetch[k] = 0;
3407 }
3408#ifdef __DML_VBA_DEBUG__
3409 dml_print("DML::%s: k=%u : NumberOfCursors = %u\n", __func__, k, NumberOfCursors[k]);
3410 dml_print("DML::%s: k=%u : CursorRequestDeliveryTime = %f\n", __func__, k, CursorRequestDeliveryTime[k]);
3411 dml_print("DML::%s: k=%u : CursorRequestDeliveryTimePrefetch = %f\n", __func__, k, CursorRequestDeliveryTimePrefetch[k]);
3412#endif
3413 }
3414} // CalculatePixelDeliveryTimes
3415
3416static void CalculateMetaAndPTETimes(
3417 dml_bool_t use_one_row_for_frame[],
3418 dml_uint_t NumberOfActiveSurfaces,
3419 dml_bool_t GPUVMEnable,
3420 dml_uint_t MetaChunkSize,
3421 dml_uint_t MinMetaChunkSizeBytes,
3422 dml_uint_t HTotal[],
3423 dml_float_t VRatio[],
3424 dml_float_t VRatioChroma[],
3425 dml_float_t DestinationLinesToRequestRowInVBlank[],
3426 dml_float_t DestinationLinesToRequestRowInImmediateFlip[],
3427 dml_bool_t DCCEnable[],
3428 dml_float_t PixelClock[],
3429 dml_uint_t BytePerPixelY[],
3430 dml_uint_t BytePerPixelC[],
3431 enum dml_rotation_angle SourceScan[],
3432 dml_uint_t dpte_row_height[],
3433 dml_uint_t dpte_row_height_chroma[],
3434 dml_uint_t meta_row_width[],
3435 dml_uint_t meta_row_width_chroma[],
3436 dml_uint_t meta_row_height[],
3437 dml_uint_t meta_row_height_chroma[],
3438 dml_uint_t meta_req_width[],
3439 dml_uint_t meta_req_width_chroma[],
3440 dml_uint_t meta_req_height[],
3441 dml_uint_t meta_req_height_chroma[],
3442 dml_uint_t dpte_group_bytes[],
3443 dml_uint_t PTERequestSizeY[],
3444 dml_uint_t PTERequestSizeC[],
3445 dml_uint_t PixelPTEReqWidthY[],
3446 dml_uint_t PixelPTEReqHeightY[],
3447 dml_uint_t PixelPTEReqWidthC[],
3448 dml_uint_t PixelPTEReqHeightC[],
3449 dml_uint_t dpte_row_width_luma_ub[],
3450 dml_uint_t dpte_row_width_chroma_ub[],
3451
3452 // Output
3453 dml_float_t DST_Y_PER_PTE_ROW_NOM_L[],
3454 dml_float_t DST_Y_PER_PTE_ROW_NOM_C[],
3455 dml_float_t DST_Y_PER_META_ROW_NOM_L[],
3456 dml_float_t DST_Y_PER_META_ROW_NOM_C[],
3457 dml_float_t TimePerMetaChunkNominal[],
3458 dml_float_t TimePerChromaMetaChunkNominal[],
3459 dml_float_t TimePerMetaChunkVBlank[],
3460 dml_float_t TimePerChromaMetaChunkVBlank[],
3461 dml_float_t TimePerMetaChunkFlip[],
3462 dml_float_t TimePerChromaMetaChunkFlip[],
3463 dml_float_t time_per_pte_group_nom_luma[],
3464 dml_float_t time_per_pte_group_vblank_luma[],
3465 dml_float_t time_per_pte_group_flip_luma[],
3466 dml_float_t time_per_pte_group_nom_chroma[],
3467 dml_float_t time_per_pte_group_vblank_chroma[],
3468 dml_float_t time_per_pte_group_flip_chroma[])
3469{
3470 dml_uint_t meta_chunk_width;
3471 dml_uint_t min_meta_chunk_width;
3472 dml_uint_t meta_chunk_per_row_int;
3473 dml_uint_t meta_row_remainder;
3474 dml_uint_t meta_chunk_threshold;
3475 dml_uint_t meta_chunks_per_row_ub;
3476 dml_uint_t meta_chunk_width_chroma;
3477 dml_uint_t min_meta_chunk_width_chroma;
3478 dml_uint_t meta_chunk_per_row_int_chroma;
3479 dml_uint_t meta_row_remainder_chroma;
3480 dml_uint_t meta_chunk_threshold_chroma;
3481 dml_uint_t meta_chunks_per_row_ub_chroma;
3482 dml_uint_t dpte_group_width_luma;
3483 dml_uint_t dpte_groups_per_row_luma_ub;
3484 dml_uint_t dpte_group_width_chroma;
3485 dml_uint_t dpte_groups_per_row_chroma_ub;
3486
3487 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3488 DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k];
3489 if (BytePerPixelC[k] == 0) {
3490 DST_Y_PER_PTE_ROW_NOM_C[k] = 0;
3491 } else {
3492 DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k];
3493 }
3494 DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k];
3495 if (BytePerPixelC[k] == 0) {
3496 DST_Y_PER_META_ROW_NOM_C[k] = 0;
3497 } else {
3498 DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k];
3499 }
3500 }
3501
3502 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3503 if (DCCEnable[k] == true) {
3504 meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k];
3505 min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k];
3506 meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width;
3507 meta_row_remainder = meta_row_width[k] % meta_chunk_width;
3508 if (!dml_is_vertical_rotation(SourceScan[k])) {
3509 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k];
3510 } else {
3511 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k];
3512 }
3513 if (meta_row_remainder <= meta_chunk_threshold) {
3514 meta_chunks_per_row_ub = meta_chunk_per_row_int + 1;
3515 } else {
3516 meta_chunks_per_row_ub = meta_chunk_per_row_int + 2;
3517 }
3518 TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3519 TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3520 TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3521 if (BytePerPixelC[k] == 0) {
3522 TimePerChromaMetaChunkNominal[k] = 0;
3523 TimePerChromaMetaChunkVBlank[k] = 0;
3524 TimePerChromaMetaChunkFlip[k] = 0;
3525 } else {
3526 meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
3527 min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
3528 meta_chunk_per_row_int_chroma = (dml_uint_t)((dml_float_t) meta_row_width_chroma[k] / meta_chunk_width_chroma);
3529 meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma;
3530 if (!dml_is_vertical_rotation(SourceScan[k])) {
3531 meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_width_chroma[k];
3532 } else {
3533 meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_height_chroma[k];
3534 }
3535 if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma) {
3536 meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1;
3537 } else {
3538 meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2;
3539 }
3540 TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3541 TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3542 TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3543 }
3544 } else {
3545 TimePerMetaChunkNominal[k] = 0;
3546 TimePerMetaChunkVBlank[k] = 0;
3547 TimePerMetaChunkFlip[k] = 0;
3548 TimePerChromaMetaChunkNominal[k] = 0;
3549 TimePerChromaMetaChunkVBlank[k] = 0;
3550 TimePerChromaMetaChunkFlip[k] = 0;
3551 }
3552 }
3553
3554 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3555 if (GPUVMEnable == true) {
3556 if (!dml_is_vertical_rotation(SourceScan[k])) {
3557 dpte_group_width_luma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeY[k] * PixelPTEReqWidthY[k]);
3558 } else {
3559 dpte_group_width_luma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeY[k] * PixelPTEReqHeightY[k]);
3560 }
3561
3562 if (use_one_row_for_frame[k]) {
3563 dpte_groups_per_row_luma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_luma_ub[k] / (dml_float_t) dpte_group_width_luma / 2.0, 1.0));
3564 } else {
3565 dpte_groups_per_row_luma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_luma_ub[k] / (dml_float_t) dpte_group_width_luma, 1.0));
3566 }
3567
3568 dml_print("DML::%s: k=%u, use_one_row_for_frame = %u\n", __func__, k, use_one_row_for_frame[k]);
3569 dml_print("DML::%s: k=%u, dpte_group_bytes = %u\n", __func__, k, dpte_group_bytes[k]);
3570 dml_print("DML::%s: k=%u, PTERequestSizeY = %u\n", __func__, k, PTERequestSizeY[k]);
3571 dml_print("DML::%s: k=%u, PixelPTEReqWidthY = %u\n", __func__, k, PixelPTEReqWidthY[k]);
3572 dml_print("DML::%s: k=%u, PixelPTEReqHeightY = %u\n", __func__, k, PixelPTEReqHeightY[k]);
3573 dml_print("DML::%s: k=%u, dpte_row_width_luma_ub = %u\n", __func__, k, dpte_row_width_luma_ub[k]);
3574 dml_print("DML::%s: k=%u, dpte_group_width_luma = %u\n", __func__, k, dpte_group_width_luma);
3575 dml_print("DML::%s: k=%u, dpte_groups_per_row_luma_ub = %u\n", __func__, k, dpte_groups_per_row_luma_ub);
3576
3577 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;
3578 time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
3579 time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
3580 if (BytePerPixelC[k] == 0) {
3581 time_per_pte_group_nom_chroma[k] = 0;
3582 time_per_pte_group_vblank_chroma[k] = 0;
3583 time_per_pte_group_flip_chroma[k] = 0;
3584 } else {
3585 if (!dml_is_vertical_rotation(SourceScan[k])) {
3586 dpte_group_width_chroma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeC[k] * PixelPTEReqWidthC[k]);
3587 } else {
3588 dpte_group_width_chroma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeC[k] * PixelPTEReqHeightC[k]);
3589 }
3590
3591 if (use_one_row_for_frame[k]) {
3592 dpte_groups_per_row_chroma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_chroma_ub[k] / (dml_float_t) dpte_group_width_chroma / 2.0, 1.0));
3593 } else {
3594 dpte_groups_per_row_chroma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_chroma_ub[k] / (dml_float_t) dpte_group_width_chroma, 1.0));
3595 }
3596 dml_print("DML::%s: k=%u, dpte_row_width_chroma_ub = %u\n", __func__, k, dpte_row_width_chroma_ub[k]);
3597 dml_print("DML::%s: k=%u, dpte_group_width_chroma = %u\n", __func__, k, dpte_group_width_chroma);
3598 dml_print("DML::%s: k=%u, dpte_groups_per_row_chroma_ub = %u\n", __func__, k, dpte_groups_per_row_chroma_ub);
3599
3600 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;
3601 time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
3602 time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
3603 }
3604 } else {
3605 time_per_pte_group_nom_luma[k] = 0;
3606 time_per_pte_group_vblank_luma[k] = 0;
3607 time_per_pte_group_flip_luma[k] = 0;
3608 time_per_pte_group_nom_chroma[k] = 0;
3609 time_per_pte_group_vblank_chroma[k] = 0;
3610 time_per_pte_group_flip_chroma[k] = 0;
3611 }
3612#ifdef __DML_VBA_DEBUG__
3613 dml_print("DML::%s: k=%u, DestinationLinesToRequestRowInVBlank = %f\n", __func__, k, DestinationLinesToRequestRowInVBlank[k]);
3614 dml_print("DML::%s: k=%u, DestinationLinesToRequestRowInImmediateFlip = %f\n", __func__, k, DestinationLinesToRequestRowInImmediateFlip[k]);
3615
3616 dml_print("DML::%s: k=%u, DST_Y_PER_PTE_ROW_NOM_L = %f\n", __func__, k, DST_Y_PER_PTE_ROW_NOM_L[k]);
3617 dml_print("DML::%s: k=%u, DST_Y_PER_PTE_ROW_NOM_C = %f\n", __func__, k, DST_Y_PER_PTE_ROW_NOM_C[k]);
3618 dml_print("DML::%s: k=%u, DST_Y_PER_META_ROW_NOM_L = %f\n", __func__, k, DST_Y_PER_META_ROW_NOM_L[k]);
3619 dml_print("DML::%s: k=%u, DST_Y_PER_META_ROW_NOM_C = %f\n", __func__, k, DST_Y_PER_META_ROW_NOM_C[k]);
3620 dml_print("DML::%s: k=%u, TimePerMetaChunkNominal = %f\n", __func__, k, TimePerMetaChunkNominal[k]);
3621 dml_print("DML::%s: k=%u, TimePerMetaChunkVBlank = %f\n", __func__, k, TimePerMetaChunkVBlank[k]);
3622 dml_print("DML::%s: k=%u, TimePerMetaChunkFlip = %f\n", __func__, k, TimePerMetaChunkFlip[k]);
3623 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkNominal = %f\n", __func__, k, TimePerChromaMetaChunkNominal[k]);
3624 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkVBlank = %f\n", __func__, k, TimePerChromaMetaChunkVBlank[k]);
3625 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkFlip = %f\n", __func__, k, TimePerChromaMetaChunkFlip[k]);
3626 dml_print("DML::%s: k=%u, time_per_pte_group_nom_luma = %f\n", __func__, k, time_per_pte_group_nom_luma[k]);
3627 dml_print("DML::%s: k=%u, time_per_pte_group_vblank_luma = %f\n", __func__, k, time_per_pte_group_vblank_luma[k]);
3628 dml_print("DML::%s: k=%u, time_per_pte_group_flip_luma = %f\n", __func__, k, time_per_pte_group_flip_luma[k]);
3629 dml_print("DML::%s: k=%u, time_per_pte_group_nom_chroma = %f\n", __func__, k, time_per_pte_group_nom_chroma[k]);
3630 dml_print("DML::%s: k=%u, time_per_pte_group_vblank_chroma = %f\n", __func__, k, time_per_pte_group_vblank_chroma[k]);
3631 dml_print("DML::%s: k=%u, time_per_pte_group_flip_chroma = %f\n", __func__, k, time_per_pte_group_flip_chroma[k]);
3632#endif
3633 }
3634} // CalculateMetaAndPTETimes
3635
3636static void CalculateVMGroupAndRequestTimes(
3637 dml_uint_t NumberOfActiveSurfaces,
3638 dml_bool_t GPUVMEnable,
3639 dml_uint_t GPUVMMaxPageTableLevels,
3640 dml_uint_t HTotal[],
3641 dml_uint_t BytePerPixelC[],
3642 dml_float_t DestinationLinesToRequestVMInVBlank[],
3643 dml_float_t DestinationLinesToRequestVMInImmediateFlip[],
3644 dml_bool_t DCCEnable[],
3645 dml_float_t PixelClock[],
3646 dml_uint_t dpte_row_width_luma_ub[],
3647 dml_uint_t dpte_row_width_chroma_ub[],
3648 dml_uint_t vm_group_bytes[],
3649 dml_uint_t dpde0_bytes_per_frame_ub_l[],
3650 dml_uint_t dpde0_bytes_per_frame_ub_c[],
3651 dml_uint_t meta_pte_bytes_per_frame_ub_l[],
3652 dml_uint_t meta_pte_bytes_per_frame_ub_c[],
3653
3654 // Output
3655 dml_float_t TimePerVMGroupVBlank[],
3656 dml_float_t TimePerVMGroupFlip[],
3657 dml_float_t TimePerVMRequestVBlank[],
3658 dml_float_t TimePerVMRequestFlip[])
3659{
3660 dml_uint_t num_group_per_lower_vm_stage;
3661 dml_uint_t num_req_per_lower_vm_stage;
3662
3663#ifdef __DML_VBA_DEBUG__
3664 dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
3665 dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
3666#endif
3667 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3668
3669#ifdef __DML_VBA_DEBUG__
3670 dml_print("DML::%s: k=%u, DCCEnable = %u\n", __func__, k, DCCEnable[k]);
3671 dml_print("DML::%s: k=%u, vm_group_bytes = %u\n", __func__, k, vm_group_bytes[k]);
3672 dml_print("DML::%s: k=%u, dpde0_bytes_per_frame_ub_l = %u\n", __func__, k, dpde0_bytes_per_frame_ub_l[k]);
3673 dml_print("DML::%s: k=%u, dpde0_bytes_per_frame_ub_c = %u\n", __func__, k, dpde0_bytes_per_frame_ub_c[k]);
3674 dml_print("DML::%s: k=%u, meta_pte_bytes_per_frame_ub_l = %u\n", __func__, k, meta_pte_bytes_per_frame_ub_l[k]);
3675 dml_print("DML::%s: k=%u, meta_pte_bytes_per_frame_ub_c = %u\n", __func__, k, meta_pte_bytes_per_frame_ub_c[k]);
3676#endif
3677
3678 if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) {
3679 if (DCCEnable[k] == false) {
3680 if (BytePerPixelC[k] > 0) {
3681 num_group_per_lower_vm_stage = (dml_uint_t) (dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_l[k] / (dml_float_t) vm_group_bytes[k], 1.0) +
3682 dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_c[k] / (dml_float_t) vm_group_bytes[k], 1.0));
3683 } else {
3684 num_group_per_lower_vm_stage = (dml_uint_t) (dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_l[k] / (dml_float_t) vm_group_bytes[k], 1.0));
3685 }
3686 } else {
3687 if (GPUVMMaxPageTableLevels == 1) {
3688 if (BytePerPixelC[k] > 0) {
3689 num_group_per_lower_vm_stage = (dml_uint_t)(dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0) +
3690 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0));
3691 } else {
3692 num_group_per_lower_vm_stage = (dml_uint_t)(dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0));
3693 }
3694 } else {
3695 if (BytePerPixelC[k] > 0) {
3696 num_group_per_lower_vm_stage = (dml_uint_t)(2.0 + dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3697 dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3698 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3699 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1));
3700 } else {
3701 num_group_per_lower_vm_stage = (dml_uint_t)(1.0 + dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3702 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1));
3703 }
3704 }
3705 }
3706
3707 if (DCCEnable[k] == false) {
3708 if (BytePerPixelC[k] > 0) {
3709 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64;
3710 } else {
3711 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64;
3712 }
3713 } else {
3714 if (GPUVMMaxPageTableLevels == 1) {
3715 if (BytePerPixelC[k] > 0) {
3716 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
3717 } else {
3718 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64;
3719 }
3720 } else {
3721 if (BytePerPixelC[k] > 0) {
3722 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64 + meta_pte_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
3723 } else {
3724 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_l[k] / 64;
3725 }
3726 }
3727 }
3728
3729 TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
3730 TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
3731 TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
3732 TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
3733
3734 if (GPUVMMaxPageTableLevels > 2) {
3735 TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2;
3736 TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2;
3737 TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2;
3738 TimePerVMRequestFlip[k] = TimePerVMRequestFlip[k] / 2;
3739 }
3740
3741 } else {
3742 TimePerVMGroupVBlank[k] = 0;
3743 TimePerVMGroupFlip[k] = 0;
3744 TimePerVMRequestVBlank[k] = 0;
3745 TimePerVMRequestFlip[k] = 0;
3746 }
3747
3748#ifdef __DML_VBA_DEBUG__
3749 dml_print("DML::%s: k=%u, TimePerVMGroupVBlank = %f\n", __func__, k, TimePerVMGroupVBlank[k]);
3750 dml_print("DML::%s: k=%u, TimePerVMGroupFlip = %f\n", __func__, k, TimePerVMGroupFlip[k]);
3751 dml_print("DML::%s: k=%u, TimePerVMRequestVBlank = %f\n", __func__, k, TimePerVMRequestVBlank[k]);
3752 dml_print("DML::%s: k=%u, TimePerVMRequestFlip = %f\n", __func__, k, TimePerVMRequestFlip[k]);
3753#endif
3754 }
3755} // CalculateVMGroupAndRequestTimes
3756
3757static void CalculateStutterEfficiency(struct display_mode_lib_scratch_st *scratch,
3758 struct CalculateStutterEfficiency_params_st *p)
3759{
3760 dml_float_t DETBufferingTimeY = 0;
3761 dml_float_t SwathWidthYCriticalSurface = 0;
3762 dml_float_t SwathHeightYCriticalSurface = 0;
3763 dml_float_t VActiveTimeCriticalSurface = 0;
3764 dml_float_t FrameTimeCriticalSurface = 0;
3765 dml_uint_t BytePerPixelYCriticalSurface = 0;
3766 dml_float_t LinesToFinishSwathTransferStutterCriticalSurface = 0;
3767 dml_uint_t DETBufferSizeYCriticalSurface = 0;
3768 dml_float_t MinTTUVBlankCriticalSurface = 0;
3769 dml_uint_t BlockWidth256BytesYCriticalSurface = 0;
3770 dml_bool_t SinglePlaneCriticalSurface = 0;
3771 dml_bool_t SinglePipeCriticalSurface = 0;
3772 dml_float_t TotalCompressedReadBandwidth = 0;
3773 dml_float_t TotalRowReadBandwidth = 0;
3774 dml_float_t AverageDCCCompressionRate = 0;
3775 dml_float_t EffectiveCompressedBufferSize = 0;
3776 dml_float_t PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = 0;
3777 dml_float_t StutterBurstTime = 0;
3778 dml_uint_t TotalActiveWriteback = 0;
3779 dml_float_t LinesInDETY = 0;
3780 dml_float_t LinesInDETYRoundedDownToSwath = 0;
3781 dml_float_t MaximumEffectiveCompressionLuma = 0;
3782 dml_float_t MaximumEffectiveCompressionChroma = 0;
3783 dml_float_t TotalZeroSizeRequestReadBandwidth = 0;
3784 dml_float_t TotalZeroSizeCompressedReadBandwidth = 0;
3785 dml_float_t AverageDCCZeroSizeFraction = 0;
3786 dml_float_t AverageZeroSizeCompressionRate = 0;
3787
3788 dml_bool_t FoundCriticalSurface = false;
3789
3790 dml_uint_t TotalNumberOfActiveOTG = 0;
3791 dml_float_t SinglePixelClock;
3792 dml_uint_t SingleHTotal;
3793 dml_uint_t SingleVTotal;
3794 dml_bool_t SameTiming = true;
3795
3796 dml_float_t LastStutterPeriod = 0.0;
3797 dml_float_t LastZ8StutterPeriod = 0.0;
3798
3799 dml_uint_t SwathSizeCriticalSurface;
3800 dml_uint_t LastChunkOfSwathSize;
3801 dml_uint_t MissingPartOfLastSwathOfDETSize;
3802
3803 TotalZeroSizeRequestReadBandwidth = 0;
3804 TotalZeroSizeCompressedReadBandwidth = 0;
3805 TotalRowReadBandwidth = 0;
3806 TotalCompressedReadBandwidth = 0;
3807
3808 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3809 if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
3810 if (p->DCCEnable[k] == true) {
3811 if ((dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockWidth256BytesY[k] > p->SwathHeightY[k]) || (!dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockHeight256BytesY[k] > p->SwathHeightY[k]) || p->DCCYMaxUncompressedBlock[k] < 256) {
3812 MaximumEffectiveCompressionLuma = 2;
3813 } else {
3814 MaximumEffectiveCompressionLuma = 4;
3815 }
3816 TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] / dml_min(p->NetDCCRateLuma[k], MaximumEffectiveCompressionLuma);
3817#ifdef __DML_VBA_DEBUG__
3818 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, p->ReadBandwidthSurfaceLuma[k]);
3819 dml_print("DML::%s: k=%u, NetDCCRateLuma = %f\n", __func__, k, p->NetDCCRateLuma[k]);
3820 dml_print("DML::%s: k=%u, MaximumEffectiveCompressionLuma = %f\n", __func__, k, MaximumEffectiveCompressionLuma);
3821#endif
3822 TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth + p->ReadBandwidthSurfaceLuma[k] * p->DCCFractionOfZeroSizeRequestsLuma[k];
3823 TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] * p->DCCFractionOfZeroSizeRequestsLuma[k] / MaximumEffectiveCompressionLuma;
3824
3825 if (p->ReadBandwidthSurfaceChroma[k] > 0) {
3826 if ((dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockWidth256BytesC[k] > p->SwathHeightC[k]) || (!dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockHeight256BytesC[k] > p->SwathHeightC[k]) || p->DCCCMaxUncompressedBlock[k] < 256) {
3827 MaximumEffectiveCompressionChroma = 2;
3828 } else {
3829 MaximumEffectiveCompressionChroma = 4;
3830 }
3831 TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceChroma[k] / dml_min(p->NetDCCRateChroma[k], MaximumEffectiveCompressionChroma);
3832#ifdef __DML_VBA_DEBUG__
3833 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceChroma = %f\n", __func__, k, p->ReadBandwidthSurfaceChroma[k]);
3834 dml_print("DML::%s: k=%u, NetDCCRateChroma = %f\n", __func__, k, p->NetDCCRateChroma[k]);
3835 dml_print("DML::%s: k=%u, MaximumEffectiveCompressionChroma = %f\n", __func__, k, MaximumEffectiveCompressionChroma);
3836#endif
3837 TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth + p->ReadBandwidthSurfaceChroma[k] * p->DCCFractionOfZeroSizeRequestsChroma[k];
3838 TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth + p->ReadBandwidthSurfaceChroma[k] * p->DCCFractionOfZeroSizeRequestsChroma[k] / MaximumEffectiveCompressionChroma;
3839 }
3840 } else {
3841 TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] + p->ReadBandwidthSurfaceChroma[k];
3842 }
3843 TotalRowReadBandwidth = TotalRowReadBandwidth + p->DPPPerSurface[k] * (p->meta_row_bw[k] + p->dpte_row_bw[k]);
3844 }
3845 }
3846
3847 AverageDCCCompressionRate = p->TotalDataReadBandwidth / TotalCompressedReadBandwidth;
3848 AverageDCCZeroSizeFraction = TotalZeroSizeRequestReadBandwidth / p->TotalDataReadBandwidth;
3849
3850#ifdef __DML_VBA_DEBUG__
3851 dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, p->UnboundedRequestEnabled);
3852 dml_print("DML::%s: TotalCompressedReadBandwidth = %f\n", __func__, TotalCompressedReadBandwidth);
3853 dml_print("DML::%s: TotalZeroSizeRequestReadBandwidth = %f\n", __func__, TotalZeroSizeRequestReadBandwidth);
3854 dml_print("DML::%s: TotalZeroSizeCompressedReadBandwidth = %f\n", __func__, TotalZeroSizeCompressedReadBandwidth);
3855 dml_print("DML::%s: MaximumEffectiveCompressionLuma = %f\n", __func__, MaximumEffectiveCompressionLuma);
3856 dml_print("DML::%s: MaximumEffectiveCompressionChroma = %f\n", __func__, MaximumEffectiveCompressionChroma);
3857 dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
3858 dml_print("DML::%s: AverageDCCZeroSizeFraction = %f\n", __func__, AverageDCCZeroSizeFraction);
3859 dml_print("DML::%s: CompbufReservedSpace64B = %u\n", __func__, p->CompbufReservedSpace64B);
3860 dml_print("DML::%s: CompbufReservedSpaceZs = %u\n", __func__, p->CompbufReservedSpaceZs);
3861 dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, p->CompressedBufferSizeInkByte);
3862#endif
3863 if (AverageDCCZeroSizeFraction == 1) {
3864 AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth / TotalZeroSizeCompressedReadBandwidth;
3865 EffectiveCompressedBufferSize = (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageZeroSizeCompressionRate + ((dml_float_t)p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 * AverageZeroSizeCompressionRate;
3866 } else if (AverageDCCZeroSizeFraction > 0) {
3867 AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth / TotalZeroSizeCompressedReadBandwidth;
3868 EffectiveCompressedBufferSize = dml_min((dml_float_t)p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
3869 (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 / AverageDCCCompressionRate)) +
3870 dml_min(((dml_float_t)p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate,
3871 ((dml_float_t)p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
3872
3873#ifdef __DML_VBA_DEBUG__
3874 dml_print("DML::%s: min 1 = %f\n", __func__, p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
3875 dml_print("DML::%s: min 2 = %f\n", __func__, p->MetaFIFOSizeInKEntries * 1024 * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 / AverageDCCCompressionRate));
3876 dml_print("DML::%s: min 3 = %f\n", __func__, (p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate);
3877 dml_print("DML::%s: min 4 = %f\n", __func__, (p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
3878#endif
3879 } else {
3880 EffectiveCompressedBufferSize = dml_min((dml_float_t)p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
3881 (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate) +
3882 ((dml_float_t)p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate;
3883
3884#ifdef __DML_VBA_DEBUG__
3885 dml_print("DML::%s: min 1 = %f\n", __func__, p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
3886 dml_print("DML::%s: min 2 = %f\n", __func__, p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate);
3887#endif
3888 }
3889
3890#ifdef __DML_VBA_DEBUG__
3891 dml_print("DML::%s: MetaFIFOSizeInKEntries = %u\n", __func__, p->MetaFIFOSizeInKEntries);
3892 dml_print("DML::%s: AverageZeroSizeCompressionRate = %f\n", __func__, AverageZeroSizeCompressionRate);
3893 dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
3894#endif
3895
3896 *p->StutterPeriod = 0;
3897
3898 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3899 if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
3900 LinesInDETY = ((dml_float_t)p->DETBufferSizeY[k] + (p->UnboundedRequestEnabled == true ? EffectiveCompressedBufferSize : 0) * p->ReadBandwidthSurfaceLuma[k] / p->TotalDataReadBandwidth) / p->BytePerPixelDETY[k] / p->SwathWidthY[k];
3901 LinesInDETYRoundedDownToSwath = dml_floor(LinesInDETY, p->SwathHeightY[k]);
3902 DETBufferingTimeY = LinesInDETYRoundedDownToSwath * ((dml_float_t)p->HTotal[k] / p->PixelClock[k]) / p->VRatio[k];
3903#ifdef __DML_VBA_DEBUG__
3904 dml_print("DML::%s: k=%u, DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
3905 dml_print("DML::%s: k=%u, BytePerPixelDETY = %f\n", __func__, k, p->BytePerPixelDETY[k]);
3906 dml_print("DML::%s: k=%u, SwathWidthY = %u\n", __func__, k, p->SwathWidthY[k]);
3907 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, p->ReadBandwidthSurfaceLuma[k]);
3908 dml_print("DML::%s: k=%u, TotalDataReadBandwidth = %f\n", __func__, k, p->TotalDataReadBandwidth);
3909 dml_print("DML::%s: k=%u, LinesInDETY = %f\n", __func__, k, LinesInDETY);
3910 dml_print("DML::%s: k=%u, LinesInDETYRoundedDownToSwath = %f\n", __func__, k, LinesInDETYRoundedDownToSwath);
3911 dml_print("DML::%s: k=%u, HTotal = %u\n", __func__, k, p->HTotal[k]);
3912 dml_print("DML::%s: k=%u, PixelClock = %f\n", __func__, k, p->PixelClock[k]);
3913 dml_print("DML::%s: k=%u, VRatio = %f\n", __func__, k, p->VRatio[k]);
3914 dml_print("DML::%s: k=%u, DETBufferingTimeY = %f\n", __func__, k, DETBufferingTimeY);
3915 dml_print("DML::%s: k=%u,PixelClock = %f\n", __func__, k, p->PixelClock[k]);
3916#endif
3917
3918 if (!FoundCriticalSurface || DETBufferingTimeY < *p->StutterPeriod) {
3919 dml_bool_t isInterlaceTiming = p->Interlace[k] && !p->ProgressiveToInterlaceUnitInOPP;
3920
3921 FoundCriticalSurface = true;
3922 *p->StutterPeriod = DETBufferingTimeY;
3923 FrameTimeCriticalSurface = (isInterlaceTiming ? dml_floor((dml_float_t)p->VTotal[k]/2.0, 1.0) : p->VTotal[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
3924 VActiveTimeCriticalSurface = (isInterlaceTiming ? dml_floor((dml_float_t)p->VActive[k]/2.0, 1.0) : p->VActive[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
3925 BytePerPixelYCriticalSurface = p->BytePerPixelY[k];
3926 SwathWidthYCriticalSurface = p->SwathWidthY[k];
3927 SwathHeightYCriticalSurface = p->SwathHeightY[k];
3928 BlockWidth256BytesYCriticalSurface = p->BlockWidth256BytesY[k];
3929 LinesToFinishSwathTransferStutterCriticalSurface = p->SwathHeightY[k] - (LinesInDETY - LinesInDETYRoundedDownToSwath);
3930 DETBufferSizeYCriticalSurface = p->DETBufferSizeY[k];
3931 MinTTUVBlankCriticalSurface = p->MinTTUVBlank[k];
3932 SinglePlaneCriticalSurface = (p->ReadBandwidthSurfaceChroma[k] == 0);
3933 SinglePipeCriticalSurface = (p->DPPPerSurface[k] == 1);
3934
3935#ifdef __DML_VBA_DEBUG__
3936 dml_print("DML::%s: k=%u, FoundCriticalSurface = %u\n", __func__, k, FoundCriticalSurface);
3937 dml_print("DML::%s: k=%u, StutterPeriod = %f\n", __func__, k, *p->StutterPeriod);
3938 dml_print("DML::%s: k=%u, MinTTUVBlankCriticalSurface = %f\n", __func__, k, MinTTUVBlankCriticalSurface);
3939 dml_print("DML::%s: k=%u, FrameTimeCriticalSurface = %f\n", __func__, k, FrameTimeCriticalSurface);
3940 dml_print("DML::%s: k=%u, VActiveTimeCriticalSurface = %f\n", __func__, k, VActiveTimeCriticalSurface);
3941 dml_print("DML::%s: k=%u, BytePerPixelYCriticalSurface = %u\n", __func__, k, BytePerPixelYCriticalSurface);
3942 dml_print("DML::%s: k=%u, SwathWidthYCriticalSurface = %f\n", __func__, k, SwathWidthYCriticalSurface);
3943 dml_print("DML::%s: k=%u, SwathHeightYCriticalSurface = %f\n", __func__, k, SwathHeightYCriticalSurface);
3944 dml_print("DML::%s: k=%u, BlockWidth256BytesYCriticalSurface = %u\n", __func__, k, BlockWidth256BytesYCriticalSurface);
3945 dml_print("DML::%s: k=%u, SinglePlaneCriticalSurface = %u\n", __func__, k, SinglePlaneCriticalSurface);
3946 dml_print("DML::%s: k=%u, SinglePipeCriticalSurface = %u\n", __func__, k, SinglePipeCriticalSurface);
3947 dml_print("DML::%s: k=%u, LinesToFinishSwathTransferStutterCriticalSurface = %f\n", __func__, k, LinesToFinishSwathTransferStutterCriticalSurface);
3948#endif
3949 }
3950 }
3951 }
3952
3953 PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = dml_min(*p->StutterPeriod * p->TotalDataReadBandwidth, EffectiveCompressedBufferSize);
3954#ifdef __DML_VBA_DEBUG__
3955 dml_print("DML::%s: ROBBufferSizeInKByte = %u\n", __func__, p->ROBBufferSizeInKByte);
3956 dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
3957 dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", __func__, *p->StutterPeriod * p->TotalDataReadBandwidth);
3958 dml_print("DML::%s: ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate + EffectiveCompressedBufferSize = %f\n", __func__, p->ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate + EffectiveCompressedBufferSize);
3959 dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
3960 dml_print("DML::%s: PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer);
3961 dml_print("DML::%s: ReturnBW = %f\n", __func__, p->ReturnBW);
3962 dml_print("DML::%s: TotalDataReadBandwidth = %f\n", __func__, p->TotalDataReadBandwidth);
3963 dml_print("DML::%s: TotalRowReadBandwidth = %f\n", __func__, TotalRowReadBandwidth);
3964 dml_print("DML::%s: DCFCLK = %f\n", __func__, p->DCFCLK);
3965#endif
3966
3967 StutterBurstTime = PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate / p->ReturnBW + (*p->StutterPeriod * p->TotalDataReadBandwidth - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (p->DCFCLK * 64) + *p->StutterPeriod * TotalRowReadBandwidth / p->ReturnBW;
3968#ifdef __DML_VBA_DEBUG__
3969 dml_print("DML::%s: Part 1 = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate / p->ReturnBW);
3970 dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", __func__, (*p->StutterPeriod * p->TotalDataReadBandwidth));
3971 dml_print("DML::%s: Part 2 = %f\n", __func__, (*p->StutterPeriod * p->TotalDataReadBandwidth - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (p->DCFCLK * 64));
3972 dml_print("DML::%s: Part 3 = %f\n", __func__, *p->StutterPeriod * TotalRowReadBandwidth / p->ReturnBW);
3973 dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
3974#endif
3975 StutterBurstTime = dml_max(StutterBurstTime, LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / p->ReturnBW);
3976
3977 dml_print("DML::%s: Time to finish residue swath=%f\n", __func__, LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / p->ReturnBW);
3978
3979 TotalActiveWriteback = 0;
3980 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3981 if (p->WritebackEnable[k]) {
3982 TotalActiveWriteback = TotalActiveWriteback + 1;
3983 }
3984 }
3985
3986 if (TotalActiveWriteback == 0) {
3987#ifdef __DML_VBA_DEBUG__
3988 dml_print("DML::%s: SRExitTime = %f\n", __func__, p->SRExitTime);
3989 dml_print("DML::%s: SRExitZ8Time = %f\n", __func__, p->SRExitZ8Time);
3990 dml_print("DML::%s: StutterBurstTime = %f (final)\n", __func__, StutterBurstTime);
3991 dml_print("DML::%s: StutterPeriod = %f\n", __func__, *p->StutterPeriod);
3992#endif
3993 *p->StutterEfficiencyNotIncludingVBlank = dml_max(0., 1 - (p->SRExitTime + StutterBurstTime) / *p->StutterPeriod) * 100;
3994 *p->Z8StutterEfficiencyNotIncludingVBlank = dml_max(0., 1 - (p->SRExitZ8Time + StutterBurstTime) / *p->StutterPeriod) * 100;
3995 *p->NumberOfStutterBurstsPerFrame = (*p->StutterEfficiencyNotIncludingVBlank > 0 ? (dml_uint_t)(dml_ceil(VActiveTimeCriticalSurface / *p->StutterPeriod, 1)) : 0);
3996 *p->Z8NumberOfStutterBurstsPerFrame = (*p->Z8StutterEfficiencyNotIncludingVBlank > 0 ? (dml_uint_t)(dml_ceil(VActiveTimeCriticalSurface / *p->StutterPeriod, 1)) : 0);
3997 } else {
3998 *p->StutterEfficiencyNotIncludingVBlank = 0.;
3999 *p->Z8StutterEfficiencyNotIncludingVBlank = 0.;
4000 *p->NumberOfStutterBurstsPerFrame = 0;
4001 *p->Z8NumberOfStutterBurstsPerFrame = 0;
4002 }
4003#ifdef __DML_VBA_DEBUG__
4004 dml_print("DML::%s: VActiveTimeCriticalSurface = %f\n", __func__, VActiveTimeCriticalSurface);
4005 dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->StutterEfficiencyNotIncludingVBlank);
4006 dml_print("DML::%s: Z8StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->Z8StutterEfficiencyNotIncludingVBlank);
4007 dml_print("DML::%s: NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->NumberOfStutterBurstsPerFrame);
4008 dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->Z8NumberOfStutterBurstsPerFrame);
4009#endif
4010
4011 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4012 if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
4013 if (p->BlendingAndTiming[k] == k) {
4014 if (TotalNumberOfActiveOTG == 0) {
4015 SinglePixelClock = p->PixelClock[k];
4016 SingleHTotal = p->HTotal[k];
4017 SingleVTotal = p->VTotal[k];
4018 } else if (SinglePixelClock != p->PixelClock[k] || SingleHTotal != p->HTotal[k] || SingleVTotal != p->VTotal[k]) {
4019 SameTiming = false;
4020 }
4021 TotalNumberOfActiveOTG = TotalNumberOfActiveOTG + 1;
4022 }
4023 }
4024 }
4025
4026 if (*p->StutterEfficiencyNotIncludingVBlank > 0) {
4027 LastStutterPeriod = VActiveTimeCriticalSurface - (*p->NumberOfStutterBurstsPerFrame - 1) * *p->StutterPeriod;
4028
4029 if ((p->SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming &&
4030 LastStutterPeriod + MinTTUVBlankCriticalSurface > p->StutterEnterPlusExitWatermark) {
4031 *p->StutterEfficiency = (1 - (*p->NumberOfStutterBurstsPerFrame * p->SRExitTime + StutterBurstTime * VActiveTimeCriticalSurface / *p->StutterPeriod) / FrameTimeCriticalSurface) * 100;
4032 } else {
4033 *p->StutterEfficiency = *p->StutterEfficiencyNotIncludingVBlank;
4034 }
4035 } else {
4036 *p->StutterEfficiency = 0;
4037 }
4038
4039 if (*p->Z8StutterEfficiencyNotIncludingVBlank > 0) {
4040 LastZ8StutterPeriod = VActiveTimeCriticalSurface - (*p->NumberOfStutterBurstsPerFrame - 1) * *p->StutterPeriod;
4041 if ((p->SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming && LastZ8StutterPeriod + MinTTUVBlankCriticalSurface > p->Z8StutterEnterPlusExitWatermark) {
4042 *p->Z8StutterEfficiency = (1 - (*p->NumberOfStutterBurstsPerFrame * p->SRExitZ8Time + StutterBurstTime * VActiveTimeCriticalSurface / *p->StutterPeriod) / FrameTimeCriticalSurface) * 100;
4043 } else {
4044 *p->Z8StutterEfficiency = *p->Z8StutterEfficiencyNotIncludingVBlank;
4045 }
4046 } else {
4047 *p->Z8StutterEfficiency = 0.;
4048 }
4049
4050#ifdef __DML_VBA_DEBUG__
4051 dml_print("DML::%s: LastZ8StutterPeriod = %f\n", __func__, LastZ8StutterPeriod);
4052 dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, p->Z8StutterEnterPlusExitWatermark);
4053 dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
4054 dml_print("DML::%s: StutterPeriod = %f\n", __func__, *p->StutterPeriod);
4055 dml_print("DML::%s: StutterEfficiency = %f\n", __func__, *p->StutterEfficiency);
4056 dml_print("DML::%s: Z8StutterEfficiency = %f\n", __func__, *p->Z8StutterEfficiency);
4057 dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->StutterEfficiencyNotIncludingVBlank);
4058 dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->Z8NumberOfStutterBurstsPerFrame);
4059#endif
4060
4061 SwathSizeCriticalSurface = (dml_uint_t)(BytePerPixelYCriticalSurface * SwathHeightYCriticalSurface * dml_ceil(SwathWidthYCriticalSurface, BlockWidth256BytesYCriticalSurface));
4062 LastChunkOfSwathSize = SwathSizeCriticalSurface % (p->PixelChunkSizeInKByte * 1024);
4063 MissingPartOfLastSwathOfDETSize = (dml_uint_t)(dml_ceil(DETBufferSizeYCriticalSurface, SwathSizeCriticalSurface) - DETBufferSizeYCriticalSurface);
4064
4065 *p->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = !(!p->UnboundedRequestEnabled && (p->NumberOfActiveSurfaces == 1) && SinglePlaneCriticalSurface && SinglePipeCriticalSurface && (LastChunkOfSwathSize > 0) &&
4066 (LastChunkOfSwathSize <= 4096) && (MissingPartOfLastSwathOfDETSize > 0) && (MissingPartOfLastSwathOfDETSize <= LastChunkOfSwathSize));
4067
4068#ifdef __DML_VBA_DEBUG__
4069 dml_print("DML::%s: SwathSizeCriticalSurface = %u\n", __func__, SwathSizeCriticalSurface);
4070 dml_print("DML::%s: DETBufferSizeYCriticalSurface = %u\n", __func__, DETBufferSizeYCriticalSurface);
4071 dml_print("DML::%s: PixelChunkSizeInKByte = %u\n", __func__, p->PixelChunkSizeInKByte);
4072 dml_print("DML::%s: LastChunkOfSwathSize = %u\n", __func__, LastChunkOfSwathSize);
4073 dml_print("DML::%s: MissingPartOfLastSwathOfDETSize = %u\n", __func__, MissingPartOfLastSwathOfDETSize);
4074 dml_print("DML::%s: DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = %u\n", __func__, *p->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
4075#endif
4076} // CalculateStutterEfficiency
4077
4078/// \CalculateSwathAndDETConfiguration
4079/// @brief Calculates swath width and different return buffers sizing (DET, CDB, etc.)
4080static void CalculateSwathAndDETConfiguration(struct display_mode_lib_scratch_st *scratch,
4081 struct CalculateSwathAndDETConfiguration_params_st *p)
4082{
4083 dml_uint_t MaximumSwathHeightY[__DML_NUM_PLANES__];
4084 dml_uint_t MaximumSwathHeightC[__DML_NUM_PLANES__];
4085 dml_uint_t RoundedUpMaxSwathSizeBytesY[__DML_NUM_PLANES__];
4086 dml_uint_t RoundedUpMaxSwathSizeBytesC[__DML_NUM_PLANES__];
4087 dml_uint_t RoundedUpSwathSizeBytesY[__DML_NUM_PLANES__];
4088 dml_uint_t RoundedUpSwathSizeBytesC[__DML_NUM_PLANES__];
4089 dml_uint_t SwathWidthSingleDPP[__DML_NUM_PLANES__];
4090 dml_uint_t SwathWidthSingleDPPChroma[__DML_NUM_PLANES__];
4091
4092 dml_uint_t TotalActiveDPP = 0;
4093 dml_bool_t NoChromaOrLinearSurfaces = true;
4094 dml_uint_t SurfaceDoingUnboundedRequest = 0;
4095
4096 dml_uint_t DETBufferSizeInKByteForSwathCalculation;
4097
4098 const long TTUFIFODEPTH = 8;
4099 const long MAXIMUMCOMPRESSION = 4;
4100
4101#ifdef __DML_VBA_DEBUG__
4102 dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, p->ForceSingleDPP);
4103 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4104 dml_print("DML::%s: DPPPerSurface[%u] = %u\n", __func__, k, p->DPPPerSurface[k]);
4105 }
4106#endif
4107 CalculateSwathWidth(p->ForceSingleDPP,
4108 p->NumberOfActiveSurfaces,
4109 p->SourcePixelFormat,
4110 p->SourceScan,
4111 p->ViewportStationary,
4112 p->ViewportWidth,
4113 p->ViewportHeight,
4114 p->ViewportXStart,
4115 p->ViewportYStart,
4116 p->ViewportXStartC,
4117 p->ViewportYStartC,
4118 p->SurfaceWidthY,
4119 p->SurfaceWidthC,
4120 p->SurfaceHeightY,
4121 p->SurfaceHeightC,
4122 p->ODMMode,
4123 p->BytePerPixY,
4124 p->BytePerPixC,
4125 p->Read256BytesBlockHeightY,
4126 p->Read256BytesBlockHeightC,
4127 p->Read256BytesBlockWidthY,
4128 p->Read256BytesBlockWidthC,
4129 p->BlendingAndTiming,
4130 p->HActive,
4131 p->HRatio,
4132 p->DPPPerSurface,
4133
4134 // Output
4135 SwathWidthSingleDPP,
4136 SwathWidthSingleDPPChroma,
4137 p->SwathWidth,
4138 p->SwathWidthChroma,
4139 MaximumSwathHeightY,
4140 MaximumSwathHeightC,
4141 p->swath_width_luma_ub,
4142 p->swath_width_chroma_ub);
4143
4144 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4145 RoundedUpMaxSwathSizeBytesY[k] = (dml_uint_t)(p->swath_width_luma_ub[k] * p->BytePerPixDETY[k] * MaximumSwathHeightY[k]);
4146 RoundedUpMaxSwathSizeBytesC[k] = (dml_uint_t)(p->swath_width_chroma_ub[k] * p->BytePerPixDETC[k] * MaximumSwathHeightC[k]);
4147#ifdef __DML_VBA_DEBUG__
4148 dml_print("DML::%s: k=%u DPPPerSurface = %u\n", __func__, k, p->DPPPerSurface[k]);
4149 dml_print("DML::%s: k=%u swath_width_luma_ub = %u\n", __func__, k, p->swath_width_luma_ub[k]);
4150 dml_print("DML::%s: k=%u BytePerPixDETY = %f\n", __func__, k, p->BytePerPixDETY[k]);
4151 dml_print("DML::%s: k=%u MaximumSwathHeightY = %u\n", __func__, k, MaximumSwathHeightY[k]);
4152 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4153 dml_print("DML::%s: k=%u swath_width_chroma_ub = %u\n", __func__, k, p->swath_width_chroma_ub[k]);
4154 dml_print("DML::%s: k=%u BytePerPixDETC = %f\n", __func__, k, p->BytePerPixDETC[k]);
4155 dml_print("DML::%s: k=%u MaximumSwathHeightC = %u\n", __func__, k, MaximumSwathHeightC[k]);
4156 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4157#endif
4158 if (p->SourcePixelFormat[k] == dml_420_10) {
4159 RoundedUpMaxSwathSizeBytesY[k] = (dml_uint_t)(dml_ceil((dml_float_t) RoundedUpMaxSwathSizeBytesY[k], 256));
4160 RoundedUpMaxSwathSizeBytesC[k] = (dml_uint_t)(dml_ceil((dml_float_t) RoundedUpMaxSwathSizeBytesC[k], 256));
4161 }
4162 }
4163
4164 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4165 TotalActiveDPP = TotalActiveDPP + (p->ForceSingleDPP ? 1 : p->DPPPerSurface[k]);
4166 if (p->DPPPerSurface[k] > 0)
4167 SurfaceDoingUnboundedRequest = k;
4168 if (p->SourcePixelFormat[k] == dml_420_8 || p->SourcePixelFormat[k] == dml_420_10 ||
4169 p->SourcePixelFormat[k] == dml_420_12 || p->SourcePixelFormat[k] == dml_rgbe_alpha
4170 || p->SurfaceTiling[k] == dml_sw_linear) {
4171 NoChromaOrLinearSurfaces = false;
4172 }
4173 }
4174
4175 *p->UnboundedRequestEnabled = UnboundedRequest(p->UseUnboundedRequestingFinal, TotalActiveDPP,
4176 NoChromaOrLinearSurfaces, p->Output[0]);
4177
4178 CalculateDETBufferSize(p->DETSizeOverride,
4179 p->UseMALLForPStateChange,
4180 p->ForceSingleDPP,
4181 p->NumberOfActiveSurfaces,
4182 *p->UnboundedRequestEnabled,
4183 p->nomDETInKByte,
4184 p->MaxTotalDETInKByte,
4185 p->ConfigReturnBufferSizeInKByte,
4186 p->MinCompressedBufferSizeInKByte,
4187 p->ConfigReturnBufferSegmentSizeInkByte,
4188 p->CompressedBufferSegmentSizeInkByteFinal,
4189 p->SourcePixelFormat,
4190 p->ReadBandwidthLuma,
4191 p->ReadBandwidthChroma,
4192 RoundedUpMaxSwathSizeBytesY,
4193 RoundedUpMaxSwathSizeBytesC,
4194 p->DPPPerSurface,
4195
4196 // Output
4197 p->DETBufferSizeInKByte, // per hubp pipe
4198 p->CompressedBufferSizeInkByte);
4199
4200#ifdef __DML_VBA_DEBUG__
4201 dml_print("DML::%s: TotalActiveDPP = %u\n", __func__, TotalActiveDPP);
4202 dml_print("DML::%s: nomDETInKByte = %u\n", __func__, p->nomDETInKByte);
4203 dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, p->ConfigReturnBufferSizeInKByte);
4204 dml_print("DML::%s: UseUnboundedRequestingFinal = %u\n", __func__, p->UseUnboundedRequestingFinal);
4205 dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, *p->UnboundedRequestEnabled);
4206 dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, *p->CompressedBufferSizeInkByte);
4207#endif
4208
4209 *p->ViewportSizeSupport = true;
4210 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4211
4212 DETBufferSizeInKByteForSwathCalculation = (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe ? 1024 : p->DETBufferSizeInKByte[k]);
4213#ifdef __DML_VBA_DEBUG__
4214 dml_print("DML::%s: k=%u DETBufferSizeInKByteForSwathCalculation = %u\n", __func__, k, DETBufferSizeInKByteForSwathCalculation);
4215#endif
4216
4217 if (RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4218 p->SwathHeightY[k] = MaximumSwathHeightY[k];
4219 p->SwathHeightC[k] = MaximumSwathHeightC[k];
4220 RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k];
4221 RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k];
4222 } else if (RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * RoundedUpMaxSwathSizeBytesC[k] && RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4223 p->SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
4224 p->SwathHeightC[k] = MaximumSwathHeightC[k];
4225 RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k] / 2;
4226 RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k];
4227 } else if (RoundedUpMaxSwathSizeBytesY[k] < 1.5 * RoundedUpMaxSwathSizeBytesC[k] && RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] / 2 <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4228 p->SwathHeightY[k] = MaximumSwathHeightY[k];
4229 p->SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
4230 RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k];
4231 RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k] / 2;
4232 } else {
4233 p->SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
4234 p->SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
4235 RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k] / 2;
4236 RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k] / 2;
4237 }
4238
4239 if ((RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] / 2 > DETBufferSizeInKByteForSwathCalculation * 1024 / 2) ||
4240 p->SwathWidth[k] > p->MaximumSwathWidthLuma[k] || (p->SwathHeightC[k] > 0 && p->SwathWidthChroma[k] > p->MaximumSwathWidthChroma[k])) {
4241 *p->ViewportSizeSupport = false;
4242 p->ViewportSizeSupportPerSurface[k] = false;
4243 } else {
4244 p->ViewportSizeSupportPerSurface[k] = true;
4245 }
4246
4247 if (p->SwathHeightC[k] == 0) {
4248#ifdef __DML_VBA_DEBUG__
4249 dml_print("DML::%s: k=%u All DET for plane0\n", __func__, k);
4250#endif
4251 p->DETBufferSizeY[k] = p->DETBufferSizeInKByte[k] * 1024;
4252 p->DETBufferSizeC[k] = 0;
4253 } else if (RoundedUpSwathSizeBytesY[k] <= 1.5 * RoundedUpSwathSizeBytesC[k]) {
4254#ifdef __DML_VBA_DEBUG__
4255 dml_print("DML::%s: k=%u Half DET for plane0, half for plane1\n", __func__, k);
4256#endif
4257 p->DETBufferSizeY[k] = p->DETBufferSizeInKByte[k] * 1024 / 2;
4258 p->DETBufferSizeC[k] = p->DETBufferSizeInKByte[k] * 1024 / 2;
4259 } else {
4260#ifdef __DML_VBA_DEBUG__
4261 dml_print("DML::%s: k=%u 2/3 DET for plane0, 1/3 for plane1\n", __func__, k);
4262#endif
4263 p->DETBufferSizeY[k] = (dml_uint_t)(dml_floor(p->DETBufferSizeInKByte[k] * 1024 * 2 / 3, 1024));
4264 p->DETBufferSizeC[k] = p->DETBufferSizeInKByte[k] * 1024 - p->DETBufferSizeY[k];
4265 }
4266
4267#ifdef __DML_VBA_DEBUG__
4268 dml_print("DML::%s: k=%u SwathHeightY = %u\n", __func__, k, p->SwathHeightY[k]);
4269 dml_print("DML::%s: k=%u SwathHeightC = %u\n", __func__, k, p->SwathHeightC[k]);
4270 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4271 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4272 dml_print("DML::%s: k=%u RoundedUpSwathSizeBytesY = %u\n", __func__, k, RoundedUpSwathSizeBytesY[k]);
4273 dml_print("DML::%s: k=%u RoundedUpSwathSizeBytesC = %u\n", __func__, k, RoundedUpSwathSizeBytesC[k]);
4274 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u\n", __func__, k, p->DETBufferSizeInKByte[k]);
4275 dml_print("DML::%s: k=%u DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
4276 dml_print("DML::%s: k=%u DETBufferSizeC = %u\n", __func__, k, p->DETBufferSizeC[k]);
4277 dml_print("DML::%s: k=%u ViewportSizeSupportPerSurface = %u\n", __func__, k, p->ViewportSizeSupportPerSurface[k]);
4278#endif
4279
4280 }
4281
4282 *p->compbuf_reserved_space_64b = 2 * p->PixelChunkSizeInKByte * 1024 / 64;
4283 if (p->UnboundedRequestEnabled) {
4284 *p->compbuf_reserved_space_64b = dml_max(*p->compbuf_reserved_space_64b,
4285 (dml_float_t)(p->ROBBufferSizeInKByte * 1024/64)
4286 - (dml_float_t)(RoundedUpSwathSizeBytesY[SurfaceDoingUnboundedRequest] * TTUFIFODEPTH / MAXIMUMCOMPRESSION/64));
4287 }
4288 *p->compbuf_reserved_space_zs = 2 * p->PixelChunkSizeInKByte * 1024 / 256;
4289} // CalculateSwathAndDETConfiguration
4290
4291static void CalculateSwathWidth(
4292 dml_bool_t ForceSingleDPP,
4293 dml_uint_t NumberOfActiveSurfaces,
4294 enum dml_source_format_class SourcePixelFormat[],
4295 enum dml_rotation_angle SourceScan[],
4296 dml_bool_t ViewportStationary[],
4297 dml_uint_t ViewportWidth[],
4298 dml_uint_t ViewportHeight[],
4299 dml_uint_t ViewportXStart[],
4300 dml_uint_t ViewportYStart[],
4301 dml_uint_t ViewportXStartC[],
4302 dml_uint_t ViewportYStartC[],
4303 dml_uint_t SurfaceWidthY[],
4304 dml_uint_t SurfaceWidthC[],
4305 dml_uint_t SurfaceHeightY[],
4306 dml_uint_t SurfaceHeightC[],
4307 enum dml_odm_mode ODMMode[],
4308 dml_uint_t BytePerPixY[],
4309 dml_uint_t BytePerPixC[],
4310 dml_uint_t Read256BytesBlockHeightY[],
4311 dml_uint_t Read256BytesBlockHeightC[],
4312 dml_uint_t Read256BytesBlockWidthY[],
4313 dml_uint_t Read256BytesBlockWidthC[],
4314 dml_uint_t BlendingAndTiming[],
4315 dml_uint_t HActive[],
4316 dml_float_t HRatio[],
4317 dml_uint_t DPPPerSurface[],
4318
4319 // Output
4320 dml_uint_t SwathWidthSingleDPPY[],
4321 dml_uint_t SwathWidthSingleDPPC[],
4322 dml_uint_t SwathWidthY[], // per-pipe
4323 dml_uint_t SwathWidthC[], // per-pipe
4324 dml_uint_t MaximumSwathHeightY[],
4325 dml_uint_t MaximumSwathHeightC[],
4326 dml_uint_t swath_width_luma_ub[], // per-pipe
4327 dml_uint_t swath_width_chroma_ub[]) // per-pipe
4328{
4329 enum dml_odm_mode MainSurfaceODMMode;
4330 dml_uint_t surface_width_ub_l;
4331 dml_uint_t surface_height_ub_l;
4332 dml_uint_t surface_width_ub_c = 0;
4333 dml_uint_t surface_height_ub_c = 0;
4334
4335#ifdef __DML_VBA_DEBUG__
4336 dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, ForceSingleDPP);
4337 dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
4338#endif
4339
4340 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4341 if (!dml_is_vertical_rotation(SourceScan[k])) {
4342 SwathWidthSingleDPPY[k] = ViewportWidth[k];
4343 } else {
4344 SwathWidthSingleDPPY[k] = ViewportHeight[k];
4345 }
4346
4347#ifdef __DML_VBA_DEBUG__
4348 dml_print("DML::%s: k=%u ViewportWidth=%u\n", __func__, k, ViewportWidth[k]);
4349 dml_print("DML::%s: k=%u ViewportHeight=%u\n", __func__, k, ViewportHeight[k]);
4350 dml_print("DML::%s: k=%u DPPPerSurface=%u\n", __func__, k, DPPPerSurface[k]);
4351#endif
4352
4353 MainSurfaceODMMode = ODMMode[k];
4354 for (dml_uint_t j = 0; j < NumberOfActiveSurfaces; ++j) {
4355 if (BlendingAndTiming[k] == j) {
4356 MainSurfaceODMMode = ODMMode[j];
4357 }
4358 }
4359
4360 if (ForceSingleDPP) {
4361 SwathWidthY[k] = SwathWidthSingleDPPY[k];
4362 } else {
4363 if (MainSurfaceODMMode == dml_odm_mode_combine_4to1) {
4364 SwathWidthY[k] = (dml_uint_t)(dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 4.0 * HRatio[k], true)));
4365 } else if (MainSurfaceODMMode == dml_odm_mode_combine_2to1) {
4366 SwathWidthY[k] = (dml_uint_t)(dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 2.0 * HRatio[k], true)));
4367 } else if (DPPPerSurface[k] == 2) {
4368 SwathWidthY[k] = SwathWidthSingleDPPY[k] / 2;
4369 } else {
4370 SwathWidthY[k] = SwathWidthSingleDPPY[k];
4371 }
4372 }
4373
4374#ifdef __DML_VBA_DEBUG__
4375 dml_print("DML::%s: k=%u HActive=%u\n", __func__, k, HActive[k]);
4376 dml_print("DML::%s: k=%u HRatio=%f\n", __func__, k, HRatio[k]);
4377 dml_print("DML::%s: k=%u MainSurfaceODMMode=%u\n", __func__, k, MainSurfaceODMMode);
4378 dml_print("DML::%s: k=%u SwathWidthSingleDPPY=%u\n", __func__, k, SwathWidthSingleDPPY[k]);
4379 dml_print("DML::%s: k=%u SwathWidthY=%u\n", __func__, k, SwathWidthY[k]);
4380#endif
4381
4382 if (SourcePixelFormat[k] == dml_420_8 || SourcePixelFormat[k] == dml_420_10 || SourcePixelFormat[k] == dml_420_12) {
4383 SwathWidthC[k] = SwathWidthY[k] / 2;
4384 SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k] / 2;
4385 } else {
4386 SwathWidthC[k] = SwathWidthY[k];
4387 SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k];
4388 }
4389
4390 if (ForceSingleDPP == true) {
4391 SwathWidthY[k] = SwathWidthSingleDPPY[k];
4392 SwathWidthC[k] = SwathWidthSingleDPPC[k];
4393 }
4394
4395 surface_width_ub_l = (dml_uint_t)dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
4396 surface_height_ub_l = (dml_uint_t)dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
4397
4398 if (!dml_is_vertical_rotation(SourceScan[k])) {
4399 MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k];
4400 MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k];
4401 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4402 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_l, dml_floor(ViewportXStart[k] + SwathWidthY[k] + Read256BytesBlockWidthY[k] - 1, Read256BytesBlockWidthY[k]) - dml_floor(ViewportXStart[k], Read256BytesBlockWidthY[k])));
4403 } else {
4404 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_l, dml_ceil(SwathWidthY[k] - 1, Read256BytesBlockWidthY[k]) + Read256BytesBlockWidthY[k]));
4405 }
4406 if (BytePerPixC[k] > 0) {
4407 surface_width_ub_c = (dml_uint_t)dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
4408 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4409 swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_c, dml_floor(ViewportXStartC[k] + SwathWidthC[k] + Read256BytesBlockWidthC[k] - 1, Read256BytesBlockWidthC[k]) - dml_floor(ViewportXStartC[k], Read256BytesBlockWidthC[k])));
4410 } else {
4411 swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_c, dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockWidthC[k]) + Read256BytesBlockWidthC[k]));
4412 }
4413 } else {
4414 swath_width_chroma_ub[k] = 0;
4415 }
4416 } else {
4417 MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k];
4418 MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k];
4419
4420 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4421 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_l, dml_floor(ViewportYStart[k] + SwathWidthY[k] + Read256BytesBlockHeightY[k] - 1, Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStart[k], Read256BytesBlockHeightY[k])));
4422 } else {
4423 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_l, dml_ceil(SwathWidthY[k] - 1, Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]));
4424 }
4425 if (BytePerPixC[k] > 0) {
4426 surface_height_ub_c = (dml_uint_t)dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
4427 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4428 swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_c, dml_floor(ViewportYStartC[k] + SwathWidthC[k] + Read256BytesBlockHeightC[k] - 1, Read256BytesBlockHeightC[k]) - dml_floor(ViewportYStartC[k], Read256BytesBlockHeightC[k])));
4429 } else {
4430 swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_c, dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockHeightC[k]) + Read256BytesBlockHeightC[k]));
4431 }
4432 } else {
4433 swath_width_chroma_ub[k] = 0;
4434 }
4435 }
4436
4437#ifdef __DML_VBA_DEBUG__
4438 dml_print("DML::%s: k=%u surface_width_ub_l=%u\n", __func__, k, surface_width_ub_l);
4439 dml_print("DML::%s: k=%u surface_height_ub_l=%u\n", __func__, k, surface_height_ub_l);
4440 dml_print("DML::%s: k=%u surface_width_ub_c=%u\n", __func__, k, surface_width_ub_c);
4441 dml_print("DML::%s: k=%u surface_height_ub_c=%u\n", __func__, k, surface_height_ub_c);
4442 dml_print("DML::%s: k=%u Read256BytesBlockWidthY=%u\n", __func__, k, Read256BytesBlockWidthY[k]);
4443 dml_print("DML::%s: k=%u Read256BytesBlockHeightY=%u\n", __func__, k, Read256BytesBlockHeightY[k]);
4444 dml_print("DML::%s: k=%u Read256BytesBlockWidthC=%u\n", __func__, k, Read256BytesBlockWidthC[k]);
4445 dml_print("DML::%s: k=%u Read256BytesBlockHeightC=%u\n", __func__, k, Read256BytesBlockHeightC[k]);
4446 dml_print("DML::%s: k=%u ViewportStationary=%u\n", __func__, k, ViewportStationary[k]);
4447 dml_print("DML::%s: k=%u DPPPerSurface=%u\n", __func__, k, DPPPerSurface[k]);
4448 dml_print("DML::%s: k=%u swath_width_luma_ub=%u\n", __func__, k, swath_width_luma_ub[k]);
4449 dml_print("DML::%s: k=%u swath_width_chroma_ub=%u\n", __func__, k, swath_width_chroma_ub[k]);
4450 dml_print("DML::%s: k=%u MaximumSwathHeightY=%u\n", __func__, k, MaximumSwathHeightY[k]);
4451 dml_print("DML::%s: k=%u MaximumSwathHeightC=%u\n", __func__, k, MaximumSwathHeightC[k]);
4452#endif
4453
4454 }
4455} // CalculateSwathWidth
4456
4457static dml_float_t CalculateExtraLatency(
4458 dml_uint_t RoundTripPingLatencyCycles,
4459 dml_uint_t ReorderingBytes,
4460 dml_float_t DCFCLK,
4461 dml_uint_t TotalNumberOfActiveDPP,
4462 dml_uint_t PixelChunkSizeInKByte,
4463 dml_uint_t TotalNumberOfDCCActiveDPP,
4464 dml_uint_t MetaChunkSize,
4465 dml_float_t ReturnBW,
4466 dml_bool_t GPUVMEnable,
4467 dml_bool_t HostVMEnable,
4468 dml_uint_t NumberOfActiveSurfaces,
4469 dml_uint_t NumberOfDPP[],
4470 dml_uint_t dpte_group_bytes[],
4471 dml_float_t HostVMInefficiencyFactor,
4472 dml_uint_t HostVMMinPageSize,
4473 dml_uint_t HostVMMaxNonCachedPageTableLevels)
4474{
4475 dml_float_t ExtraLatencyBytes;
4476 dml_float_t ExtraLatency;
4477
4478 ExtraLatencyBytes = CalculateExtraLatencyBytes(
4479 ReorderingBytes,
4480 TotalNumberOfActiveDPP,
4481 PixelChunkSizeInKByte,
4482 TotalNumberOfDCCActiveDPP,
4483 MetaChunkSize,
4484 GPUVMEnable,
4485 HostVMEnable,
4486 NumberOfActiveSurfaces,
4487 NumberOfDPP,
4488 dpte_group_bytes,
4489 HostVMInefficiencyFactor,
4490 HostVMMinPageSize,
4491 HostVMMaxNonCachedPageTableLevels);
4492
4493 ExtraLatency = (RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__) / DCFCLK + ExtraLatencyBytes / ReturnBW;
4494
4495#ifdef __DML_VBA_DEBUG__
4496 dml_print("DML::%s: RoundTripPingLatencyCycles=%u\n", __func__, RoundTripPingLatencyCycles);
4497 dml_print("DML::%s: DCFCLK=%f\n", __func__, DCFCLK);
4498 dml_print("DML::%s: ExtraLatencyBytes=%f\n", __func__, ExtraLatencyBytes);
4499 dml_print("DML::%s: ReturnBW=%f\n", __func__, ReturnBW);
4500 dml_print("DML::%s: ExtraLatency=%f\n", __func__, ExtraLatency);
4501#endif
4502
4503 return ExtraLatency;
4504} // CalculateExtraLatency
4505
4506static dml_uint_t CalculateHostVMDynamicLevels(
4507 dml_bool_t GPUVMEnable,
4508 dml_bool_t HostVMEnable,
4509 dml_uint_t HostVMMinPageSize,
4510 dml_uint_t HostVMMaxNonCachedPageTableLevels)
4511{
4512 dml_uint_t HostVMDynamicLevels = 0;
4513
4514 if (GPUVMEnable && HostVMEnable) {
4515 if (HostVMMinPageSize < 2048)
4516 HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
4517 else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576)
4518 HostVMDynamicLevels = (dml_uint_t) dml_max(0, (dml_float_t) HostVMMaxNonCachedPageTableLevels - 1);
4519 else
4520 HostVMDynamicLevels = (dml_uint_t) dml_max(0, (dml_float_t) HostVMMaxNonCachedPageTableLevels - 2);
4521 } else {
4522 HostVMDynamicLevels = 0;
4523 }
4524 return HostVMDynamicLevels;
4525}
4526
4527static dml_uint_t CalculateExtraLatencyBytes(dml_uint_t ReorderingBytes,
4528 dml_uint_t TotalNumberOfActiveDPP,
4529 dml_uint_t PixelChunkSizeInKByte,
4530 dml_uint_t TotalNumberOfDCCActiveDPP,
4531 dml_uint_t MetaChunkSize,
4532 dml_bool_t GPUVMEnable,
4533 dml_bool_t HostVMEnable,
4534 dml_uint_t NumberOfActiveSurfaces,
4535 dml_uint_t NumberOfDPP[],
4536 dml_uint_t dpte_group_bytes[],
4537 dml_float_t HostVMInefficiencyFactor,
4538 dml_uint_t HostVMMinPageSize,
4539 dml_uint_t HostVMMaxNonCachedPageTableLevels)
4540{
4541 dml_uint_t HostVMDynamicLevels = CalculateHostVMDynamicLevels(GPUVMEnable, HostVMEnable, HostVMMinPageSize, HostVMMaxNonCachedPageTableLevels);
4542 dml_float_t ret = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte + TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0;
4543
4544 if (GPUVMEnable == true) {
4545 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4546 ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] * (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor;
4547 }
4548 }
4549 return (dml_uint_t)(ret);
4550}
4551
4552static dml_float_t CalculateUrgentLatency(
4553 dml_float_t UrgentLatencyPixelDataOnly,
4554 dml_float_t UrgentLatencyPixelMixedWithVMData,
4555 dml_float_t UrgentLatencyVMDataOnly,
4556 dml_bool_t DoUrgentLatencyAdjustment,
4557 dml_float_t UrgentLatencyAdjustmentFabricClockComponent,
4558 dml_float_t UrgentLatencyAdjustmentFabricClockReference,
4559 dml_float_t FabricClock)
4560{
4561 dml_float_t ret;
4562
4563 ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly);
4564 if (DoUrgentLatencyAdjustment == true) {
4565 ret = ret + UrgentLatencyAdjustmentFabricClockComponent * (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
4566 }
4567 return ret;
4568}
4569
4570static dml_float_t RequiredDTBCLK(
4571 dml_bool_t DSCEnable,
4572 dml_float_t PixelClock,
4573 enum dml_output_format_class OutputFormat,
4574 dml_float_t OutputBpp,
4575 dml_uint_t DSCSlices,
4576 dml_uint_t HTotal,
4577 dml_uint_t HActive,
4578 dml_uint_t AudioRate,
4579 dml_uint_t AudioLayout)
4580{
4581 if (DSCEnable != true) {
4582 return dml_max(PixelClock / 4.0 * OutputBpp / 24.0, 25.0);
4583 } else {
4584 dml_float_t PixelWordRate = PixelClock / (OutputFormat == dml_444 ? 1 : 2);
4585 dml_float_t HCActive = dml_ceil(DSCSlices * dml_ceil(OutputBpp * dml_ceil(HActive / DSCSlices, 1) / 8.0, 1) / 3.0, 1);
4586 dml_float_t HCBlank = 64 + 32 * dml_ceil(AudioRate * (AudioLayout == 1 ? 1 : 0.25) * HTotal / (PixelClock * 1000), 1);
4587 dml_float_t AverageTribyteRate = PixelWordRate * (HCActive + HCBlank) / HTotal;
4588 dml_float_t HActiveTribyteRate = PixelWordRate * HCActive / HActive;
4589 return dml_max4(PixelWordRate / 4.0, AverageTribyteRate / 4.0, HActiveTribyteRate / 4.0, 25.0) * 1.002;
4590 }
4591}
4592
4593static void UseMinimumDCFCLK(struct display_mode_lib_scratch_st *scratch, struct UseMinimumDCFCLK_params_st *p)
4594{
4595 struct UseMinimumDCFCLK_locals_st *s = &scratch->UseMinimumDCFCLK_locals;
4596
4597 s->NormalEfficiency = p->PercentOfIdealSDPPortBWReceivedAfterUrgLatency / 100.0;
4598 for (dml_uint_t j = 0; j < 2; ++j) {
4599
4600
4601 s->TotalMaxPrefetchFlipDPTERowBandwidth[j] = 0;
4602 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4603 s->TotalMaxPrefetchFlipDPTERowBandwidth[j] = s->TotalMaxPrefetchFlipDPTERowBandwidth[j] + p->NoOfDPP[j][k] * p->DPTEBytesPerRow[j][k] / (15.75 * p->HTotal[k] / p->PixelClock[k]);
4604 }
4605
4606 for (dml_uint_t k = 0; k <= p->NumberOfActiveSurfaces - 1; ++k) {
4607 s->NoOfDPPState[k] = p->NoOfDPP[j][k];
4608 }
4609
4610 s->DPTEBandwidth = s->TotalMaxPrefetchFlipDPTERowBandwidth[j];
4611
4612 s->DCFCLKRequiredForAverageBandwidth = dml_max(p->ProjectedDCFCLKDeepSleep[j], s->DPTEBandwidth / s->NormalEfficiency / p->ReturnBusWidth);
4613
4614 s->ExtraLatencyBytes = CalculateExtraLatencyBytes(p->ReorderingBytes, p->TotalNumberOfActiveDPP[j], p->PixelChunkSizeInKByte, p->TotalNumberOfDCCActiveDPP[j],
4615 p->MetaChunkSize, p->GPUVMEnable, p->HostVMEnable, p->NumberOfActiveSurfaces, s->NoOfDPPState, p->dpte_group_bytes,
4616 1, p->HostVMMinPageSize, p->HostVMMaxNonCachedPageTableLevels);
4617 s->ExtraLatencyCycles = p->RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__ + s->ExtraLatencyBytes / s->NormalEfficiency / p->ReturnBusWidth;
4618 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4619 dml_float_t DCFCLKCyclesRequiredInPrefetch;
4620 dml_float_t PrefetchTime;
4621
4622 s->PixelDCFCLKCyclesRequiredInPrefetch[k] = (p->PrefetchLinesY[j][k] * p->swath_width_luma_ub_all_states[j][k] * p->BytePerPixelY[k] + p->PrefetchLinesC[j][k] * p->swath_width_chroma_ub_all_states[j][k] * p->BytePerPixelC[k]) / s->NormalEfficiency / p->ReturnBusWidth;
4623 DCFCLKCyclesRequiredInPrefetch = 2 * s->ExtraLatencyCycles / s->NoOfDPPState[k] + p->PDEAndMetaPTEBytesPerFrame[j][k] / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth * (p->GPUVMMaxPageTableLevels > 2 ? 1 : 0) + 2 * p->DPTEBytesPerRow[j][k] / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth + 2 * p->MetaRowBytes[j][k] / s->NormalEfficiency / p->ReturnBusWidth + s->PixelDCFCLKCyclesRequiredInPrefetch[k];
4624 s->PrefetchPixelLinesTime[k] = dml_max(p->PrefetchLinesY[j][k], p->PrefetchLinesC[j][k]) * p->HTotal[k] / p->PixelClock[k];
4625 s->DynamicMetadataVMExtraLatency[k] = (p->GPUVMEnable == true && p->DynamicMetadataEnable[k] == true && p->DynamicMetadataVMEnabled == true) ? p->UrgLatency * p->GPUVMMaxPageTableLevels * (p->HostVMEnable == true ? p->HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0;
4626
4627 s->MinimumTWait = CalculateTWait(p->MaxPrefetchMode,
4628 p->UseMALLForPStateChange[k],
4629 p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
4630 p->DRRDisplay[k],
4631 p->DRAMClockChangeLatencyFinal,
4632 p->FCLKChangeLatency,
4633 p->UrgLatency,
4634 p->SREnterPlusExitTime);
4635
4636 PrefetchTime = (p->MaximumVStartup[j][k] - 1) * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - p->UrgLatency * ((p->GPUVMMaxPageTableLevels <= 2 ? p->GPUVMMaxPageTableLevels : p->GPUVMMaxPageTableLevels - 2) * (p->HostVMEnable == true ? p->HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) - s->DynamicMetadataVMExtraLatency[k];
4637
4638 if (PrefetchTime > 0) {
4639 dml_float_t ExpectedVRatioPrefetch;
4640 ExpectedVRatioPrefetch = s->PrefetchPixelLinesTime[k] / (PrefetchTime * s->PixelDCFCLKCyclesRequiredInPrefetch[k] / DCFCLKCyclesRequiredInPrefetch);
4641 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = s->NoOfDPPState[k] * s->PixelDCFCLKCyclesRequiredInPrefetch[k] / s->PrefetchPixelLinesTime[k] * dml_max(1.0, ExpectedVRatioPrefetch) * dml_max(1.0, ExpectedVRatioPrefetch / 4);
4642 if (p->HostVMEnable == true || p->ImmediateFlipRequirement == true) {
4643 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = s->DCFCLKRequiredForPeakBandwidthPerSurface[k] + s->NoOfDPPState[k] * s->DPTEBandwidth / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth;
4644 }
4645 } else {
4646 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = p->DCFCLKPerState;
4647 }
4648 if (p->DynamicMetadataEnable[k] == true) {
4649 dml_float_t TSetupPipe;
4650 dml_float_t TdmbfPipe;
4651 dml_float_t TdmsksPipe;
4652 dml_float_t TdmecPipe;
4653 dml_float_t AllowedTimeForUrgentExtraLatency;
4654
4655 CalculateVUpdateAndDynamicMetadataParameters(
4656 p->MaxInterDCNTileRepeaters,
4657 p->RequiredDPPCLKPerSurface[j][k],
4658 p->RequiredDISPCLK[j],
4659 p->ProjectedDCFCLKDeepSleep[j],
4660 p->PixelClock[k],
4661 p->HTotal[k],
4662 p->VTotal[k] - p->VActive[k],
4663 p->DynamicMetadataTransmittedBytes[k],
4664 p->DynamicMetadataLinesBeforeActiveRequired[k],
4665 p->Interlace[k],
4666 p->ProgressiveToInterlaceUnitInOPP,
4667
4668 // Output
4669 &TSetupPipe,
4670 &TdmbfPipe,
4671 &TdmecPipe,
4672 &TdmsksPipe,
4673 &s->dummy1,
4674 &s->dummy2,
4675 &s->dummy3);
4676
4677 AllowedTimeForUrgentExtraLatency = p->MaximumVStartup[j][k] * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - TSetupPipe - TdmbfPipe - TdmecPipe - TdmsksPipe - s->DynamicMetadataVMExtraLatency[k];
4678 if (AllowedTimeForUrgentExtraLatency > 0) {
4679 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = dml_max(s->DCFCLKRequiredForPeakBandwidthPerSurface[k], s->ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency);
4680 } else {
4681 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = p->DCFCLKPerState;
4682 }
4683 }
4684 }
4685 s->DCFCLKRequiredForPeakBandwidth = 0;
4686 for (dml_uint_t k = 0; k <= p->NumberOfActiveSurfaces - 1; ++k) {
4687 s->DCFCLKRequiredForPeakBandwidth = s->DCFCLKRequiredForPeakBandwidth + s->DCFCLKRequiredForPeakBandwidthPerSurface[k];
4688 }
4689 s->MinimumTvmPlus2Tr0 = p->UrgLatency * (p->GPUVMEnable == true ? (p->HostVMEnable == true ? (p->GPUVMMaxPageTableLevels + 2) * (p->HostVMMaxNonCachedPageTableLevels + 1) - 1 : p->GPUVMMaxPageTableLevels + 1) : 0);
4690 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4691 dml_float_t MaximumTvmPlus2Tr0PlusTsw;
4692 MaximumTvmPlus2Tr0PlusTsw = (p->MaximumVStartup[j][k] - 2) * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - s->DynamicMetadataVMExtraLatency[k];
4693 if (MaximumTvmPlus2Tr0PlusTsw <= s->MinimumTvmPlus2Tr0 + s->PrefetchPixelLinesTime[k] / 4) {
4694 s->DCFCLKRequiredForPeakBandwidth = p->DCFCLKPerState;
4695 } else {
4696 s->DCFCLKRequiredForPeakBandwidth = dml_max3(s->DCFCLKRequiredForPeakBandwidth,
4697 2 * s->ExtraLatencyCycles / (MaximumTvmPlus2Tr0PlusTsw - s->MinimumTvmPlus2Tr0 - s->PrefetchPixelLinesTime[k] / 4),
4698 (2 * s->ExtraLatencyCycles + s->PixelDCFCLKCyclesRequiredInPrefetch[k]) / (MaximumTvmPlus2Tr0PlusTsw - s->MinimumTvmPlus2Tr0));
4699 }
4700 }
4701 p->DCFCLKState[j] = dml_min(p->DCFCLKPerState, 1.05 * dml_max(s->DCFCLKRequiredForAverageBandwidth, s->DCFCLKRequiredForPeakBandwidth));
4702 }
4703}
4704
4705
4706static dml_bool_t UnboundedRequest(enum dml_unbounded_requesting_policy UseUnboundedRequestingFinal,
4707 dml_uint_t TotalNumberOfActiveDPP,
4708 dml_bool_t NoChromaOrLinear,
4709 enum dml_output_encoder_class Output)
4710{
4711 dml_bool_t ret_val = false;
4712
4713 ret_val = (UseUnboundedRequestingFinal != dml_unbounded_requesting_disable
4714 && TotalNumberOfActiveDPP == 1 && NoChromaOrLinear);
4715 if (UseUnboundedRequestingFinal == dml_unbounded_requesting_edp_only && Output != dml_edp) {
4716 ret_val = false;
4717 }
4718 return (ret_val);
4719}
4720
4721static void CalculateSurfaceSizeInMall(
4722 dml_uint_t NumberOfActiveSurfaces,
4723 dml_uint_t MALLAllocatedForDCN,
4724 enum dml_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
4725 dml_bool_t DCCEnable[],
4726 dml_bool_t ViewportStationary[],
4727 dml_uint_t ViewportXStartY[],
4728 dml_uint_t ViewportYStartY[],
4729 dml_uint_t ViewportXStartC[],
4730 dml_uint_t ViewportYStartC[],
4731 dml_uint_t ViewportWidthY[],
4732 dml_uint_t ViewportHeightY[],
4733 dml_uint_t BytesPerPixelY[],
4734 dml_uint_t ViewportWidthC[],
4735 dml_uint_t ViewportHeightC[],
4736 dml_uint_t BytesPerPixelC[],
4737 dml_uint_t SurfaceWidthY[],
4738 dml_uint_t SurfaceWidthC[],
4739 dml_uint_t SurfaceHeightY[],
4740 dml_uint_t SurfaceHeightC[],
4741 dml_uint_t Read256BytesBlockWidthY[],
4742 dml_uint_t Read256BytesBlockWidthC[],
4743 dml_uint_t Read256BytesBlockHeightY[],
4744 dml_uint_t Read256BytesBlockHeightC[],
4745 dml_uint_t ReadBlockWidthY[],
4746 dml_uint_t ReadBlockWidthC[],
4747 dml_uint_t ReadBlockHeightY[],
4748 dml_uint_t ReadBlockHeightC[],
4749
4750 // Output
4751 dml_uint_t SurfaceSizeInMALL[],
4752 dml_bool_t *ExceededMALLSize)
4753{
4754 dml_uint_t TotalSurfaceSizeInMALL = 0;
4755
4756 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4757 if (ViewportStationary[k]) {
4758 SurfaceSizeInMALL[k] = (dml_uint_t)(dml_min(dml_ceil(SurfaceWidthY[k], ReadBlockWidthY[k]), dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + ReadBlockWidthY[k] - 1, ReadBlockWidthY[k]) - dml_floor(ViewportXStartY[k], ReadBlockWidthY[k])) *
4759 dml_min(dml_ceil(SurfaceHeightY[k], ReadBlockHeightY[k]), dml_floor(ViewportYStartY[k] + ViewportHeightY[k] + ReadBlockHeightY[k] - 1, ReadBlockHeightY[k]) - dml_floor(ViewportYStartY[k], ReadBlockHeightY[k])) *
4760 BytesPerPixelY[k]);
4761
4762 if (ReadBlockWidthC[k] > 0) {
4763 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4764 dml_min(dml_ceil(SurfaceWidthC[k], ReadBlockWidthC[k]), dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + ReadBlockWidthC[k] - 1, ReadBlockWidthC[k]) - dml_floor(ViewportXStartC[k], ReadBlockWidthC[k])) *
4765 dml_min(dml_ceil(SurfaceHeightC[k], ReadBlockHeightC[k]), dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + ReadBlockHeightC[k] - 1, ReadBlockHeightC[k]) - dml_floor(ViewportYStartC[k], ReadBlockHeightC[k])) * BytesPerPixelC[k]);
4766 }
4767 if (DCCEnable[k] == true) {
4768 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4769 dml_min(dml_ceil(SurfaceWidthY[k], 8 * Read256BytesBlockWidthY[k]), dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + 8 * Read256BytesBlockWidthY[k] - 1, 8 * Read256BytesBlockWidthY[k]) - dml_floor(ViewportXStartY[k], 8 * Read256BytesBlockWidthY[k])) *
4770 dml_min(dml_ceil(SurfaceHeightY[k], 8 * Read256BytesBlockHeightY[k]), dml_floor(ViewportYStartY[k] + ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1, 8 * Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStartY[k], 8 * Read256BytesBlockHeightY[k])) * BytesPerPixelY[k] / 256);
4771 if (Read256BytesBlockWidthC[k] > 0) {
4772 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4773 dml_min(dml_ceil(SurfaceWidthC[k], 8 * Read256BytesBlockWidthC[k]), dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + 8 * Read256BytesBlockWidthC[k] - 1, 8 * Read256BytesBlockWidthC[k]) - dml_floor(ViewportXStartC[k], 8 * Read256BytesBlockWidthC[k])) *
4774 dml_min(dml_ceil(SurfaceHeightC[k], 8 * Read256BytesBlockHeightC[k]), dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + 8 * Read256BytesBlockHeightC[k] - 1, 8 * Read256BytesBlockHeightC[k]) - dml_floor(ViewportYStartC[k], 8 * Read256BytesBlockHeightC[k])) * BytesPerPixelC[k] / 256);
4775 }
4776 }
4777 } else {
4778 SurfaceSizeInMALL[k] = (dml_uint_t)(dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + ReadBlockWidthY[k] - 1), ReadBlockWidthY[k]) * dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + ReadBlockHeightY[k] - 1), ReadBlockHeightY[k]) * BytesPerPixelY[k]);
4779 if (ReadBlockWidthC[k] > 0) {
4780 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4781 dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + ReadBlockWidthC[k] - 1), ReadBlockWidthC[k]) *
4782 dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + ReadBlockHeightC[k] - 1), ReadBlockHeightC[k]) * BytesPerPixelC[k]);
4783 }
4784 if (DCCEnable[k] == true) {
4785 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4786 dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + 8 * Read256BytesBlockWidthY[k] - 1), 8 * Read256BytesBlockWidthY[k]) *
4787 dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1), 8 * Read256BytesBlockHeightY[k]) * BytesPerPixelY[k] / 256);
4788
4789 if (Read256BytesBlockWidthC[k] > 0) {
4790 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4791 dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + 8 * Read256BytesBlockWidthC[k] - 1), 8 * Read256BytesBlockWidthC[k]) *
4792 dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + 8 * Read256BytesBlockHeightC[k] - 1), 8 * Read256BytesBlockHeightC[k]) * BytesPerPixelC[k] / 256);
4793 }
4794 }
4795 }
4796 }
4797
4798 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4799 if (UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable)
4800 TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k];
4801 }
4802 *ExceededMALLSize = (TotalSurfaceSizeInMALL <= MALLAllocatedForDCN * 1024 * 1024 ? false : true);
4803} // CalculateSurfaceSizeInMall
4804
4805static void CalculateDETBufferSize(
4806 dml_uint_t DETSizeOverride[],
4807 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
4808 dml_bool_t ForceSingleDPP,
4809 dml_uint_t NumberOfActiveSurfaces,
4810 dml_bool_t UnboundedRequestEnabled,
4811 dml_uint_t nomDETInKByte,
4812 dml_uint_t MaxTotalDETInKByte,
4813 dml_uint_t ConfigReturnBufferSizeInKByte,
4814 dml_uint_t MinCompressedBufferSizeInKByte,
4815 dml_uint_t ConfigReturnBufferSegmentSizeInkByte,
4816 dml_uint_t CompressedBufferSegmentSizeInkByteFinal,
4817 enum dml_source_format_class SourcePixelFormat[],
4818 dml_float_t ReadBandwidthLuma[],
4819 dml_float_t ReadBandwidthChroma[],
4820 dml_uint_t RoundedUpMaxSwathSizeBytesY[],
4821 dml_uint_t RoundedUpMaxSwathSizeBytesC[],
4822 dml_uint_t DPPPerSurface[],
4823 // Output
4824 dml_uint_t DETBufferSizeInKByte[],
4825 dml_uint_t *CompressedBufferSizeInkByte)
4826{
4827 dml_uint_t DETBufferSizePoolInKByte;
4828 dml_uint_t NextDETBufferPieceInKByte;
4829 dml_bool_t DETPieceAssignedToThisSurfaceAlready[__DML_NUM_PLANES__];
4830 dml_bool_t NextPotentialSurfaceToAssignDETPieceFound;
4831 dml_uint_t NextSurfaceToAssignDETPiece;
4832 dml_float_t TotalBandwidth;
4833 dml_float_t BandwidthOfSurfacesNotAssignedDETPiece;
4834 dml_uint_t max_minDET;
4835 dml_uint_t minDET;
4836 dml_uint_t minDET_pipe;
4837
4838#ifdef __DML_VBA_DEBUG__
4839 dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, ForceSingleDPP);
4840 dml_print("DML::%s: nomDETInKByte = %u\n", __func__, nomDETInKByte);
4841 dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
4842 dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, UnboundedRequestEnabled);
4843 dml_print("DML::%s: MaxTotalDETInKByte = %u\n", __func__, MaxTotalDETInKByte);
4844 dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, ConfigReturnBufferSizeInKByte);
4845 dml_print("DML::%s: MinCompressedBufferSizeInKByte = %u\n", __func__, MinCompressedBufferSizeInKByte);
4846 dml_print("DML::%s: CompressedBufferSegmentSizeInkByteFinal = %u\n", __func__, CompressedBufferSegmentSizeInkByteFinal);
4847#endif
4848
4849 // Note: Will use default det size if that fits 2 swaths
4850 if (UnboundedRequestEnabled) {
4851 if (DETSizeOverride[0] > 0) {
4852 DETBufferSizeInKByte[0] = DETSizeOverride[0];
4853 } else {
4854 DETBufferSizeInKByte[0] = (dml_uint_t) dml_max(128.0, dml_ceil(2.0 * ((dml_float_t) RoundedUpMaxSwathSizeBytesY[0] + (dml_float_t) RoundedUpMaxSwathSizeBytesC[0]) / 1024.0, ConfigReturnBufferSegmentSizeInkByte));
4855 }
4856 *CompressedBufferSizeInkByte = ConfigReturnBufferSizeInKByte - DETBufferSizeInKByte[0];
4857 } else {
4858 DETBufferSizePoolInKByte = MaxTotalDETInKByte;
4859 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4860 DETBufferSizeInKByte[k] = 0;
4861 if (SourcePixelFormat[k] == dml_420_8 || SourcePixelFormat[k] == dml_420_10 || SourcePixelFormat[k] == dml_420_12) {
4862 max_minDET = nomDETInKByte - ConfigReturnBufferSegmentSizeInkByte;
4863 } else {
4864 max_minDET = nomDETInKByte;
4865 }
4866 minDET = 128;
4867 minDET_pipe = 0;
4868
4869 // add DET resource until can hold 2 full swaths
4870 while (minDET <= max_minDET && minDET_pipe == 0) {
4871 if (2.0 * ((dml_float_t) RoundedUpMaxSwathSizeBytesY[k] + (dml_float_t) RoundedUpMaxSwathSizeBytesC[k]) / 1024.0 <= minDET)
4872 minDET_pipe = minDET;
4873 minDET = minDET + ConfigReturnBufferSegmentSizeInkByte;
4874 }
4875
4876#ifdef __DML_VBA_DEBUG__
4877 dml_print("DML::%s: k=%u minDET = %u\n", __func__, k, minDET);
4878 dml_print("DML::%s: k=%u max_minDET = %u\n", __func__, k, max_minDET);
4879 dml_print("DML::%s: k=%u minDET_pipe = %u\n", __func__, k, minDET_pipe);
4880 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4881 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4882#endif
4883
4884 if (minDET_pipe == 0) {
4885 minDET_pipe = (dml_uint_t)(dml_max(128, dml_ceil(((dml_float_t)RoundedUpMaxSwathSizeBytesY[k] + (dml_float_t)RoundedUpMaxSwathSizeBytesC[k]) / 1024.0, ConfigReturnBufferSegmentSizeInkByte)));
4886#ifdef __DML_VBA_DEBUG__
4887 dml_print("DML::%s: k=%u minDET_pipe = %u (assume each plane take half DET)\n", __func__, k, minDET_pipe);
4888#endif
4889 }
4890
4891 if (UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) {
4892 DETBufferSizeInKByte[k] = 0;
4893 } else if (DETSizeOverride[k] > 0) {
4894 DETBufferSizeInKByte[k] = DETSizeOverride[k];
4895 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - (ForceSingleDPP ? 1 : DPPPerSurface[k]) * DETSizeOverride[k];
4896 } else if ((ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe <= DETBufferSizePoolInKByte) {
4897 DETBufferSizeInKByte[k] = minDET_pipe;
4898 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - (ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe;
4899 }
4900
4901#ifdef __DML_VBA_DEBUG__
4902 dml_print("DML::%s: k=%u DPPPerSurface = %u\n", __func__, k, DPPPerSurface[k]);
4903 dml_print("DML::%s: k=%u DETSizeOverride = %u\n", __func__, k, DETSizeOverride[k]);
4904 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u\n", __func__, k, DETBufferSizeInKByte[k]);
4905 dml_print("DML::%s: DETBufferSizePoolInKByte = %u\n", __func__, DETBufferSizePoolInKByte);
4906#endif
4907 }
4908
4909 TotalBandwidth = 0;
4910 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4911 if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe)
4912 TotalBandwidth = TotalBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
4913 }
4914#ifdef __DML_VBA_DEBUG__
4915 dml_print("DML::%s: --- Before bandwidth adjustment ---\n", __func__);
4916 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4917 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u\n", __func__, k, DETBufferSizeInKByte[k]);
4918 }
4919 dml_print("DML::%s: --- DET allocation with bandwidth ---\n", __func__);
4920#endif
4921 dml_print("DML::%s: TotalBandwidth = %f\n", __func__, TotalBandwidth);
4922 BandwidthOfSurfacesNotAssignedDETPiece = TotalBandwidth;
4923 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4924
4925 if (UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) {
4926 DETPieceAssignedToThisSurfaceAlready[k] = true;
4927 } else if (DETSizeOverride[k] > 0 || (((dml_float_t) (ForceSingleDPP ? 1 : DPPPerSurface[k]) * (dml_float_t) DETBufferSizeInKByte[k] / (dml_float_t) MaxTotalDETInKByte) >= ((ReadBandwidthLuma[k] + ReadBandwidthChroma[k]) / TotalBandwidth))) {
4928 DETPieceAssignedToThisSurfaceAlready[k] = true;
4929 BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - ReadBandwidthLuma[k] - ReadBandwidthChroma[k];
4930 } else {
4931 DETPieceAssignedToThisSurfaceAlready[k] = false;
4932 }
4933#ifdef __DML_VBA_DEBUG__
4934 dml_print("DML::%s: k=%u DETPieceAssignedToThisSurfaceAlready = %u\n", __func__, k, DETPieceAssignedToThisSurfaceAlready[k]);
4935 dml_print("DML::%s: k=%u BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, k, BandwidthOfSurfacesNotAssignedDETPiece);
4936#endif
4937 }
4938
4939 for (dml_uint_t j = 0; j < NumberOfActiveSurfaces; ++j) {
4940 NextPotentialSurfaceToAssignDETPieceFound = false;
4941 NextSurfaceToAssignDETPiece = 0;
4942
4943 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4944#ifdef __DML_VBA_DEBUG__
4945 dml_print("DML::%s: j=%u k=%u, ReadBandwidthLuma[k] = %f\n", __func__, j, k, ReadBandwidthLuma[k]);
4946 dml_print("DML::%s: j=%u k=%u, ReadBandwidthChroma[k] = %f\n", __func__, j, k, ReadBandwidthChroma[k]);
4947 dml_print("DML::%s: j=%u k=%u, ReadBandwidthLuma[Next] = %f\n", __func__, j, k, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
4948 dml_print("DML::%s: j=%u k=%u, ReadBandwidthChroma[Next] = %f\n", __func__, j, k, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4949 dml_print("DML::%s: j=%u k=%u, NextSurfaceToAssignDETPiece = %u\n", __func__, j, k, NextSurfaceToAssignDETPiece);
4950#endif
4951 if (!DETPieceAssignedToThisSurfaceAlready[k] && (!NextPotentialSurfaceToAssignDETPieceFound ||
4952 ReadBandwidthLuma[k] + ReadBandwidthChroma[k] < ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece])) {
4953 NextSurfaceToAssignDETPiece = k;
4954 NextPotentialSurfaceToAssignDETPieceFound = true;
4955 }
4956#ifdef __DML_VBA_DEBUG__
4957 dml_print("DML::%s: j=%u k=%u, DETPieceAssignedToThisSurfaceAlready = %u\n", __func__, j, k, DETPieceAssignedToThisSurfaceAlready[k]);
4958 dml_print("DML::%s: j=%u k=%u, NextPotentialSurfaceToAssignDETPieceFound = %u\n", __func__, j, k, NextPotentialSurfaceToAssignDETPieceFound);
4959#endif
4960 }
4961
4962 if (NextPotentialSurfaceToAssignDETPieceFound) {
4963 // Note: To show the banker's rounding behavior in VBA and also the fact that the DET buffer size varies due to precision issue
4964 //
4965 //dml_float_t tmp1 = ((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4966 // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
4967 //dml_float_t tmp2 = dml_round((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4968 // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
4969 //
4970 //dml_print("DML::%s: j=%u, tmp1 = %f\n", __func__, j, tmp1);
4971 //dml_print("DML::%s: j=%u, tmp2 = %f\n", __func__, j, tmp2);
4972
4973 NextDETBufferPieceInKByte = (dml_uint_t)(dml_min(
4974 dml_round((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4975 ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte), true)
4976 * (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte,
4977 dml_floor((dml_float_t) DETBufferSizePoolInKByte, (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte)));
4978
4979#ifdef __DML_VBA_DEBUG__
4980 dml_print("DML::%s: j=%u, DETBufferSizePoolInKByte = %u\n", __func__, j, DETBufferSizePoolInKByte);
4981 dml_print("DML::%s: j=%u, NextSurfaceToAssignDETPiece = %u\n", __func__, j, NextSurfaceToAssignDETPiece);
4982 dml_print("DML::%s: j=%u, ReadBandwidthLuma[%u] = %f\n", __func__, j, NextSurfaceToAssignDETPiece, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
4983 dml_print("DML::%s: j=%u, ReadBandwidthChroma[%u] = %f\n", __func__, j, NextSurfaceToAssignDETPiece, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4984 dml_print("DML::%s: j=%u, BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, j, BandwidthOfSurfacesNotAssignedDETPiece);
4985 dml_print("DML::%s: j=%u, NextDETBufferPieceInKByte = %u\n", __func__, j, NextDETBufferPieceInKByte);
4986 dml_print("DML::%s: j=%u, DETBufferSizeInKByte[%u] increases from %u ", __func__, j, NextSurfaceToAssignDETPiece, DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
4987#endif
4988
4989 DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] = DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] + NextDETBufferPieceInKByte / (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]);
4990#ifdef __DML_VBA_DEBUG__
4991 dml_print("to %u\n", DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
4992#endif
4993
4994 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - NextDETBufferPieceInKByte;
4995 DETPieceAssignedToThisSurfaceAlready[NextSurfaceToAssignDETPiece] = true;
4996 BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4997 }
4998 }
4999 *CompressedBufferSizeInkByte = MinCompressedBufferSizeInKByte;
5000 }
5001 *CompressedBufferSizeInkByte = *CompressedBufferSizeInkByte * CompressedBufferSegmentSizeInkByteFinal / ConfigReturnBufferSegmentSizeInkByte;
5002
5003#ifdef __DML_VBA_DEBUG__
5004 dml_print("DML::%s: --- After bandwidth adjustment ---\n", __func__);
5005 dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, *CompressedBufferSizeInkByte);
5006 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5007 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u (TotalReadBandWidth=%f)\n", __func__, k, DETBufferSizeInKByte[k], ReadBandwidthLuma[k] + ReadBandwidthChroma[k]);
5008 }
5009#endif
5010} // CalculateDETBufferSize
5011
5012
5013/// @brief Calculate the bound for return buffer sizing
5014static void CalculateMaxDETAndMinCompressedBufferSize(
5015 dml_uint_t ConfigReturnBufferSizeInKByte,
5016 dml_uint_t ConfigReturnBufferSegmentSizeInKByte,
5017 dml_uint_t ROBBufferSizeInKByte,
5018 dml_uint_t MaxNumDPP,
5019 dml_bool_t nomDETInKByteOverrideEnable, // VBA_DELTA, allow DV to override default DET size
5020 dml_uint_t nomDETInKByteOverrideValue, // VBA_DELTA
5021
5022 // Output
5023 dml_uint_t *MaxTotalDETInKByte,
5024 dml_uint_t *nomDETInKByte,
5025 dml_uint_t *MinCompressedBufferSizeInKByte)
5026{
5027 *MaxTotalDETInKByte = ConfigReturnBufferSizeInKByte - ConfigReturnBufferSegmentSizeInKByte;
5028 *nomDETInKByte = (dml_uint_t)(dml_floor((dml_float_t) *MaxTotalDETInKByte / (dml_float_t) MaxNumDPP, ConfigReturnBufferSegmentSizeInKByte));
5029 *MinCompressedBufferSizeInKByte = ConfigReturnBufferSizeInKByte - *MaxTotalDETInKByte;
5030
5031#ifdef __DML_VBA_DEBUG__
5032 dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, ConfigReturnBufferSizeInKByte);
5033 dml_print("DML::%s: ROBBufferSizeInKByte = %u\n", __func__, ROBBufferSizeInKByte);
5034 dml_print("DML::%s: MaxNumDPP = %u\n", __func__, MaxNumDPP);
5035 dml_print("DML::%s: MaxTotalDETInKByte = %u\n", __func__, *MaxTotalDETInKByte);
5036 dml_print("DML::%s: nomDETInKByte = %u\n", __func__, *nomDETInKByte);
5037 dml_print("DML::%s: MinCompressedBufferSizeInKByte = %u\n", __func__, *MinCompressedBufferSizeInKByte);
5038#endif
5039
5040 if (nomDETInKByteOverrideEnable) {
5041 *nomDETInKByte = nomDETInKByteOverrideValue;
5042 dml_print("DML::%s: nomDETInKByte = %u (overrided)\n", __func__, *nomDETInKByte);
5043 }
5044} // CalculateMaxDETAndMinCompressedBufferSize
5045
5046/// @brief Calculate all the RQ request attributes, like row height and # swath
5047static void CalculateVMRowAndSwath(struct display_mode_lib_scratch_st *scratch,
5048 struct CalculateVMRowAndSwath_params_st *p)
5049{
5050 struct CalculateVMRowAndSwath_locals_st *s = &scratch->CalculateVMRowAndSwath_locals;
5051
5052 s->HostVMDynamicLevels = CalculateHostVMDynamicLevels(p->GPUVMEnable, p->HostVMEnable, p->HostVMMinPageSize, p->HostVMMaxNonCachedPageTableLevels);
5053
5054 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5055 if (p->HostVMEnable == true) {
5056 p->vm_group_bytes[k] = 512;
5057 p->dpte_group_bytes[k] = 512;
5058 } else if (p->GPUVMEnable == true) {
5059 p->vm_group_bytes[k] = 2048;
5060 if (p->GPUVMMinPageSizeKBytes[k] >= 64 && dml_is_vertical_rotation(p->myPipe[k].SourceScan)) {
5061 p->dpte_group_bytes[k] = 512;
5062 } else {
5063 p->dpte_group_bytes[k] = 2048;
5064 }
5065 } else {
5066 p->vm_group_bytes[k] = 0;
5067 p->dpte_group_bytes[k] = 0;
5068 }
5069
5070 if (p->myPipe[k].SourcePixelFormat == dml_420_8 || p->myPipe[k].SourcePixelFormat == dml_420_10 ||
5071 p->myPipe[k].SourcePixelFormat == dml_420_12 || p->myPipe[k].SourcePixelFormat == dml_rgbe_alpha) {
5072 if ((p->myPipe[k].SourcePixelFormat == dml_420_10 || p->myPipe[k].SourcePixelFormat == dml_420_12) && !dml_is_vertical_rotation(p->myPipe[k].SourceScan)) {
5073 s->PTEBufferSizeInRequestsForLuma[k] = (p->PTEBufferSizeInRequestsLuma + p->PTEBufferSizeInRequestsChroma) / 2;
5074 s->PTEBufferSizeInRequestsForChroma[k] = s->PTEBufferSizeInRequestsForLuma[k];
5075 } else {
5076 s->PTEBufferSizeInRequestsForLuma[k] = p->PTEBufferSizeInRequestsLuma;
5077 s->PTEBufferSizeInRequestsForChroma[k] = p->PTEBufferSizeInRequestsChroma;
5078 }
5079
5080 s->PDEAndMetaPTEBytesFrameC = CalculateVMAndRowBytes(
5081 p->myPipe[k].ViewportStationary,
5082 p->myPipe[k].DCCEnable,
5083 p->myPipe[k].DPPPerSurface,
5084 p->myPipe[k].BlockHeight256BytesC,
5085 p->myPipe[k].BlockWidth256BytesC,
5086 p->myPipe[k].SourcePixelFormat,
5087 p->myPipe[k].SurfaceTiling,
5088 p->myPipe[k].BytePerPixelC,
5089 p->myPipe[k].SourceScan,
5090 p->SwathWidthC[k],
5091 p->myPipe[k].ViewportHeightChroma,
5092 p->myPipe[k].ViewportXStartC,
5093 p->myPipe[k].ViewportYStartC,
5094 p->GPUVMEnable,
5095 p->GPUVMMaxPageTableLevels,
5096 p->GPUVMMinPageSizeKBytes[k],
5097 s->PTEBufferSizeInRequestsForChroma[k],
5098 p->myPipe[k].PitchC,
5099 p->myPipe[k].DCCMetaPitchC,
5100 p->myPipe[k].BlockWidthC,
5101 p->myPipe[k].BlockHeightC,
5102
5103 // Output
5104 &s->MetaRowByteC[k],
5105 &s->PixelPTEBytesPerRowC[k],
5106 &s->PixelPTEBytesPerRowStorageC[k],
5107 &p->dpte_row_width_chroma_ub[k],
5108 &p->dpte_row_height_chroma[k],
5109 &p->dpte_row_height_linear_chroma[k],
5110 &s->PixelPTEBytesPerRowC_one_row_per_frame[k],
5111 &s->dpte_row_width_chroma_ub_one_row_per_frame[k],
5112 &s->dpte_row_height_chroma_one_row_per_frame[k],
5113 &p->meta_req_width_chroma[k],
5114 &p->meta_req_height_chroma[k],
5115 &p->meta_row_width_chroma[k],
5116 &p->meta_row_height_chroma[k],
5117 &p->PixelPTEReqWidthC[k],
5118 &p->PixelPTEReqHeightC[k],
5119 &p->PTERequestSizeC[k],
5120 &p->dpde0_bytes_per_frame_ub_c[k],
5121 &p->meta_pte_bytes_per_frame_ub_c[k]);
5122
5123 p->PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines (
5124 p->myPipe[k].VRatioChroma,
5125 p->myPipe[k].VTapsChroma,
5126 p->myPipe[k].InterlaceEnable,
5127 p->myPipe[k].ProgressiveToInterlaceUnitInOPP,
5128 p->myPipe[k].SwathHeightC,
5129 p->myPipe[k].SourceScan,
5130 p->myPipe[k].ViewportStationary,
5131 p->SwathWidthC[k],
5132 p->myPipe[k].ViewportHeightChroma,
5133 p->myPipe[k].ViewportXStartC,
5134 p->myPipe[k].ViewportYStartC,
5135
5136 // Output
5137 &p->VInitPreFillC[k],
5138 &p->MaxNumSwathC[k]);
5139 } else {
5140 s->PTEBufferSizeInRequestsForLuma[k] = p->PTEBufferSizeInRequestsLuma + p->PTEBufferSizeInRequestsChroma;
5141 s->PTEBufferSizeInRequestsForChroma[k] = 0;
5142 s->PixelPTEBytesPerRowC[k] = 0;
5143 s->PixelPTEBytesPerRowStorageC[k] = 0;
5144 s->PDEAndMetaPTEBytesFrameC = 0;
5145 s->MetaRowByteC[k] = 0;
5146 p->MaxNumSwathC[k] = 0;
5147 p->PrefetchSourceLinesC[k] = 0;
5148 s->dpte_row_height_chroma_one_row_per_frame[k] = 0;
5149 s->dpte_row_width_chroma_ub_one_row_per_frame[k] = 0;
5150 s->PixelPTEBytesPerRowC_one_row_per_frame[k] = 0;
5151 }
5152
5153 s->PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
5154 p->myPipe[k].ViewportStationary,
5155 p->myPipe[k].DCCEnable,
5156 p->myPipe[k].DPPPerSurface,
5157 p->myPipe[k].BlockHeight256BytesY,
5158 p->myPipe[k].BlockWidth256BytesY,
5159 p->myPipe[k].SourcePixelFormat,
5160 p->myPipe[k].SurfaceTiling,
5161 p->myPipe[k].BytePerPixelY,
5162 p->myPipe[k].SourceScan,
5163 p->SwathWidthY[k],
5164 p->myPipe[k].ViewportHeight,
5165 p->myPipe[k].ViewportXStart,
5166 p->myPipe[k].ViewportYStart,
5167 p->GPUVMEnable,
5168 p->GPUVMMaxPageTableLevels,
5169 p->GPUVMMinPageSizeKBytes[k],
5170 s->PTEBufferSizeInRequestsForLuma[k],
5171 p->myPipe[k].PitchY,
5172 p->myPipe[k].DCCMetaPitchY,
5173 p->myPipe[k].BlockWidthY,
5174 p->myPipe[k].BlockHeightY,
5175
5176 // Output
5177 &s->MetaRowByteY[k],
5178 &s->PixelPTEBytesPerRowY[k],
5179 &s->PixelPTEBytesPerRowStorageY[k],
5180 &p->dpte_row_width_luma_ub[k],
5181 &p->dpte_row_height_luma[k],
5182 &p->dpte_row_height_linear_luma[k],
5183 &s->PixelPTEBytesPerRowY_one_row_per_frame[k],
5184 &s->dpte_row_width_luma_ub_one_row_per_frame[k],
5185 &s->dpte_row_height_luma_one_row_per_frame[k],
5186 &p->meta_req_width[k],
5187 &p->meta_req_height[k],
5188 &p->meta_row_width[k],
5189 &p->meta_row_height[k],
5190 &p->PixelPTEReqWidthY[k],
5191 &p->PixelPTEReqHeightY[k],
5192 &p->PTERequestSizeY[k],
5193 &p->dpde0_bytes_per_frame_ub_l[k],
5194 &p->meta_pte_bytes_per_frame_ub_l[k]);
5195
5196 p->PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
5197 p->myPipe[k].VRatio,
5198 p->myPipe[k].VTaps,
5199 p->myPipe[k].InterlaceEnable,
5200 p->myPipe[k].ProgressiveToInterlaceUnitInOPP,
5201 p->myPipe[k].SwathHeightY,
5202 p->myPipe[k].SourceScan,
5203 p->myPipe[k].ViewportStationary,
5204 p->SwathWidthY[k],
5205 p->myPipe[k].ViewportHeight,
5206 p->myPipe[k].ViewportXStart,
5207 p->myPipe[k].ViewportYStart,
5208
5209 // Output
5210 &p->VInitPreFillY[k],
5211 &p->MaxNumSwathY[k]);
5212
5213 p->PDEAndMetaPTEBytesFrame[k] = (s->PDEAndMetaPTEBytesFrameY + s->PDEAndMetaPTEBytesFrameC) * (1 + 8 * s->HostVMDynamicLevels);
5214 p->MetaRowByte[k] = s->MetaRowByteY[k] + s->MetaRowByteC[k];
5215
5216 if (s->PixelPTEBytesPerRowStorageY[k] <= 64 * s->PTEBufferSizeInRequestsForLuma[k] && s->PixelPTEBytesPerRowStorageC[k] <= 64 * s->PTEBufferSizeInRequestsForChroma[k]) {
5217 p->PTEBufferSizeNotExceeded[k] = true;
5218 } else {
5219 p->PTEBufferSizeNotExceeded[k] = false;
5220#ifdef __DML_VBA_DEBUG__
5221 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY = %u\n", __func__, k, s->PixelPTEBytesPerRowY[k]);
5222 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC = %u\n", __func__, k, s->PixelPTEBytesPerRowC[k]);
5223 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowStorageY = %u\n", __func__, k, s->PixelPTEBytesPerRowStorageY[k]);
5224 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowStorageC = %u\n", __func__, k, s->PixelPTEBytesPerRowStorageC[k]);
5225 dml_print("DML::%s: k=%u, PTEBufferSizeInRequestsForLuma = %u\n", __func__, k, s->PTEBufferSizeInRequestsForLuma[k]);
5226 dml_print("DML::%s: k=%u, PTEBufferSizeInRequestsForChroma = %u\n", __func__, k, s->PTEBufferSizeInRequestsForChroma[k]);
5227 dml_print("DML::%s: k=%u, PTEBufferSizeNotExceeded = %u\n", __func__, k, p->PTEBufferSizeNotExceeded[k]);
5228#endif
5229 }
5230 s->one_row_per_frame_fits_in_buffer[k] = (s->PixelPTEBytesPerRowY_one_row_per_frame[k] <= 64 * 2 * s->PTEBufferSizeInRequestsForLuma[k] &&
5231 s->PixelPTEBytesPerRowC_one_row_per_frame[k] <= 64 * 2 * s->PTEBufferSizeInRequestsForChroma[k]);
5232
5233#ifdef __DML_VBA_DEBUG__
5234 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrame = %u\n", __func__, k, p->PDEAndMetaPTEBytesFrame[k]);
5235 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrameY = %u\n", __func__, k, s->PDEAndMetaPTEBytesFrameY);
5236 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrameC = %u\n", __func__, k, s->PDEAndMetaPTEBytesFrameC);
5237 dml_print("DML::%s: k=%u, HostVMDynamicLevels = %u\n", __func__, k, s->HostVMDynamicLevels);
5238 dml_print("DML::%s: k=%u, one_row_per_frame_fits_in_buffer = %u\n", __func__, k, s->one_row_per_frame_fits_in_buffer[k]);
5239 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY_one_row_per_frame = %u\n", __func__, k, s->PixelPTEBytesPerRowY_one_row_per_frame[k]);
5240 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC_one_row_per_frame = %u\n", __func__, k, s->PixelPTEBytesPerRowC_one_row_per_frame[k]);
5241#endif
5242 }
5243
5244 CalculateMALLUseForStaticScreen(
5245 p->NumberOfActiveSurfaces,
5246 p->MALLAllocatedForDCN,
5247 p->UseMALLForStaticScreen, // mode
5248 p->SurfaceSizeInMALL,
5249 s->one_row_per_frame_fits_in_buffer,
5250 // Output
5251 p->UsesMALLForStaticScreen); // boolen
5252
5253 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5254 if (p->PTEBufferModeOverrideEn[k] == 1) {
5255 p->PTE_BUFFER_MODE[k] = p->PTEBufferModeOverrideVal[k];
5256 }
5257 p->PTE_BUFFER_MODE[k] = p->myPipe[k].FORCE_ONE_ROW_FOR_FRAME || p->UsesMALLForStaticScreen[k] || (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) ||
5258 (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) || (p->GPUVMMinPageSizeKBytes[k] > 64);
5259 p->BIGK_FRAGMENT_SIZE[k] = (dml_uint_t)(dml_log2(p->GPUVMMinPageSizeKBytes[k] * 1024) - 12);
5260 }
5261
5262 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5263#ifdef __DML_VBA_DEBUG__
5264 dml_print("DML::%s: k=%u, SurfaceSizeInMALL = %u\n", __func__, k, p->SurfaceSizeInMALL[k]);
5265 dml_print("DML::%s: k=%u, UsesMALLForStaticScreen = %u\n", __func__, k, p->UsesMALLForStaticScreen[k]);
5266#endif
5267 p->use_one_row_for_frame[k] = p->myPipe[k].FORCE_ONE_ROW_FOR_FRAME || p->UsesMALLForStaticScreen[k] || (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) ||
5268 (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) || (p->GPUVMMinPageSizeKBytes[k] > 64 && dml_is_vertical_rotation(p->myPipe[k].SourceScan));
5269
5270 p->use_one_row_for_frame_flip[k] = p->use_one_row_for_frame[k] && !(p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame);
5271
5272 if (p->use_one_row_for_frame[k]) {
5273 p->dpte_row_height_luma[k] = s->dpte_row_height_luma_one_row_per_frame[k];
5274 p->dpte_row_width_luma_ub[k] = s->dpte_row_width_luma_ub_one_row_per_frame[k];
5275 s->PixelPTEBytesPerRowY[k] = s->PixelPTEBytesPerRowY_one_row_per_frame[k];
5276 p->dpte_row_height_chroma[k] = s->dpte_row_height_chroma_one_row_per_frame[k];
5277 p->dpte_row_width_chroma_ub[k] = s->dpte_row_width_chroma_ub_one_row_per_frame[k];
5278 s->PixelPTEBytesPerRowC[k] = s->PixelPTEBytesPerRowC_one_row_per_frame[k];
5279 p->PTEBufferSizeNotExceeded[k] = s->one_row_per_frame_fits_in_buffer[k];
5280 }
5281
5282 if (p->MetaRowByte[k] <= p->DCCMetaBufferSizeBytes) {
5283 p->DCCMetaBufferSizeNotExceeded[k] = true;
5284 } else {
5285 p->DCCMetaBufferSizeNotExceeded[k] = false;
5286
5287#ifdef __DML_VBA_DEBUG__
5288 dml_print("DML::%s: k=%u, MetaRowByte = %u\n", __func__, k, p->MetaRowByte[k]);
5289 dml_print("DML::%s: k=%u, DCCMetaBufferSizeBytes = %u\n", __func__, k, p->DCCMetaBufferSizeBytes);
5290 dml_print("DML::%s: k=%u, DCCMetaBufferSizeNotExceeded = %u\n", __func__, k, p->DCCMetaBufferSizeNotExceeded[k]);
5291#endif
5292 }
5293 s->PixelPTEBytesPerRowY[k] = s->PixelPTEBytesPerRowY[k] * (1 + 8 * s->HostVMDynamicLevels);
5294 s->PixelPTEBytesPerRowC[k] = s->PixelPTEBytesPerRowC[k] * (1 + 8 * s->HostVMDynamicLevels);
5295 p->PixelPTEBytesPerRow[k] = s->PixelPTEBytesPerRowY[k] + s->PixelPTEBytesPerRowC[k];
5296 if (p->use_one_row_for_frame[k])
5297 p->PixelPTEBytesPerRow[k] = p->PixelPTEBytesPerRow[k] / 2;
5298
5299 CalculateRowBandwidth(
5300 p->GPUVMEnable,
5301 p->myPipe[k].SourcePixelFormat,
5302 p->myPipe[k].VRatio,
5303 p->myPipe[k].VRatioChroma,
5304 p->myPipe[k].DCCEnable,
5305 p->myPipe[k].HTotal / p->myPipe[k].PixelClock,
5306 s->MetaRowByteY[k],
5307 s->MetaRowByteC[k],
5308 p->meta_row_height[k],
5309 p->meta_row_height_chroma[k],
5310 s->PixelPTEBytesPerRowY[k],
5311 s->PixelPTEBytesPerRowC[k],
5312 p->dpte_row_height_luma[k],
5313 p->dpte_row_height_chroma[k],
5314
5315 // Output
5316 &p->meta_row_bw[k],
5317 &p->dpte_row_bw[k]);
5318#ifdef __DML_VBA_DEBUG__
5319 dml_print("DML::%s: k=%u, use_one_row_for_frame = %u\n", __func__, k, p->use_one_row_for_frame[k]);
5320 dml_print("DML::%s: k=%u, use_one_row_for_frame_flip = %u\n", __func__, k, p->use_one_row_for_frame_flip[k]);
5321 dml_print("DML::%s: k=%u, UseMALLForPStateChange = %u\n", __func__, k, p->UseMALLForPStateChange[k]);
5322 dml_print("DML::%s: k=%u, dpte_row_height_luma = %u\n", __func__, k, p->dpte_row_height_luma[k]);
5323 dml_print("DML::%s: k=%u, dpte_row_width_luma_ub = %u\n", __func__, k, p->dpte_row_width_luma_ub[k]);
5324 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY = %u\n", __func__, k, s->PixelPTEBytesPerRowY[k]);
5325 dml_print("DML::%s: k=%u, dpte_row_height_chroma = %u\n", __func__, k, p->dpte_row_height_chroma[k]);
5326 dml_print("DML::%s: k=%u, dpte_row_width_chroma_ub = %u\n", __func__, k, p->dpte_row_width_chroma_ub[k]);
5327 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC = %u\n", __func__, k, s->PixelPTEBytesPerRowC[k]);
5328 dml_print("DML::%s: k=%u, PixelPTEBytesPerRow = %u\n", __func__, k, p->PixelPTEBytesPerRow[k]);
5329 dml_print("DML::%s: k=%u, PTEBufferSizeNotExceeded = %u\n", __func__, k, p->PTEBufferSizeNotExceeded[k]);
5330 dml_print("DML::%s: k=%u, PTE_BUFFER_MODE = %u\n", __func__, k, p->PTE_BUFFER_MODE[k]);
5331 dml_print("DML::%s: k=%u, BIGK_FRAGMENT_SIZE = %u\n", __func__, k, p->BIGK_FRAGMENT_SIZE[k]);
5332#endif
5333 }
5334}
5335
5336static void CalculateOutputLink(
5337 dml_float_t PHYCLKPerState,
5338 dml_float_t PHYCLKD18PerState,
5339 dml_float_t PHYCLKD32PerState,
5340 dml_float_t Downspreading,
5341 dml_bool_t IsMainSurfaceUsingTheIndicatedTiming,
5342 enum dml_output_encoder_class Output,
5343 enum dml_output_format_class OutputFormat,
5344 dml_uint_t HTotal,
5345 dml_uint_t HActive,
5346 dml_float_t PixelClockBackEnd,
5347 dml_float_t ForcedOutputLinkBPP,
5348 dml_uint_t DSCInputBitPerComponent,
5349 dml_uint_t NumberOfDSCSlices,
5350 dml_float_t AudioSampleRate,
5351 dml_uint_t AudioSampleLayout,
5352 enum dml_odm_mode ODMModeNoDSC,
5353 enum dml_odm_mode ODMModeDSC,
5354 enum dml_dsc_enable DSCEnable,
5355 dml_uint_t OutputLinkDPLanes,
5356 enum dml_output_link_dp_rate OutputLinkDPRate,
5357
5358 // Output
5359 dml_bool_t *RequiresDSC,
5360 dml_bool_t *RequiresFEC,
5361 dml_float_t *OutBpp,
5362 enum dml_output_type_and_rate__type *OutputType,
5363 enum dml_output_type_and_rate__rate *OutputRate,
5364 dml_uint_t *RequiredSlots)
5365{
5366 dml_bool_t LinkDSCEnable;
5367 dml_uint_t dummy;
5368 *RequiresDSC = false;
5369 *RequiresFEC = false;
5370 *OutBpp = 0;
5371
5372 *OutputType = dml_output_type_unknown;
5373 *OutputRate = dml_output_rate_unknown;
5374
5375 if (IsMainSurfaceUsingTheIndicatedTiming) {
5376 if (Output == dml_hdmi) {
5377 *RequiresDSC = false;
5378 *RequiresFEC = false;
5379 *OutBpp = TruncToValidBPP(dml_min(600, PHYCLKPerState) * 10, 3, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, false, Output,
5380 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, &dummy);
5381 //OutputTypeAndRate = "HDMI";
5382 *OutputType = dml_output_type_hdmi;
5383
5384 } else if (Output == dml_dp || Output == dml_dp2p0 || Output == dml_edp) {
5385 if (DSCEnable == dml_dsc_enable) {
5386 *RequiresDSC = true;
5387 LinkDSCEnable = true;
5388 if (Output == dml_dp || Output == dml_dp2p0) {
5389 *RequiresFEC = true;
5390 } else {
5391 *RequiresFEC = false;
5392 }
5393 } else {
5394 *RequiresDSC = false;
5395 LinkDSCEnable = false;
5396 if (Output == dml_dp2p0) {
5397 *RequiresFEC = true;
5398 } else {
5399 *RequiresFEC = false;
5400 }
5401 }
5402 if (Output == dml_dp2p0) {
5403 *OutBpp = 0;
5404 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr10) && PHYCLKD32PerState >= 10000 / 32) {
5405 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 10000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5406 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5407 if (*OutBpp == 0 && PHYCLKD32PerState < 13500 / 32 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5408 *RequiresDSC = true;
5409 LinkDSCEnable = true;
5410 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 10000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5411 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5412 }
5413 //OutputTypeAndRate = Output & " UHBR10";
5414 *OutputType = dml_output_type_dp2p0;
5415 *OutputRate = dml_output_rate_dp_rate_uhbr10;
5416 }
5417 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr13p5) && *OutBpp == 0 && PHYCLKD32PerState >= 13500 / 32) {
5418 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 13500, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5419 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5420
5421 if (OutBpp == 0 && PHYCLKD32PerState < 20000 / 32 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5422 *RequiresDSC = true;
5423 LinkDSCEnable = true;
5424 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 13500, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5425 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5426 }
5427 //OutputTypeAndRate = Output & " UHBR13p5";
5428 *OutputType = dml_output_type_dp2p0;
5429 *OutputRate = dml_output_rate_dp_rate_uhbr13p5;
5430 }
5431 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr20) && *OutBpp == 0 && PHYCLKD32PerState >= 20000 / 32) {
5432 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 20000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5433 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5434 if (*OutBpp == 0 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5435 *RequiresDSC = true;
5436 LinkDSCEnable = true;
5437 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 20000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5438 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5439 }
5440 //OutputTypeAndRate = Output & " UHBR20";
5441 *OutputType = dml_output_type_dp2p0;
5442 *OutputRate = dml_output_rate_dp_rate_uhbr20;
5443 }
5444 } else { // output is dp or edp
5445 *OutBpp = 0;
5446 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr) && PHYCLKPerState >= 270) {
5447 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 2700, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5448 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5449 if (*OutBpp == 0 && PHYCLKPerState < 540 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5450 *RequiresDSC = true;
5451 LinkDSCEnable = true;
5452 if (Output == dml_dp) {
5453 *RequiresFEC = true;
5454 }
5455 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 2700, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5456 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5457 }
5458 //OutputTypeAndRate = Output & " HBR";
5459 *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5460 *OutputRate = dml_output_rate_dp_rate_hbr;
5461 }
5462 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr2) && *OutBpp == 0 && PHYCLKPerState >= 540) {
5463 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 5400, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5464 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5465
5466 if (*OutBpp == 0 && PHYCLKPerState < 810 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5467 *RequiresDSC = true;
5468 LinkDSCEnable = true;
5469 if (Output == dml_dp) {
5470 *RequiresFEC = true;
5471 }
5472 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 5400, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5473 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5474 }
5475 //OutputTypeAndRate = Output & " HBR2";
5476 *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5477 *OutputRate = dml_output_rate_dp_rate_hbr2;
5478 }
5479 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr3) && *OutBpp == 0 && PHYCLKPerState >= 810) { // VBA_ERROR, vba code doesn't have hbr3 check
5480 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 8100, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5481 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5482
5483 if (*OutBpp == 0 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5484 *RequiresDSC = true;
5485 LinkDSCEnable = true;
5486 if (Output == dml_dp) {
5487 *RequiresFEC = true;
5488 }
5489 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 8100, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5490 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5491 }
5492 //OutputTypeAndRate = Output & " HBR3";
5493 *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5494 *OutputRate = dml_output_rate_dp_rate_hbr3;
5495 }
5496 }
5497 }
5498 }
5499}
5500
5501/// @brief Determine the ODM mode and number of DPP used per plane based on dispclk, dsc usage, odm usage policy
5502static void CalculateODMMode(
5503 dml_uint_t MaximumPixelsPerLinePerDSCUnit,
5504 dml_uint_t HActive,
5505 enum dml_output_encoder_class Output,
5506 enum dml_output_format_class OutputFormat,
5507 enum dml_odm_use_policy ODMUse,
5508 dml_float_t StateDispclk,
5509 dml_float_t MaxDispclk,
5510 dml_bool_t DSCEnable,
5511 dml_uint_t TotalNumberOfActiveDPP,
5512 dml_uint_t MaxNumDPP,
5513 dml_float_t PixelClock,
5514 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5515 dml_float_t DISPCLKRampingMargin,
5516 dml_float_t DISPCLKDPPCLKVCOSpeed,
5517
5518 // Output
5519 dml_bool_t *TotalAvailablePipesSupport,
5520 dml_uint_t *NumberOfDPP,
5521 enum dml_odm_mode *ODMMode,
5522 dml_float_t *RequiredDISPCLKPerSurface)
5523{
5524
5525 dml_float_t SurfaceRequiredDISPCLKWithoutODMCombine;
5526 dml_float_t SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
5527 dml_float_t SurfaceRequiredDISPCLKWithODMCombineFourToOne;
5528
5529 SurfaceRequiredDISPCLKWithoutODMCombine = CalculateRequiredDispclk(dml_odm_mode_bypass, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5530 SurfaceRequiredDISPCLKWithODMCombineTwoToOne = CalculateRequiredDispclk(dml_odm_mode_combine_2to1, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5531 SurfaceRequiredDISPCLKWithODMCombineFourToOne = CalculateRequiredDispclk(dml_odm_mode_combine_4to1, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5532 *TotalAvailablePipesSupport = true;
5533
5534 if (OutputFormat == dml_420) {
5535 if (HActive > 4 * DML2_MAX_FMT_420_BUFFER_WIDTH)
5536 *TotalAvailablePipesSupport = false;
5537 else if (HActive > 2 * DML2_MAX_FMT_420_BUFFER_WIDTH)
5538 ODMUse = dml_odm_use_policy_combine_4to1;
5539 else if (HActive > DML2_MAX_FMT_420_BUFFER_WIDTH)
5540 ODMUse = dml_odm_use_policy_combine_2to1;
5541 if (Output == dml_hdmi && ODMUse == dml_odm_use_policy_combine_2to1)
5542 *TotalAvailablePipesSupport = false;
5543 if ((Output == dml_hdmi || Output == dml_dp || Output == dml_edp) && ODMUse == dml_odm_use_policy_combine_4to1)
5544 *TotalAvailablePipesSupport = false;
5545 }
5546
5547 if (ODMUse == dml_odm_use_policy_bypass || ODMUse == dml_odm_use_policy_combine_as_needed)
5548 *ODMMode = dml_odm_mode_bypass;
5549 else if (ODMUse == dml_odm_use_policy_combine_2to1)
5550 *ODMMode = dml_odm_mode_combine_2to1;
5551 else if (ODMUse == dml_odm_use_policy_combine_4to1)
5552 *ODMMode = dml_odm_mode_combine_4to1;
5553 else if (ODMUse == dml_odm_use_policy_split_1to2)
5554 *ODMMode = dml_odm_mode_split_1to2;
5555 else if (ODMUse == dml_odm_use_policy_mso_1to2)
5556 *ODMMode = dml_odm_mode_mso_1to2;
5557 else if (ODMUse == dml_odm_use_policy_mso_1to4)
5558 *ODMMode = dml_odm_mode_mso_1to4;
5559
5560 *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithoutODMCombine;
5561 *NumberOfDPP = 0;
5562
5563 if (!(Output == dml_hdmi || Output == dml_dp || Output == dml_edp) && (ODMUse == dml_odm_use_policy_combine_4to1 || (ODMUse == dml_odm_use_policy_combine_as_needed &&
5564 (SurfaceRequiredDISPCLKWithODMCombineTwoToOne > StateDispclk || (DSCEnable && (HActive > 2 * MaximumPixelsPerLinePerDSCUnit)))))) {
5565 if (TotalNumberOfActiveDPP + 4 <= MaxNumDPP) {
5566 *ODMMode = dml_odm_mode_combine_4to1;
5567 *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineFourToOne;
5568 *NumberOfDPP = 4;
5569 } else {
5570 *TotalAvailablePipesSupport = false;
5571 }
5572 } else if (Output != dml_hdmi && (ODMUse == dml_odm_use_policy_combine_2to1 || (ODMUse == dml_odm_use_policy_combine_as_needed &&
5573 ((SurfaceRequiredDISPCLKWithoutODMCombine > StateDispclk && SurfaceRequiredDISPCLKWithODMCombineTwoToOne <= StateDispclk) ||
5574 (DSCEnable && (HActive > MaximumPixelsPerLinePerDSCUnit)))))) {
5575 if (TotalNumberOfActiveDPP + 2 <= MaxNumDPP) {
5576 *ODMMode = dml_odm_mode_combine_2to1;
5577 *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
5578 *NumberOfDPP = 2;
5579 } else {
5580 *TotalAvailablePipesSupport = false;
5581 }
5582 } else {
5583 if (TotalNumberOfActiveDPP + 1 <= MaxNumDPP) {
5584 *NumberOfDPP = 1;
5585 } else {
5586 *TotalAvailablePipesSupport = false;
5587 }
5588 }
5589}
5590
5591/// @brief Calculate the required DISPCLK given the odm mode and pixclk
5592static dml_float_t CalculateRequiredDispclk(
5593 enum dml_odm_mode ODMMode,
5594 dml_float_t PixelClock,
5595 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5596 dml_float_t DISPCLKRampingMargin,
5597 dml_float_t DISPCLKDPPCLKVCOSpeed,
5598 dml_float_t MaxDispclk)
5599{
5600 dml_float_t RequiredDispclk = 0.;
5601 dml_float_t PixelClockAfterODM;
5602
5603 dml_float_t DISPCLKWithRampingRoundedToDFSGranularity;
5604 dml_float_t DISPCLKWithoutRampingRoundedToDFSGranularity;
5605 dml_float_t MaxDispclkRoundedDownToDFSGranularity;
5606
5607 if (ODMMode == dml_odm_mode_combine_4to1) {
5608 PixelClockAfterODM = PixelClock / 4;
5609 } else if (ODMMode == dml_odm_mode_combine_2to1) {
5610 PixelClockAfterODM = PixelClock / 2;
5611 } else {
5612 PixelClockAfterODM = PixelClock;
5613 }
5614
5615 DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularity(PixelClockAfterODM * (1.0 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + DISPCLKRampingMargin / 100.0), 1, DISPCLKDPPCLKVCOSpeed);
5616 DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularity(PixelClockAfterODM * (1.0 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0), 1, DISPCLKDPPCLKVCOSpeed);
5617 MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularity(MaxDispclk, 0, DISPCLKDPPCLKVCOSpeed);
5618
5619 if (DISPCLKWithoutRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) {
5620 RequiredDispclk = DISPCLKWithoutRampingRoundedToDFSGranularity;
5621 } else if (DISPCLKWithRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) {
5622 RequiredDispclk = MaxDispclkRoundedDownToDFSGranularity;
5623 } else {
5624 RequiredDispclk = DISPCLKWithRampingRoundedToDFSGranularity;
5625 }
5626
5627 return RequiredDispclk;
5628}
5629
5630/// @brief Determine DPPCLK if there only one DPP per plane, main factor is the pixel rate and DPP scaling parameter
5631static void CalculateSinglePipeDPPCLKAndSCLThroughput(
5632 dml_float_t HRatio,
5633 dml_float_t HRatioChroma,
5634 dml_float_t VRatio,
5635 dml_float_t VRatioChroma,
5636 dml_float_t MaxDCHUBToPSCLThroughput,
5637 dml_float_t MaxPSCLToLBThroughput,
5638 dml_float_t PixelClock,
5639 enum dml_source_format_class SourcePixelFormat,
5640 dml_uint_t HTaps,
5641 dml_uint_t HTapsChroma,
5642 dml_uint_t VTaps,
5643 dml_uint_t VTapsChroma,
5644
5645 // Output
5646 dml_float_t *PSCL_THROUGHPUT,
5647 dml_float_t *PSCL_THROUGHPUT_CHROMA,
5648 dml_float_t *DPPCLKUsingSingleDPP)
5649{
5650 dml_float_t DPPCLKUsingSingleDPPLuma;
5651 dml_float_t DPPCLKUsingSingleDPPChroma;
5652
5653 if (HRatio > 1) {
5654 *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatio / dml_ceil((dml_float_t) HTaps / 6.0, 1.0));
5655 } else {
5656 *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
5657 }
5658
5659 DPPCLKUsingSingleDPPLuma = PixelClock * dml_max3(VTaps / 6 * dml_min(1, HRatio), HRatio * VRatio / *PSCL_THROUGHPUT, 1);
5660
5661 if ((HTaps > 6 || VTaps > 6) && DPPCLKUsingSingleDPPLuma < 2 * PixelClock)
5662 DPPCLKUsingSingleDPPLuma = 2 * PixelClock;
5663
5664 if ((SourcePixelFormat != dml_420_8 && SourcePixelFormat != dml_420_10 && SourcePixelFormat != dml_420_12 && SourcePixelFormat != dml_rgbe_alpha)) {
5665 *PSCL_THROUGHPUT_CHROMA = 0;
5666 *DPPCLKUsingSingleDPP = DPPCLKUsingSingleDPPLuma;
5667 } else {
5668 if (HRatioChroma > 1) {
5669 *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatioChroma / dml_ceil((dml_float_t) HTapsChroma / 6.0, 1.0));
5670 } else {
5671 *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
5672 }
5673 DPPCLKUsingSingleDPPChroma = PixelClock * dml_max3(VTapsChroma / 6 * dml_min(1, HRatioChroma),
5674 HRatioChroma * VRatioChroma / *PSCL_THROUGHPUT_CHROMA, 1);
5675 if ((HTapsChroma > 6 || VTapsChroma > 6) && DPPCLKUsingSingleDPPChroma < 2 * PixelClock)
5676 DPPCLKUsingSingleDPPChroma = 2 * PixelClock;
5677 *DPPCLKUsingSingleDPP = dml_max(DPPCLKUsingSingleDPPLuma, DPPCLKUsingSingleDPPChroma);
5678 }
5679}
5680
5681/// @brief Calculate the actual dppclk freq
5682/// @param DPPCLKUsingSingleDPP DppClk freq required if there is only 1 DPP per plane
5683/// @param DPPPerSurface Number of DPP for each plane
5684static void CalculateDPPCLK(
5685 dml_uint_t NumberOfActiveSurfaces,
5686 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5687 dml_float_t DISPCLKDPPCLKVCOSpeed,
5688 dml_float_t DPPCLKUsingSingleDPP[],
5689 dml_uint_t DPPPerSurface[],
5690
5691 // Output
5692 dml_float_t *GlobalDPPCLK,
5693 dml_float_t Dppclk[])
5694{
5695 *GlobalDPPCLK = 0;
5696 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5697 Dppclk[k] = DPPCLKUsingSingleDPP[k] / DPPPerSurface[k] * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
5698 *GlobalDPPCLK = dml_max(*GlobalDPPCLK, Dppclk[k]);
5699 }
5700 *GlobalDPPCLK = RoundToDFSGranularity(*GlobalDPPCLK, 1, DISPCLKDPPCLKVCOSpeed);
5701
5702 dml_print("DML::%s: GlobalDPPCLK = %f\n", __func__, *GlobalDPPCLK);
5703 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5704 Dppclk[k] = *GlobalDPPCLK / 255.0 * dml_ceil(Dppclk[k] * 255.0 / *GlobalDPPCLK, 1.0);
5705 dml_print("DML::%s: Dppclk[%0d] = %f\n", __func__, k, Dppclk[k]);
5706 }
5707}
5708
5709static void CalculateMALLUseForStaticScreen(
5710 dml_uint_t NumberOfActiveSurfaces,
5711 dml_uint_t MALLAllocatedForDCNFinal,
5712 enum dml_use_mall_for_static_screen_mode *UseMALLForStaticScreen,
5713 dml_uint_t SurfaceSizeInMALL[],
5714 dml_bool_t one_row_per_frame_fits_in_buffer[],
5715
5716 // Output
5717 dml_bool_t UsesMALLForStaticScreen[])
5718{
5719
5720 dml_uint_t SurfaceToAddToMALL;
5721 dml_bool_t CanAddAnotherSurfaceToMALL;
5722 dml_uint_t TotalSurfaceSizeInMALL;
5723
5724 TotalSurfaceSizeInMALL = 0;
5725 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5726 UsesMALLForStaticScreen[k] = (UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable);
5727 if (UsesMALLForStaticScreen[k])
5728 TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k];
5729#ifdef __DML_VBA_DEBUG__
5730 dml_print("DML::%s: k=%u, UsesMALLForStaticScreen = %u\n", __func__, k, UsesMALLForStaticScreen[k]);
5731 dml_print("DML::%s: k=%u, TotalSurfaceSizeInMALL = %u\n", __func__, k, TotalSurfaceSizeInMALL);
5732#endif
5733 }
5734
5735 SurfaceToAddToMALL = 0;
5736 CanAddAnotherSurfaceToMALL = true;
5737 while (CanAddAnotherSurfaceToMALL) {
5738 CanAddAnotherSurfaceToMALL = false;
5739 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5740 if (TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k] <= MALLAllocatedForDCNFinal * 1024 * 1024 &&
5741 !UsesMALLForStaticScreen[k] && UseMALLForStaticScreen[k] != dml_use_mall_static_screen_disable && one_row_per_frame_fits_in_buffer[k] &&
5742 (!CanAddAnotherSurfaceToMALL || SurfaceSizeInMALL[k] < SurfaceSizeInMALL[SurfaceToAddToMALL])) {
5743 CanAddAnotherSurfaceToMALL = true;
5744 SurfaceToAddToMALL = k;
5745 dml_print("DML::%s: k=%u, UseMALLForStaticScreen = %u (dis, en, optimize)\n", __func__, k, UseMALLForStaticScreen[k]);
5746 }
5747 }
5748 if (CanAddAnotherSurfaceToMALL) {
5749 UsesMALLForStaticScreen[SurfaceToAddToMALL] = true;
5750 TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[SurfaceToAddToMALL];
5751
5752#ifdef __DML_VBA_DEBUG__
5753 dml_print("DML::%s: SurfaceToAddToMALL = %u\n", __func__, SurfaceToAddToMALL);
5754 dml_print("DML::%s: TotalSurfaceSizeInMALL = %u\n", __func__, TotalSurfaceSizeInMALL);
5755#endif
5756 }
5757 }
5758}
5759
5760// @brief Calculate return bw for VM only traffic
5761dml_float_t dml_get_return_bw_mbps_vm_only(
5762 const struct soc_bounding_box_st *soc,
5763 dml_bool_t use_ideal_dram_bw_strobe,
5764 dml_bool_t HostVMEnable,
5765 dml_float_t DCFCLK,
5766 dml_float_t FabricClock,
5767 dml_float_t DRAMSpeed)
5768{
5769 dml_float_t VMDataOnlyReturnBW =
5770 dml_min3(soc->return_bus_width_bytes * DCFCLK * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
5771 FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
5772 DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes *
5773 ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe : soc->pct_ideal_dram_bw_after_urgent_vm_only) / 100.0);
5774#ifdef __DML_VBA_DEBUG__
5775 dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5776 dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5777 dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
5778 dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
5779 dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5780 dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
5781#endif
5782 return VMDataOnlyReturnBW;
5783}
5784
5785// Function: dml_get_return_bw_mbps
5786// Megabyte per second
5787dml_float_t dml_get_return_bw_mbps(
5788 const struct soc_bounding_box_st *soc,
5789 dml_bool_t use_ideal_dram_bw_strobe,
5790 dml_bool_t HostVMEnable,
5791 dml_float_t DCFCLK,
5792 dml_float_t FabricClock,
5793 dml_float_t DRAMSpeed)
5794{
5795 dml_float_t ReturnBW = 0.;
5796 dml_float_t IdealSDPPortBandwidth = soc->return_bus_width_bytes * DCFCLK;
5797 dml_float_t IdealFabricBandwidth = FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes;
5798 dml_float_t IdealDRAMBandwidth = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes;
5799 dml_float_t PixelDataOnlyReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
5800 IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
5801 IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5802 soc->pct_ideal_dram_bw_after_urgent_pixel_only) / 100);
5803 dml_float_t PixelMixedWithVMDataReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
5804 IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
5805 IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5806 soc->pct_ideal_dram_bw_after_urgent_pixel_and_vm) / 100);
5807
5808 if (HostVMEnable != true) {
5809 ReturnBW = PixelDataOnlyReturnBW;
5810 } else {
5811 ReturnBW = PixelMixedWithVMDataReturnBW;
5812 }
5813
5814#ifdef __DML_VBA_DEBUG__
5815 dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5816 dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5817 dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
5818 dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
5819 dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5820 dml_print("DML::%s: IdealSDPPortBandwidth = %f\n", __func__, IdealSDPPortBandwidth);
5821 dml_print("DML::%s: IdealFabricBandwidth = %f\n", __func__, IdealFabricBandwidth);
5822 dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth);
5823 dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW);
5824 dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW);
5825 dml_print("DML::%s: ReturnBW = %f MBps\n", __func__, ReturnBW);
5826#endif
5827 return ReturnBW;
5828}
5829
5830// Function: dml_get_return_dram_bw_mbps
5831// Megabyte per second
5832static dml_float_t dml_get_return_dram_bw_mbps(
5833 const struct soc_bounding_box_st *soc,
5834 dml_bool_t use_ideal_dram_bw_strobe,
5835 dml_bool_t HostVMEnable,
5836 dml_float_t DRAMSpeed)
5837{
5838 dml_float_t ReturnDRAMBW = 0.;
5839 dml_float_t IdealDRAMBandwidth = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes;
5840 dml_float_t PixelDataOnlyReturnBW = IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5841 soc->pct_ideal_dram_bw_after_urgent_pixel_only) / 100;
5842 dml_float_t PixelMixedWithVMDataReturnBW = IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5843 soc->pct_ideal_dram_bw_after_urgent_pixel_and_vm) / 100;
5844
5845 if (HostVMEnable != true) {
5846 ReturnDRAMBW = PixelDataOnlyReturnBW;
5847 } else {
5848 ReturnDRAMBW = PixelMixedWithVMDataReturnBW;
5849 }
5850
5851#ifdef __DML_VBA_DEBUG__
5852 dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5853 dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5854 dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5855 dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth);
5856 dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW);
5857 dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW);
5858 dml_print("DML::%s: ReturnDRAMBW = %f MBps\n", __func__, ReturnDRAMBW);
5859#endif
5860 return ReturnDRAMBW;
5861}
5862
5863/// @brief BACKEND
5864static dml_uint_t DSCDelayRequirement(
5865 dml_bool_t DSCEnabled,
5866 enum dml_odm_mode ODMMode,
5867 dml_uint_t DSCInputBitPerComponent,
5868 dml_float_t OutputBpp,
5869 dml_uint_t HActive,
5870 dml_uint_t HTotal,
5871 dml_uint_t NumberOfDSCSlices,
5872 enum dml_output_format_class OutputFormat,
5873 enum dml_output_encoder_class Output,
5874 dml_float_t PixelClock,
5875 dml_float_t PixelClockBackEnd)
5876{
5877 dml_uint_t DSCDelayRequirement_val = 0;
5878
5879 if (DSCEnabled == true && OutputBpp != 0) {
5880 if (ODMMode == dml_odm_mode_combine_4to1) {
5881 DSCDelayRequirement_val = 4 * (dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)(dml_ceil((dml_float_t) HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5882 (dml_uint_t) (NumberOfDSCSlices / 4.0), OutputFormat, Output) + dscComputeDelay(OutputFormat, Output));
5883 } else if (ODMMode == dml_odm_mode_combine_2to1) {
5884 DSCDelayRequirement_val = 2 * (dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)(dml_ceil((dml_float_t) HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5885 (dml_uint_t) (NumberOfDSCSlices / 2.0), OutputFormat, Output) + dscComputeDelay(OutputFormat, Output));
5886 } else {
5887 DSCDelayRequirement_val = dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)((dml_float_t) dml_ceil(HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5888 NumberOfDSCSlices, OutputFormat, Output) + dscComputeDelay(OutputFormat, Output);
5889 }
5890 DSCDelayRequirement_val = (dml_uint_t)(DSCDelayRequirement_val + (HTotal - HActive) * dml_ceil((dml_float_t) DSCDelayRequirement_val / (dml_float_t) HActive, 1.0));
5891 DSCDelayRequirement_val = (dml_uint_t)(DSCDelayRequirement_val * PixelClock / PixelClockBackEnd);
5892
5893 } else {
5894 DSCDelayRequirement_val = 0;
5895 }
5896#ifdef __DML_VBA_DEBUG__
5897 dml_print("DML::%s: DSCEnabled = %u\n", __func__, DSCEnabled);
5898 dml_print("DML::%s: ODMMode = %u\n", __func__, ODMMode);
5899 dml_print("DML::%s: OutputBpp = %f\n", __func__, OutputBpp);
5900 dml_print("DML::%s: HActive = %u\n", __func__, HActive);
5901 dml_print("DML::%s: HTotal = %u\n", __func__, HTotal);
5902 dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock);
5903 dml_print("DML::%s: PixelClockBackEnd = %f\n", __func__, PixelClockBackEnd);
5904 dml_print("DML::%s: OutputFormat = %u\n", __func__, OutputFormat);
5905 dml_print("DML::%s: DSCInputBitPerComponent = %u\n", __func__, DSCInputBitPerComponent);
5906 dml_print("DML::%s: NumberOfDSCSlices = %u\n", __func__, NumberOfDSCSlices);
5907 dml_print("DML::%s: DSCDelayRequirement_val = %u\n", __func__, DSCDelayRequirement_val);
5908#endif
5909
5910 return DSCDelayRequirement_val;
5911}
5912
5913static dml_bool_t CalculateVActiveBandwithSupport(dml_uint_t NumberOfActiveSurfaces,
5914 dml_float_t ReturnBW,
5915 dml_bool_t NotUrgentLatencyHiding[],
5916 dml_float_t ReadBandwidthLuma[],
5917 dml_float_t ReadBandwidthChroma[],
5918 dml_float_t cursor_bw[],
5919 dml_float_t meta_row_bandwidth[],
5920 dml_float_t dpte_row_bandwidth[],
5921 dml_uint_t NumberOfDPP[],
5922 dml_float_t UrgentBurstFactorLuma[],
5923 dml_float_t UrgentBurstFactorChroma[],
5924 dml_float_t UrgentBurstFactorCursor[])
5925{
5926 dml_bool_t NotEnoughUrgentLatencyHiding = false;
5927 dml_bool_t CalculateVActiveBandwithSupport_val = false;
5928 dml_float_t VActiveBandwith = 0;
5929
5930 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5931 if (NotUrgentLatencyHiding[k]) {
5932 NotEnoughUrgentLatencyHiding = true;
5933 }
5934 }
5935
5936 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5937 VActiveBandwith = VActiveBandwith + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * meta_row_bandwidth[k] + NumberOfDPP[k] * dpte_row_bandwidth[k];
5938 }
5939
5940 CalculateVActiveBandwithSupport_val = (VActiveBandwith <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
5941
5942#ifdef __DML_VBA_DEBUG__
5943 dml_print("DML::%s: NotEnoughUrgentLatencyHiding = %u\n", __func__, NotEnoughUrgentLatencyHiding);
5944 dml_print("DML::%s: VActiveBandwith = %f\n", __func__, VActiveBandwith);
5945 dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
5946 dml_print("DML::%s: CalculateVActiveBandwithSupport_val = %u\n", __func__, CalculateVActiveBandwithSupport_val);
5947#endif
5948 return CalculateVActiveBandwithSupport_val;
5949}
5950
5951static void CalculatePrefetchBandwithSupport(
5952 dml_uint_t NumberOfActiveSurfaces,
5953 dml_float_t ReturnBW,
5954 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
5955 dml_bool_t NotUrgentLatencyHiding[],
5956 dml_float_t ReadBandwidthLuma[],
5957 dml_float_t ReadBandwidthChroma[],
5958 dml_float_t PrefetchBandwidthLuma[],
5959 dml_float_t PrefetchBandwidthChroma[],
5960 dml_float_t cursor_bw[],
5961 dml_float_t meta_row_bandwidth[],
5962 dml_float_t dpte_row_bandwidth[],
5963 dml_float_t cursor_bw_pre[],
5964 dml_float_t prefetch_vmrow_bw[],
5965 dml_uint_t NumberOfDPP[],
5966 dml_float_t UrgentBurstFactorLuma[],
5967 dml_float_t UrgentBurstFactorChroma[],
5968 dml_float_t UrgentBurstFactorCursor[],
5969 dml_float_t UrgentBurstFactorLumaPre[],
5970 dml_float_t UrgentBurstFactorChromaPre[],
5971 dml_float_t UrgentBurstFactorCursorPre[],
5972
5973 // Output
5974 dml_float_t *PrefetchBandwidth,
5975 dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch,
5976 dml_float_t *FractionOfUrgentBandwidth,
5977 dml_bool_t *PrefetchBandwidthSupport)
5978{
5979 dml_bool_t NotEnoughUrgentLatencyHiding = false;
5980 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5981 if (NotUrgentLatencyHiding[k]) {
5982 NotEnoughUrgentLatencyHiding = true;
5983 }
5984 }
5985
5986 *PrefetchBandwidth = 0;
5987 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5988 *PrefetchBandwidth = *PrefetchBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
5989 ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]),
5990 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
5991 }
5992
5993 *PrefetchBandwidthNotIncludingMALLPrefetch = 0;
5994 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5995 if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe)
5996 *PrefetchBandwidthNotIncludingMALLPrefetch = *PrefetchBandwidthNotIncludingMALLPrefetch
5997 + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
5998 ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k]
5999 + cursor_bw[k] * UrgentBurstFactorCursor[k]
6000 + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]),
6001 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k]
6002 + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6003 + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6004 }
6005
6006 *PrefetchBandwidthSupport = (*PrefetchBandwidth <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
6007 *FractionOfUrgentBandwidth = *PrefetchBandwidth / ReturnBW;
6008
6009#ifdef __DML_VBA_DEBUG__
6010 dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
6011 dml_print("DML::%s: PrefetchBandwidth = %f\n", __func__, *PrefetchBandwidth);
6012 dml_print("DML::%s: FractionOfUrgentBandwidth = %f\n", __func__, *FractionOfUrgentBandwidth);
6013 dml_print("DML::%s: PrefetchBandwidthSupport = %u\n", __func__, *PrefetchBandwidthSupport);
6014#endif
6015}
6016
6017static dml_float_t CalculateBandwidthAvailableForImmediateFlip(
6018 dml_uint_t NumberOfActiveSurfaces,
6019 dml_float_t ReturnBW,
6020 dml_float_t ReadBandwidthLuma[],
6021 dml_float_t ReadBandwidthChroma[],
6022 dml_float_t PrefetchBandwidthLuma[],
6023 dml_float_t PrefetchBandwidthChroma[],
6024 dml_float_t cursor_bw[],
6025 dml_float_t cursor_bw_pre[],
6026 dml_uint_t NumberOfDPP[],
6027 dml_float_t UrgentBurstFactorLuma[],
6028 dml_float_t UrgentBurstFactorChroma[],
6029 dml_float_t UrgentBurstFactorCursor[],
6030 dml_float_t UrgentBurstFactorLumaPre[],
6031 dml_float_t UrgentBurstFactorChromaPre[],
6032 dml_float_t UrgentBurstFactorCursorPre[])
6033{
6034 dml_float_t ret_val = ReturnBW;
6035
6036 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6037 ret_val = ret_val - dml_max(ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6038 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) +
6039 cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6040#ifdef __DML_VBA_DEBUG__
6041 dml_print("DML::%s: k=%u\n", __func__, k);
6042 dml_print("DML::%s: NumberOfDPP = %u\n", __func__, NumberOfDPP[k]);
6043 dml_print("DML::%s: ReadBandwidthLuma = %f\n", __func__, ReadBandwidthLuma[k]);
6044 dml_print("DML::%s: UrgentBurstFactorLuma = %f\n", __func__, UrgentBurstFactorLuma[k]);
6045 dml_print("DML::%s: ReadBandwidthChroma = %f\n", __func__, ReadBandwidthChroma[k]);
6046 dml_print("DML::%s: UrgentBurstFactorChroma = %f\n", __func__, UrgentBurstFactorChroma[k]);
6047 dml_print("DML::%s: cursor_bw = %f\n", __func__, cursor_bw[k]);
6048 dml_print("DML::%s: UrgentBurstFactorCursor = %f\n", __func__, UrgentBurstFactorCursor[k]);
6049
6050 dml_print("DML::%s: PrefetchBandwidthLuma = %f\n", __func__, PrefetchBandwidthLuma[k]);
6051 dml_print("DML::%s: UrgentBurstFactorLumaPre = %f\n", __func__, UrgentBurstFactorLumaPre[k]);
6052 dml_print("DML::%s: PrefetchBandwidthChroma = %f\n", __func__, PrefetchBandwidthChroma[k]);
6053 dml_print("DML::%s: UrgentBurstFactorChromaPre = %f\n", __func__, UrgentBurstFactorChromaPre[k]);
6054 dml_print("DML::%s: cursor_bw_pre = %f\n", __func__, cursor_bw_pre[k]);
6055 dml_print("DML::%s: UrgentBurstFactorCursorPre = %f\n", __func__, UrgentBurstFactorCursorPre[k]);
6056 dml_print("DML::%s: ret_val = %f\n", __func__, ret_val);
6057#endif
6058 }
6059
6060 return ret_val;
6061}
6062
6063static void CalculateImmediateFlipBandwithSupport(
6064 dml_uint_t NumberOfActiveSurfaces,
6065 dml_float_t ReturnBW,
6066 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
6067 enum dml_immediate_flip_requirement ImmediateFlipRequirement[],
6068 dml_float_t final_flip_bw[],
6069 dml_float_t ReadBandwidthLuma[],
6070 dml_float_t ReadBandwidthChroma[],
6071 dml_float_t PrefetchBandwidthLuma[],
6072 dml_float_t PrefetchBandwidthChroma[],
6073 dml_float_t cursor_bw[],
6074 dml_float_t meta_row_bandwidth[],
6075 dml_float_t dpte_row_bandwidth[],
6076 dml_float_t cursor_bw_pre[],
6077 dml_float_t prefetch_vmrow_bw[],
6078 dml_uint_t NumberOfDPP[],
6079 dml_float_t UrgentBurstFactorLuma[],
6080 dml_float_t UrgentBurstFactorChroma[],
6081 dml_float_t UrgentBurstFactorCursor[],
6082 dml_float_t UrgentBurstFactorLumaPre[],
6083 dml_float_t UrgentBurstFactorChromaPre[],
6084 dml_float_t UrgentBurstFactorCursorPre[],
6085
6086 // Output
6087 dml_float_t *TotalBandwidth,
6088 dml_float_t *TotalBandwidthNotIncludingMALLPrefetch,
6089 dml_float_t *FractionOfUrgentBandwidth,
6090 dml_bool_t *ImmediateFlipBandwidthSupport)
6091{
6092 *TotalBandwidth = 0;
6093 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6094 if (ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) {
6095
6096
6097
6098 *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6099 NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6100 NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6101 } else {
6102 *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6103 NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]) + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6104 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6105 }
6106#ifdef __DML_VBA_DEBUG__
6107 dml_print("DML::%s: k = %u\n", __func__, k);
6108 dml_print("DML::%s: ImmediateFlipRequirement = %u\n", __func__, ImmediateFlipRequirement[k]);
6109 dml_print("DML::%s: TotalBandwidth = %f\n", __func__, *TotalBandwidth);
6110 dml_print("DML::%s: NumberOfDPP = %u\n", __func__, NumberOfDPP[k]);
6111 dml_print("DML::%s: prefetch_vmrow_bw = %f\n", __func__, prefetch_vmrow_bw[k]);
6112 dml_print("DML::%s: final_flip_bw = %f\n", __func__, final_flip_bw[k]);
6113 dml_print("DML::%s: ReadBandwidthLuma = %f\n", __func__, ReadBandwidthLuma[k]);
6114 dml_print("DML::%s: UrgentBurstFactorLuma = %f\n", __func__, UrgentBurstFactorLuma[k]);
6115 dml_print("DML::%s: ReadBandwidthChroma = %f\n", __func__, ReadBandwidthChroma[k]);
6116 dml_print("DML::%s: UrgentBurstFactorChroma = %f\n", __func__, UrgentBurstFactorChroma[k]);
6117 dml_print("DML::%s: cursor_bw = %f\n", __func__, cursor_bw[k]);
6118 dml_print("DML::%s: UrgentBurstFactorCursor = %f\n", __func__, UrgentBurstFactorCursor[k]);
6119 dml_print("DML::%s: PrefetchBandwidthLuma = %f\n", __func__, PrefetchBandwidthLuma[k]);
6120 dml_print("DML::%s: UrgentBurstFactorLumaPre = %f\n", __func__, UrgentBurstFactorLumaPre[k]);
6121 dml_print("DML::%s: PrefetchBandwidthChroma = %f\n", __func__, PrefetchBandwidthChroma[k]);
6122 dml_print("DML::%s: UrgentBurstFactorChromaPre = %f\n", __func__, UrgentBurstFactorChromaPre[k]);
6123 dml_print("DML::%s: cursor_bw_pre = %f\n", __func__, cursor_bw_pre[k]);
6124 dml_print("DML::%s: UrgentBurstFactorCursorPre = %f\n", __func__, UrgentBurstFactorCursorPre[k]);
6125 dml_print("DML::%s: meta_row_bandwidth = %f\n", __func__, meta_row_bandwidth[k]);
6126 dml_print("DML::%s: dpte_row_bandwidth = %f\n", __func__, dpte_row_bandwidth[k]);
6127#endif
6128 }
6129
6130 *TotalBandwidthNotIncludingMALLPrefetch = 0;
6131 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6132 if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
6133 if (ImmediateFlipRequirement[k] != dml_immediate_flip_not_required)
6134 *TotalBandwidthNotIncludingMALLPrefetch = *TotalBandwidthNotIncludingMALLPrefetch + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6135 NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6136 NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6137 + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6138 else
6139 *TotalBandwidthNotIncludingMALLPrefetch = *TotalBandwidthNotIncludingMALLPrefetch + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6140 NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k])
6141 + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6142 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6143 + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6144 }
6145 }
6146
6147 *ImmediateFlipBandwidthSupport = (*TotalBandwidth <= ReturnBW);
6148 *FractionOfUrgentBandwidth = *TotalBandwidth / ReturnBW;
6149#ifdef __DML_VBA_DEBUG__
6150 dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
6151 dml_print("DML::%s: TotalBandwidth = %f\n", __func__, *TotalBandwidth);
6152 dml_print("DML::%s: ImmediateFlipBandwidthSupport = %u\n", __func__, *ImmediateFlipBandwidthSupport);
6153#endif
6154}
6155
cbe069f5
DM		 6156static dml_uint_t MicroSecToVertLines(dml_uint_t num_us, dml_uint_t h_total, dml_float_t pixel_clock)
6157{
6158 dml_uint_t lines_time_in_ns = 1000.0 * (h_total * 1000.0) / (pixel_clock * 1000.0);
6159
6160 return dml_ceil(1000.0 * num_us / lines_time_in_ns, 1.0);
6161}
6162
7966f319
QZ		 6163/// @brief Calculate the maximum vstartup for mode support and mode programming consideration
6164/// Bounded by min of actual vblank and input vblank_nom, dont want vstartup/ready to start too early if actual vbllank is huge
6165static dml_uint_t CalculateMaxVStartup(
6166 dml_uint_t plane_idx,
6167 dml_bool_t ptoi_supported,
6168 dml_uint_t vblank_nom_default_us,
6169 struct dml_timing_cfg_st *timing,
6170 dml_float_t write_back_delay_us)
6171{
6172 dml_uint_t vblank_size = 0;
6173 dml_uint_t max_vstartup_lines = 0;
cbe069f5 6174 const dml_uint_t max_allowed_vblank_nom = 1023;
7966f319
QZ		 6175
6176 dml_float_t line_time_us = (dml_float_t) timing->HTotal[plane_idx] / timing->PixelClock[plane_idx];
6177 dml_uint_t vblank_actual = timing->VTotal[plane_idx] - timing->VActive[plane_idx];
cbe069f5
DM		 6178
6179 dml_uint_t vblank_nom_default_in_line = MicroSecToVertLines(vblank_nom_default_us, timing->HTotal[plane_idx],
6180 timing->PixelClock[plane_idx]);
6181 dml_uint_t vblank_nom_input = (dml_uint_t)dml_min(vblank_actual, vblank_nom_default_in_line);
6182
6183 // vblank_nom should not be smaller than (VSync (VTotal - VActive - VFrontPorch) + 2)
6184 // + 2 is because
6185 // 1 -> VStartup_start should be 1 line before VSync
6186 // 1 -> always reserve 1 line between start of VBlank to VStartup signal
6187 dml_uint_t vblank_nom_vsync_capped = dml_max(vblank_nom_input,
6188 timing->VTotal[plane_idx] - timing->VActive[plane_idx] - timing->VFrontPorch[plane_idx] + 2);
6189 dml_uint_t vblank_nom_max_allowed_capped = dml_min(vblank_nom_vsync_capped, max_allowed_vblank_nom);
6190 dml_uint_t vblank_avail = (vblank_nom_max_allowed_capped == 0) ?
6191 vblank_nom_default_in_line : vblank_nom_max_allowed_capped;
7966f319
QZ		 6192
6193 vblank_size = (dml_uint_t) dml_min(vblank_actual, vblank_avail);
6194
6195 if (timing->Interlace[plane_idx] && !ptoi_supported)
6196 max_vstartup_lines = (dml_uint_t) (dml_floor(vblank_size/2.0, 1.0));
6197 else
6198 max_vstartup_lines = vblank_size - (dml_uint_t) dml_max(1.0, dml_ceil(write_back_delay_us/line_time_us, 1.0));
6199#ifdef __DML_VBA_DEBUG__
6200 dml_print("DML::%s: plane_idx = %u\n", __func__, plane_idx);
6201 dml_print("DML::%s: VBlankNom = %u\n", __func__, timing->VBlankNom[plane_idx]);
6202 dml_print("DML::%s: vblank_nom_default_us = %u\n", __func__, vblank_nom_default_us);
6203 dml_print("DML::%s: line_time_us = %f\n", __func__, line_time_us);
6204 dml_print("DML::%s: vblank_actual = %u\n", __func__, vblank_actual);
6205 dml_print("DML::%s: vblank_avail = %u\n", __func__, vblank_avail);
6206 dml_print("DML::%s: max_vstartup_lines = %u\n", __func__, max_vstartup_lines);
6207#endif
6208 return max_vstartup_lines;
6209}
6210
6211/// @brief The Mode Support function.
6212dml_bool_t dml_core_mode_support(struct display_mode_lib_st *mode_lib)
6213{
6214 struct dml_core_mode_support_locals_st *s = &mode_lib->scratch.dml_core_mode_support_locals;
6215 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *CalculateWatermarks_params = &mode_lib->scratch.CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params;
6216 struct CalculateVMRowAndSwath_params_st *CalculateVMRowAndSwath_params = &mode_lib->scratch.CalculateVMRowAndSwath_params;
6217 struct UseMinimumDCFCLK_params_st *UseMinimumDCFCLK_params = &mode_lib->scratch.UseMinimumDCFCLK_params;
6218 struct CalculateSwathAndDETConfiguration_params_st *CalculateSwathAndDETConfiguration_params = &mode_lib->scratch.CalculateSwathAndDETConfiguration_params;
6219 struct CalculatePrefetchSchedule_params_st *CalculatePrefetchSchedule_params = &mode_lib->scratch.CalculatePrefetchSchedule_params;
6220 struct DmlPipe *myPipe;
6221
6222 dml_uint_t j, k, m;
6223
6224 mode_lib->ms.num_active_planes = dml_get_num_active_planes(&mode_lib->ms.cache_display_cfg);
6225 dml_print("DML::%s: num_active_planes = %u\n", __func__, mode_lib->ms.num_active_planes);
6226
6227 CalculateMaxDETAndMinCompressedBufferSize(
6228 mode_lib->ms.ip.config_return_buffer_size_in_kbytes,
6229 mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes,
6230 mode_lib->ms.ip.rob_buffer_size_kbytes,
6231 mode_lib->ms.ip.max_num_dpp,
6232 mode_lib->ms.policy.NomDETInKByteOverrideEnable, // VBA_DELTA
6233 mode_lib->ms.policy.NomDETInKByteOverrideValue, // VBA_DELTA
6234
6235 /* Output */
6236 &mode_lib->ms.MaxTotalDETInKByte,
6237 &mode_lib->ms.NomDETInKByte,
6238 &mode_lib->ms.MinCompressedBufferSizeInKByte);
6239
6240 PixelClockAdjustmentForProgressiveToInterlaceUnit(&mode_lib->ms.cache_display_cfg, mode_lib->ms.ip.ptoi_supported);
6241
6242
6243 /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
6244
6245 /*Scale Ratio, taps Support Check*/
6246 mode_lib->ms.support.ScaleRatioAndTapsSupport = true;
6247 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6248 if (mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k] == false
6249 && ((mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
6250 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
6251 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
6252 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
6253 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8
6254 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
6255 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha)
6256 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] != 1.0
6257 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] != 1.0
6258 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] != 1.0
6259 || mode_lib->ms.cache_display_cfg.plane.VTaps[k] != 1.0)) {
6260 mode_lib->ms.support.ScaleRatioAndTapsSupport = false;
6261 } else if (mode_lib->ms.cache_display_cfg.plane.VTaps[k] < 1.0 || mode_lib->ms.cache_display_cfg.plane.VTaps[k] > 8.0
6262 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] < 1.0 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] > 8.0
6263 || (mode_lib->ms.cache_display_cfg.plane.HTaps[k] > 1.0 && (mode_lib->ms.cache_display_cfg.plane.HTaps[k] % 2) == 1)
6264 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] > mode_lib->ms.ip.max_hscl_ratio
6265 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] > mode_lib->ms.ip.max_vscl_ratio
6266 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] > mode_lib->ms.cache_display_cfg.plane.HTaps[k]
6267 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] > mode_lib->ms.cache_display_cfg.plane.VTaps[k]
6268 || (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
6269 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
6270 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
6271 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
6272 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8
6273 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
6274 && (mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k] < 1 || mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k] > 8 || mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] < 1 || mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] > 8 ||
6275 (mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] > 1 && mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] % 2 == 1) ||
6276 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k] > mode_lib->ms.ip.max_hscl_ratio ||
6277 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k] > mode_lib->ms.ip.max_vscl_ratio ||
6278 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k] > mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] ||
6279 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k] > mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k]))) {
6280 mode_lib->ms.support.ScaleRatioAndTapsSupport = false;
6281 }
6282 }
6283
6284 /*Source Format, Pixel Format and Scan Support Check*/
6285 mode_lib->ms.support.SourceFormatPixelAndScanSupport = true;
6286 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6287 if (mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear && (!(!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k])) || mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true)) {
6288 mode_lib->ms.support.SourceFormatPixelAndScanSupport = false;
6289 }
6290 }
6291
6292 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6293 CalculateBytePerPixelAndBlockSizes(
6294 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
6295 mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
6296
6297 /* Output */
6298 &mode_lib->ms.BytePerPixelY[k],
6299 &mode_lib->ms.BytePerPixelC[k],
6300 &mode_lib->ms.BytePerPixelInDETY[k],
6301 &mode_lib->ms.BytePerPixelInDETC[k],
6302 &mode_lib->ms.Read256BlockHeightY[k],
6303 &mode_lib->ms.Read256BlockHeightC[k],
6304 &mode_lib->ms.Read256BlockWidthY[k],
6305 &mode_lib->ms.Read256BlockWidthC[k],
6306 &mode_lib->ms.MacroTileHeightY[k],
6307 &mode_lib->ms.MacroTileHeightC[k],
6308 &mode_lib->ms.MacroTileWidthY[k],
6309 &mode_lib->ms.MacroTileWidthC[k]);
6310 }
6311
6312 /*Bandwidth Support Check*/
6313 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6314 if (!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k])) {
6315 mode_lib->ms.SwathWidthYSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportWidth[k];
6316 mode_lib->ms.SwathWidthCSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma[k];
6317 } else {
6318 mode_lib->ms.SwathWidthYSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
6319 mode_lib->ms.SwathWidthCSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
6320 }
6321 }
6322 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6323 mode_lib->ms.ReadBandwidthLuma[k] = mode_lib->ms.SwathWidthYSingleDPP[k] * dml_ceil(mode_lib->ms.BytePerPixelInDETY[k], 1.0) / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
6324 mode_lib->ms.ReadBandwidthChroma[k] = mode_lib->ms.SwathWidthYSingleDPP[k] / 2 * dml_ceil(mode_lib->ms.BytePerPixelInDETC[k], 2.0) / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k] / 2.0;
6325 }
6326 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6327 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true
6328 && mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k] == dml_444_64) {
6329 mode_lib->ms.WriteBandwidth[k] = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k]
6330 * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k]
6331 / (mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k]
6332 * mode_lib->ms.cache_display_cfg.timing.HTotal[k]
6333 / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 8.0;
6334 } else if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6335 mode_lib->ms.WriteBandwidth[k] = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k]
6336 * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k]
6337 / (mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k]
6338 * mode_lib->ms.cache_display_cfg.timing.HTotal[k]
6339 / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 4.0;
6340 } else {
6341 mode_lib->ms.WriteBandwidth[k] = 0.0;
6342 }
6343 }
6344
6345 /*Writeback Latency support check*/
6346 mode_lib->ms.support.WritebackLatencySupport = true;
6347 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6348 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true &&
6349 (mode_lib->ms.WriteBandwidth[k] > mode_lib->ms.ip.writeback_interface_buffer_size_kbytes * 1024 / mode_lib->ms.state.writeback_latency_us)) {
6350 mode_lib->ms.support.WritebackLatencySupport = false;
6351 }
6352 }
6353
6354 /*Writeback Mode Support Check*/
6355 s->TotalNumberOfActiveWriteback = 0;
6356 for (k = 0; k <= (dml_uint_t) mode_lib->ms.num_active_planes - 1; k++) {
6357 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6358 s->TotalNumberOfActiveWriteback = s->TotalNumberOfActiveWriteback + 1;
6359 }
6360 }
6361
6362 mode_lib->ms.support.EnoughWritebackUnits = 1;
6363 if (s->TotalNumberOfActiveWriteback > (dml_uint_t) mode_lib->ms.ip.max_num_wb) {
6364 mode_lib->ms.support.EnoughWritebackUnits = false;
6365 }
6366
6367 /*Writeback Scale Ratio and Taps Support Check*/
6368 mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = true;
6369 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6370 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6371 if (mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] > mode_lib->ms.ip.writeback_max_hscl_ratio
6372 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] > mode_lib->ms.ip.writeback_max_vscl_ratio
6373 || mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] < mode_lib->ms.ip.writeback_min_hscl_ratio
6374 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] < mode_lib->ms.ip.writeback_min_vscl_ratio
6375 || mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] > (dml_uint_t) mode_lib->ms.ip.writeback_max_hscl_taps
6376 || mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k] > (dml_uint_t) mode_lib->ms.ip.writeback_max_vscl_taps
6377 || mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] > (dml_uint_t) mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k]
6378 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] > (dml_uint_t) mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k]
6379 || (mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] > 2.0 && ((mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] % 2) == 1))) {
6380 mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = false;
6381 }
6382 if (2.0 * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * (mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k] - 1) * 57 > mode_lib->ms.ip.writeback_line_buffer_buffer_size) {
6383 mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = false;
6384 }
6385 }
6386 }
6387
6388 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6389 CalculateSinglePipeDPPCLKAndSCLThroughput(
6390 mode_lib->ms.cache_display_cfg.plane.HRatio[k],
6391 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k],
6392 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
6393 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
6394 mode_lib->ms.ip.max_dchub_pscl_bw_pix_per_clk,
6395 mode_lib->ms.ip.max_pscl_lb_bw_pix_per_clk,
6396 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6397 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
6398 mode_lib->ms.cache_display_cfg.plane.HTaps[k],
6399 mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k],
6400 mode_lib->ms.cache_display_cfg.plane.VTaps[k],
6401 mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k],
6402 /* Output */
6403 &mode_lib->ms.PSCL_FACTOR[k],
6404 &mode_lib->ms.PSCL_FACTOR_CHROMA[k],
6405 &mode_lib->ms.MinDPPCLKUsingSingleDPP[k]);
6406 }
6407
6408 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6409 if (mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear) {
6410 s->MaximumSwathWidthSupportLuma = 8192;
6411 } else if (!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelC[k] > 0 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha) {
6412 s->MaximumSwathWidthSupportLuma = 7680;
6413 } else if (dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelC[k] > 0 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha) {
6414 s->MaximumSwathWidthSupportLuma = 4320;
6415 } else if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_rgbe_alpha) {
6416 s->MaximumSwathWidthSupportLuma = 3840;
6417 } else if (dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelY[k] == 8 && mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
6418 s->MaximumSwathWidthSupportLuma = 3072;
6419 } else {
6420 s->MaximumSwathWidthSupportLuma = 6144;
6421 }
6422
6423 if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_8 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_10 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_12) {
6424 s->MaximumSwathWidthSupportChroma = (dml_uint_t)(s->MaximumSwathWidthSupportLuma / 2.0);
6425 } else {
6426 s->MaximumSwathWidthSupportChroma = s->MaximumSwathWidthSupportLuma;
6427 }
6428 mode_lib->ms.MaximumSwathWidthInLineBufferLuma = mode_lib->ms.ip.line_buffer_size_bits * dml_max(mode_lib->ms.cache_display_cfg.plane.HRatio[k], 1.0) / mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel[k] /
6429 (mode_lib->ms.cache_display_cfg.plane.VTaps[k] + dml_max(dml_ceil(mode_lib->ms.cache_display_cfg.plane.VRatio[k], 1.0) - 2, 0.0));
6430 if (mode_lib->ms.BytePerPixelC[k] == 0.0) {
6431 mode_lib->ms.MaximumSwathWidthInLineBufferChroma = 0;
6432 } else {
6433 mode_lib->ms.MaximumSwathWidthInLineBufferChroma =
6434 mode_lib->ms.ip.line_buffer_size_bits
6435 * dml_max(mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k], 1.0)
6436 / mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel[k]
6437 / (mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k]
6438 + dml_max(dml_ceil(mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k], 1.0) - 2, 0.0));
6439 }
6440 mode_lib->ms.MaximumSwathWidthLuma[k] = dml_min(s->MaximumSwathWidthSupportLuma, mode_lib->ms.MaximumSwathWidthInLineBufferLuma);
6441 mode_lib->ms.MaximumSwathWidthChroma[k] = dml_min(s->MaximumSwathWidthSupportChroma, mode_lib->ms.MaximumSwathWidthInLineBufferChroma);
6442 }
6443
6444 /*Number Of DSC Slices*/
6445 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6446 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
6447 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 4800) {
6448 mode_lib->ms.support.NumberOfDSCSlices[k] = (dml_uint_t)(dml_ceil(mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 600, 4));
6449 } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 2400) {
6450 mode_lib->ms.support.NumberOfDSCSlices[k] = 8;
6451 } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 1200) {
6452 mode_lib->ms.support.NumberOfDSCSlices[k] = 4;
6453 } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 340) {
6454 mode_lib->ms.support.NumberOfDSCSlices[k] = 2;
6455 } else {
6456 mode_lib->ms.support.NumberOfDSCSlices[k] = 1;
6457 }
6458 } else {
6459 mode_lib->ms.support.NumberOfDSCSlices[k] = 0;
6460 }
6461 }
6462
6463 CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
6464 CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
6465 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
6466 CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
6467 CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
6468 CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
6469 CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
6470 CalculateSwathAndDETConfiguration_params->ForceSingleDPP = 1;
6471 CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
6472 CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
6473 CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
6474 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
6475 CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
6476 CalculateSwathAndDETConfiguration_params->Output = mode_lib->ms.cache_display_cfg.output.OutputEncoder;
6477 CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
6478 CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
6479 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = mode_lib->ms.MaximumSwathWidthLuma;
6480 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = mode_lib->ms.MaximumSwathWidthChroma;
6481 CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
6482 CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
6483 CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
6484 CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
6485 CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
6486 CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
6487 CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
6488 CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
6489 CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
6490 CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
6491 CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
6492 CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
6493 CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
6494 CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
6495 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = mode_lib->ms.Read256BlockHeightY;
6496 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = mode_lib->ms.Read256BlockHeightC;
6497 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = mode_lib->ms.Read256BlockWidthY;
6498 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = mode_lib->ms.Read256BlockWidthC;
6499 CalculateSwathAndDETConfiguration_params->ODMMode = s->dummy_odm_mode;
6500 CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
6501 CalculateSwathAndDETConfiguration_params->BytePerPixY = mode_lib->ms.BytePerPixelY;
6502 CalculateSwathAndDETConfiguration_params->BytePerPixC = mode_lib->ms.BytePerPixelC;
6503 CalculateSwathAndDETConfiguration_params->BytePerPixDETY = mode_lib->ms.BytePerPixelInDETY;
6504 CalculateSwathAndDETConfiguration_params->BytePerPixDETC = mode_lib->ms.BytePerPixelInDETC;
6505 CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
6506 CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
6507 CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
6508 CalculateSwathAndDETConfiguration_params->DPPPerSurface = s->dummy_integer_array[0];
6509 CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = s->dummy_integer_array[1];
6510 CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = s->dummy_integer_array[2];
6511 CalculateSwathAndDETConfiguration_params->SwathWidth = s->dummy_integer_array[3];
6512 CalculateSwathAndDETConfiguration_params->SwathWidthChroma = s->dummy_integer_array[4];
6513 CalculateSwathAndDETConfiguration_params->SwathHeightY = s->dummy_integer_array[5];
6514 CalculateSwathAndDETConfiguration_params->SwathHeightC = s->dummy_integer_array[6];
6515 CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = s->dummy_integer_array[7];
6516 CalculateSwathAndDETConfiguration_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeY;
6517 CalculateSwathAndDETConfiguration_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeC;
6518 CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &s->dummy_boolean[0];
6519 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &s->dummy_integer[2];
6520 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &s->dummy_integer[1];
6521 CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &s->dummy_integer[0];
6522 CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = mode_lib->ms.SingleDPPViewportSizeSupportPerSurface;
6523 CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &s->dummy_boolean[1];
6524
6525 CalculateSwathAndDETConfiguration(&mode_lib->scratch,
6526 CalculateSwathAndDETConfiguration_params); /* dml_bool_t *ViewportSizeSupport */
6527
6528 s->MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
6529 s->MPCCombineMethodAsPossible = false;
6530 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6531 if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_as_needed_for_pstate_and_voltage)
6532 s->MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
6533 if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_as_possible)
6534 s->MPCCombineMethodAsPossible = true;
6535 }
6536 mode_lib->ms.support.MPCCombineMethodIncompatible = s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && s->MPCCombineMethodAsPossible;
6537
6538 for (j = 0; j < 2; j++) {
6539 mode_lib->ms.TotalNumberOfActiveDPP[j] = 0;
6540 mode_lib->ms.support.TotalAvailablePipesSupport[j] = true;
6541
6542 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6543 CalculateODMMode(
6544 mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit,
6545 mode_lib->ms.cache_display_cfg.timing.HActive[k],
6546 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
6547 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
6548 mode_lib->ms.policy.ODMUse[k],
6549 mode_lib->ms.state.dispclk_mhz,
6550 mode_lib->ms.max_state.dispclk_mhz,
6551 false, // DSCEnable
6552 mode_lib->ms.TotalNumberOfActiveDPP[j],
6553 mode_lib->ms.ip.max_num_dpp,
6554 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6555 mode_lib->ms.soc.dcn_downspread_percent,
6556 mode_lib->ms.ip.dispclk_ramp_margin_percent,
6557 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
6558
6559 /* Output */
6560 &s->TotalAvailablePipesSupportNoDSC,
6561 &s->NumberOfDPPNoDSC,
6562 &s->ODMModeNoDSC,
6563 &s->RequiredDISPCLKPerSurfaceNoDSC);
6564
6565 CalculateODMMode(
6566 mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit,
6567 mode_lib->ms.cache_display_cfg.timing.HActive[k],
6568 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
6569 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
6570 mode_lib->ms.policy.ODMUse[k],
6571 mode_lib->ms.state.dispclk_mhz,
6572 mode_lib->ms.max_state.dispclk_mhz,
6573 true, // DSCEnable
6574 mode_lib->ms.TotalNumberOfActiveDPP[j],
6575 mode_lib->ms.ip.max_num_dpp,
6576 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6577 mode_lib->ms.soc.dcn_downspread_percent,
6578 mode_lib->ms.ip.dispclk_ramp_margin_percent,
6579 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
6580
6581 /* Output */
6582 &s->TotalAvailablePipesSupportDSC,
6583 &s->NumberOfDPPDSC,
6584 &s->ODMModeDSC,
6585 &s->RequiredDISPCLKPerSurfaceDSC);
6586
6587 CalculateOutputLink(
6588 mode_lib->ms.state.phyclk_mhz,
6589 mode_lib->ms.state.phyclk_d18_mhz,
6590 mode_lib->ms.state.phyclk_d32_mhz,
6591 mode_lib->ms.soc.phy_downspread_percent,
6592 (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k),
6593 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
6594 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
6595 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
6596 mode_lib->ms.cache_display_cfg.timing.HActive[k],
6597 mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k],
6598 mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k],
6599 mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
6600 mode_lib->ms.support.NumberOfDSCSlices[k],
6601 mode_lib->ms.cache_display_cfg.output.AudioSampleRate[k],
6602 mode_lib->ms.cache_display_cfg.output.AudioSampleLayout[k],
6603 s->ODMModeNoDSC,
6604 s->ODMModeDSC,
6605 mode_lib->ms.cache_display_cfg.output.DSCEnable[k],
6606 mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k],
6607 mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k],
6608
6609 /* Output */
6610 &mode_lib->ms.RequiresDSC[k],
6611 &mode_lib->ms.RequiresFEC[k],
6612 &mode_lib->ms.OutputBppPerState[k],
6613 &mode_lib->ms.OutputTypePerState[k], // VBA_DELTA, VBA uses a string to represent type and rate, but DML uses enum, don't want to rely on strng
6614 &mode_lib->ms.OutputRatePerState[k],
6615 &mode_lib->ms.RequiredSlots[k]);
6616
6617 if (mode_lib->ms.RequiresDSC[k] == false) {
6618 mode_lib->ms.ODMModePerState[k] = s->ODMModeNoDSC;
6619 mode_lib->ms.RequiredDISPCLKPerSurface[j][k] = s->RequiredDISPCLKPerSurfaceNoDSC;
6620 if (!s->TotalAvailablePipesSupportNoDSC)
6621 mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
6622 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + s->NumberOfDPPNoDSC;
6623 } else {
6624 mode_lib->ms.ODMModePerState[k] = s->ODMModeDSC;
6625 mode_lib->ms.RequiredDISPCLKPerSurface[j][k] = s->RequiredDISPCLKPerSurfaceDSC;
6626 if (!s->TotalAvailablePipesSupportDSC)
6627 mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
6628 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + s->NumberOfDPPDSC;
6629 }
6630 }
6631
6632 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6633 if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
6634 mode_lib->ms.MPCCombine[j][k] = false;
6635 mode_lib->ms.NoOfDPP[j][k] = 4;
6636 } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
6637 mode_lib->ms.MPCCombine[j][k] = false;
6638 mode_lib->ms.NoOfDPP[j][k] = 2;
6639 } else if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_disabled) {
6640 mode_lib->ms.MPCCombine[j][k] = false;
6641 mode_lib->ms.NoOfDPP[j][k] = 1;
6642 } else if (RoundToDFSGranularity(mode_lib->ms.MinDPPCLKUsingSingleDPP[k] * (1 + mode_lib->ms.soc.dcn_downspread_percent / 100),
6643 1, mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz) <= mode_lib->ms.state.dppclk_mhz &&
6644 mode_lib->ms.SingleDPPViewportSizeSupportPerSurface[k] == true) {
6645 mode_lib->ms.MPCCombine[j][k] = false;
6646 mode_lib->ms.NoOfDPP[j][k] = 1;
6647 } else if (mode_lib->ms.TotalNumberOfActiveDPP[j] < (dml_uint_t) mode_lib->ms.ip.max_num_dpp) {
6648 mode_lib->ms.MPCCombine[j][k] = true;
6649 mode_lib->ms.NoOfDPP[j][k] = 2;
6650 mode_lib->ms.TotalNumberOfActiveDPP[j] = (dml_uint_t) mode_lib->ms.TotalNumberOfActiveDPP[j] + 1;
6651 } else {
6652 mode_lib->ms.MPCCombine[j][k] = false;
6653 mode_lib->ms.NoOfDPP[j][k] = 1;
6654 mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
6655 }
6656 }
6657
6658 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = 0;
6659 s->NoChromaOrLinear = true;
6660 for (k = 0; k < (dml_uint_t) mode_lib->ms.num_active_planes; ++k) {
6661 if (mode_lib->ms.NoOfDPP[j][k] == 1)
6662 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] + 1;
6663 if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_8
6664 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_10
6665 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_12
6666 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_rgbe_alpha
6667 || mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear) {
6668 s->NoChromaOrLinear = false;
6669 }
6670 }
6671
6672 if (j == 1 && !UnboundedRequest(mode_lib->ms.policy.UseUnboundedRequesting,
6673 mode_lib->ms.TotalNumberOfActiveDPP[j], s->NoChromaOrLinear,
6674 mode_lib->ms.cache_display_cfg.output.OutputEncoder[0])) {
6675 while (!(mode_lib->ms.TotalNumberOfActiveDPP[j] >= (dml_uint_t) mode_lib->ms.ip.max_num_dpp || mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] == 0)) {
6676 s->BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
6677 s->NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;
6678 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6679 if (mode_lib->ms.policy.MPCCombineUse[k] != dml_mpc_disabled && mode_lib->ms.policy.MPCCombineUse[k] != dml_mpc_as_needed_for_voltage &&
6680 mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k] > s->BWOfNonCombinedSurfaceOfMaximumBandwidth &&
6681 (mode_lib->ms.ODMModePerState[k] != dml_odm_mode_combine_2to1 && mode_lib->ms.ODMModePerState[k] != dml_odm_mode_combine_4to1) &&
6682 mode_lib->ms.MPCCombine[j][k] == false) {
6683 s->BWOfNonCombinedSurfaceOfMaximumBandwidth = mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k];
6684 s->NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
6685 }
6686 }
6687 mode_lib->ms.MPCCombine[j][s->NumberOfNonCombinedSurfaceOfMaximumBandwidth] = true;
6688 mode_lib->ms.NoOfDPP[j][s->NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
6689 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + 1;
6690 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] - 1;
6691 }
6692 }
6693
6694 //DISPCLK/DPPCLK
6695 mode_lib->ms.WritebackRequiredDISPCLK = 0;
6696 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6697 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k]) {
6698 mode_lib->ms.WritebackRequiredDISPCLK = dml_max(mode_lib->ms.WritebackRequiredDISPCLK,
6699 CalculateWriteBackDISPCLK(mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
6700 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6701 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
6702 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
6703 mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k],
6704 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
6705 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceWidth[k],
6706 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
6707 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
6708 mode_lib->ms.ip.writeback_line_buffer_buffer_size,
6709 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz));
6710 }
6711 }
6712
6713 mode_lib->ms.RequiredDISPCLK[j] = mode_lib->ms.WritebackRequiredDISPCLK;
6714 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6715 mode_lib->ms.RequiredDISPCLK[j] = dml_max(mode_lib->ms.RequiredDISPCLK[j], mode_lib->ms.RequiredDISPCLKPerSurface[j][k]);
6716 }
6717
6718 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6719 mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
6720 }
6721
6722 CalculateDPPCLK(mode_lib->ms.num_active_planes,
6723 mode_lib->ms.soc.dcn_downspread_percent,
6724 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
6725 mode_lib->ms.MinDPPCLKUsingSingleDPP,
6726 mode_lib->ms.NoOfDPPThisState,
6727 /* Output */
6728 &mode_lib->ms.GlobalDPPCLK,
6729 mode_lib->ms.RequiredDPPCLKThisState);
6730
6731 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6732 mode_lib->ms.RequiredDPPCLKPerSurface[j][k] = mode_lib->ms.RequiredDPPCLKThisState[k];
6733 }
6734
6735 mode_lib->ms.support.DISPCLK_DPPCLK_Support[j] = !((mode_lib->ms.RequiredDISPCLK[j] > mode_lib->ms.state.dispclk_mhz) || (mode_lib->ms.GlobalDPPCLK > mode_lib->ms.state.dppclk_mhz));
6736
6737 if (mode_lib->ms.TotalNumberOfActiveDPP[j] > (dml_uint_t) mode_lib->ms.ip.max_num_dpp) {
6738 mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
6739 }
6740 } // j
6741
6742 /* Total Available OTG, HDMIFRL, DP Support Check */
6743 s->TotalNumberOfActiveOTG = 0;
6744 s->TotalNumberOfActiveHDMIFRL = 0;
6745 s->TotalNumberOfActiveDP2p0 = 0;
6746 s->TotalNumberOfActiveDP2p0Outputs = 0;
6747
6748 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6749 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
6750 s->TotalNumberOfActiveOTG = s->TotalNumberOfActiveOTG + 1;
6751 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)
6752 s->TotalNumberOfActiveHDMIFRL = s->TotalNumberOfActiveHDMIFRL + 1;
6753 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0) {
6754 s->TotalNumberOfActiveDP2p0 = s->TotalNumberOfActiveDP2p0 + 1;
6755 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k || mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == false) {
6756 s->TotalNumberOfActiveDP2p0Outputs = s->TotalNumberOfActiveDP2p0Outputs + 1;
6757 }
6758 }
6759 }
6760 }
6761
6762 mode_lib->ms.support.NumberOfOTGSupport = (s->TotalNumberOfActiveOTG <= (dml_uint_t) mode_lib->ms.ip.max_num_otg);
6763 mode_lib->ms.support.NumberOfHDMIFRLSupport = (s->TotalNumberOfActiveHDMIFRL <= (dml_uint_t) mode_lib->ms.ip.max_num_hdmi_frl_outputs);
6764 mode_lib->ms.support.NumberOfDP2p0Support = (s->TotalNumberOfActiveDP2p0 <= (dml_uint_t) mode_lib->ms.ip.max_num_dp2p0_streams && s->TotalNumberOfActiveDP2p0Outputs <= (dml_uint_t) mode_lib->ms.ip.max_num_dp2p0_outputs);
6765
6766 /* Display IO and DSC Support Check */
6767 mode_lib->ms.support.NonsupportedDSCInputBPC = false;
6768 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6769 if (mode_lib->ms.cache_display_cfg.output.OutputDisabled[k] == false &&
6770 !(mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 12.0
6771 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 10.0
6772 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 8.0
6773 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] > (dml_uint_t) mode_lib->ms.ip.maximum_dsc_bits_per_component
6774 )) {
6775 mode_lib->ms.support.NonsupportedDSCInputBPC = true;
6776 }
6777 }
6778
6779 mode_lib->ms.support.ExceededMultistreamSlots = false;
6780 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6781 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k) {
6782 s->TotalSlots = mode_lib->ms.RequiredSlots[k];
6783 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
6784 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[j] == k)
6785 s->TotalSlots = s->TotalSlots + mode_lib->ms.RequiredSlots[j];
6786 }
6787 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp && s->TotalSlots > 63)
6788 mode_lib->ms.support.ExceededMultistreamSlots = true;
6789 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 && s->TotalSlots > 64)
6790 mode_lib->ms.support.ExceededMultistreamSlots = true;
6791 }
6792 }
6793 mode_lib->ms.support.LinkCapacitySupport = true;
6794 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6795 if (mode_lib->ms.cache_display_cfg.output.OutputDisabled[k] == false &&
6796 mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
6797 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) && mode_lib->ms.OutputBppPerState[k] == 0) {
6798 mode_lib->ms.support.LinkCapacitySupport = false;
6799 }
6800 }
6801
6802 mode_lib->ms.support.P2IWith420 = false;
6803 mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP = false;
6804 mode_lib->ms.support.DSC422NativeNotSupported = false;
6805 mode_lib->ms.support.LinkRateDoesNotMatchDPVersion = false;
6806 mode_lib->ms.support.LinkRateForMultistreamNotIndicated = false;
6807 mode_lib->ms.support.BPPForMultistreamNotIndicated = false;
6808 mode_lib->ms.support.MultistreamWithHDMIOreDP = false;
6809 mode_lib->ms.support.MSOOrODMSplitWithNonDPLink = false;
6810 mode_lib->ms.support.NotEnoughLanesForMSO = false;
6811
6812 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6813 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
6814 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)) {
6815 if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420 && mode_lib->ms.cache_display_cfg.timing.Interlace[k] == 1 && mode_lib->ms.ip.ptoi_supported == true)
6816 mode_lib->ms.support.P2IWith420 = true;
6817
6818 if (mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable_if_necessary && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] != 0)
6819 mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP = true;
6820 if ((mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable || mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable_if_necessary) && mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 && !mode_lib->ms.ip.dsc422_native_support)
6821 mode_lib->ms.support.DSC422NativeNotSupported = true;
6822
6823 if (((mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr2 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr3) &&
6824 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp && mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_edp) ||
6825 ((mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr10 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr13p5 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr20) &&
6826 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp2p0))
6827 mode_lib->ms.support.LinkRateDoesNotMatchDPVersion = true;
6828
6829 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1) {
6830 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k && mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_na)
6831 mode_lib->ms.support.LinkRateForMultistreamNotIndicated = true;
6832 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] == 0)
6833 mode_lib->ms.support.BPPForMultistreamNotIndicated = true;
6834 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
6835 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == j && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] == 0)
6836 mode_lib->ms.support.BPPForMultistreamNotIndicated = true;
6837 }
6838 }
6839
6840 if ((mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)) {
6841 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1 && mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k)
6842 mode_lib->ms.support.MultistreamWithHDMIOreDP = true;
6843 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
6844 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1 && mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == j)
6845 mode_lib->ms.support.MultistreamWithHDMIOreDP = true;
6846 }
6847 }
6848 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp && (mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_split_1to2 ||
6849 mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to2 || mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to4))
6850 mode_lib->ms.support.MSOOrODMSplitWithNonDPLink = true;
6851
6852 if ((mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to2 && mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k] < 2) ||
6853 (mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to4 && mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k] < 4))
6854 mode_lib->ms.support.NotEnoughLanesForMSO = true;
6855 }
6856 }
6857
6858 mode_lib->ms.support.DTBCLKRequiredMoreThanSupported = false;
6859 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6860 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k &&
6861 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl &&
6862 RequiredDTBCLK(
6863 mode_lib->ms.RequiresDSC[k],
6864 mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k],
6865 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
6866 mode_lib->ms.OutputBppPerState[k],
6867 mode_lib->ms.support.NumberOfDSCSlices[k],
6868 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
6869 mode_lib->ms.cache_display_cfg.timing.HActive[k],
6870 mode_lib->ms.cache_display_cfg.output.AudioSampleRate[k],
6871 mode_lib->ms.cache_display_cfg.output.AudioSampleLayout[k]) > mode_lib->ms.state.dtbclk_mhz) {
6872 mode_lib->ms.support.DTBCLKRequiredMoreThanSupported = true;
6873 }
6874 }
6875
6876 mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK = true;
6877 mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK = true;
6878 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6879 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1 && mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi) {
6880 mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK = false;
6881 }
6882 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1 && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp ||
6883 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi)) {
6884 mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK = false;
6885 }
6886 }
6887
6888 mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = false;
6889 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6890 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
6891 if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp ||
6892 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 ||
6893 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
6894 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) {
6895 if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420) {
6896 s->DSCFormatFactor = 2;
6897 } else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_444) {
6898 s->DSCFormatFactor = 1;
6899 } else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) {
6900 s->DSCFormatFactor = 2;
6901 } else {
6902 s->DSCFormatFactor = 1;
6903 }
6904#ifdef __DML_VBA_DEBUG__
6905 dml_print("DML::%s: k=%u, RequiresDSC = %u\n", __func__, k, mode_lib->ms.RequiresDSC[k]);
6906#endif
6907 if (mode_lib->ms.RequiresDSC[k] == true) {
6908 if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
6909 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 12.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
6910#ifdef __DML_VBA_DEBUG__
6911 dml_print("DML::%s: k=%u, PixelClockBackEnd = %f\n", __func__, k, mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
6912 dml_print("DML::%s: k=%u, DSCCLKPerState = %f\n", __func__, k, mode_lib->ms.state.dscclk_mhz);
6913 dml_print("DML::%s: k=%u, DSCFormatFactor = %u\n", __func__, k, s->DSCFormatFactor);
6914#endif
6915 mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
6916 }
6917 } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
6918 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 6.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
6919 mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
6920 }
6921 } else {
6922 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 3.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
6923 mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
6924 }
6925 }
6926 }
6927 }
6928 }
6929 }
6930#ifdef __DML_VBA_DEBUG__
6931 dml_print("DML::%s: DSCCLKRequiredMoreThanSupported = %u\n", __func__, mode_lib->ms.support.DSCCLKRequiredMoreThanSupported);
6932#endif
6933
6934 /* Check DSC Unit and Slices Support */
6935 mode_lib->ms.support.NotEnoughDSCUnits = false;
6936 mode_lib->ms.support.NotEnoughDSCSlices = false;
6937 s->TotalDSCUnitsRequired = 0;
6938 mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = true;
6939 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6940 if (mode_lib->ms.RequiresDSC[k] == true) {
6941 if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
6942 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > 4 * (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
6943 mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
6944 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 4;
6945 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 16)
6946 mode_lib->ms.support.NotEnoughDSCSlices = true;
6947 } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
6948 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > 2 * (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
6949 mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
6950 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 2;
6951 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 8)
6952 mode_lib->ms.support.NotEnoughDSCSlices = true;
6953 } else {
6954 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
6955 mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
6956 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 1;
6957 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 4)
6958 mode_lib->ms.support.NotEnoughDSCSlices = true;
6959 }
6960 }
6961 }
6962 if (s->TotalDSCUnitsRequired > (dml_uint_t) mode_lib->ms.ip.num_dsc) {
6963 mode_lib->ms.support.NotEnoughDSCUnits = true;
6964 }
6965
6966 /*DSC Delay per state*/
6967 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6968 mode_lib->ms.DSCDelayPerState[k] = DSCDelayRequirement(mode_lib->ms.RequiresDSC[k],
6969 mode_lib->ms.ODMModePerState[k],
6970 mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
6971 mode_lib->ms.OutputBppPerState[k],
6972 mode_lib->ms.cache_display_cfg.timing.HActive[k],
6973 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
6974 mode_lib->ms.support.NumberOfDSCSlices[k],
6975 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
6976 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
6977 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6978 mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
6979 }
6980
6981 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6982 for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
6983 for (j = 0; j <= mode_lib->ms.num_active_planes - 1; j++) {
6984 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == m && mode_lib->ms.RequiresDSC[m] == true) {
6985 mode_lib->ms.DSCDelayPerState[k] = mode_lib->ms.DSCDelayPerState[m];
6986 }
6987 }
6988 }
6989 }
6990
6991 //Calculate Swath, DET Configuration, DCFCLKDeepSleep
6992 //
6993 for (j = 0; j < 2; ++j) {
6994 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6995 mode_lib->ms.RequiredDPPCLKThisState[k] = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
6996 mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
6997 mode_lib->ms.ODMModeThisState[k] = mode_lib->ms.ODMModePerState[k];
6998 }
6999
7000 CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
7001 CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7002 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
7003 CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
7004 CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
7005 CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
7006 CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
7007 CalculateSwathAndDETConfiguration_params->ForceSingleDPP = false;
7008 CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7009 CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
7010 CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
7011 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
7012 CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
7013 CalculateSwathAndDETConfiguration_params->Output = mode_lib->ms.cache_display_cfg.output.OutputEncoder;
7014 CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
7015 CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
7016 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = mode_lib->ms.MaximumSwathWidthLuma;
7017 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = mode_lib->ms.MaximumSwathWidthChroma;
7018 CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
7019 CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
7020 CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
7021 CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
7022 CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
7023 CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
7024 CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
7025 CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
7026 CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
7027 CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
7028 CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
7029 CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
7030 CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
7031 CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
7032 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = mode_lib->ms.Read256BlockHeightY;
7033 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = mode_lib->ms.Read256BlockHeightC;
7034 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = mode_lib->ms.Read256BlockWidthY;
7035 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = mode_lib->ms.Read256BlockWidthC;
7036 CalculateSwathAndDETConfiguration_params->ODMMode = mode_lib->ms.ODMModeThisState;
7037 CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
7038 CalculateSwathAndDETConfiguration_params->BytePerPixY = mode_lib->ms.BytePerPixelY;
7039 CalculateSwathAndDETConfiguration_params->BytePerPixC = mode_lib->ms.BytePerPixelC;
7040 CalculateSwathAndDETConfiguration_params->BytePerPixDETY = mode_lib->ms.BytePerPixelInDETY;
7041 CalculateSwathAndDETConfiguration_params->BytePerPixDETC = mode_lib->ms.BytePerPixelInDETC;
7042 CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
7043 CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
7044 CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
7045 CalculateSwathAndDETConfiguration_params->DPPPerSurface = mode_lib->ms.NoOfDPPThisState;
7046 CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = mode_lib->ms.swath_width_luma_ub_this_state;
7047 CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = mode_lib->ms.swath_width_chroma_ub_this_state;
7048 CalculateSwathAndDETConfiguration_params->SwathWidth = mode_lib->ms.SwathWidthYThisState;
7049 CalculateSwathAndDETConfiguration_params->SwathWidthChroma = mode_lib->ms.SwathWidthCThisState;
7050 CalculateSwathAndDETConfiguration_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState;
7051 CalculateSwathAndDETConfiguration_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState;
7052 CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = mode_lib->ms.DETBufferSizeInKByteThisState;
7053 CalculateSwathAndDETConfiguration_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeYThisState;
7054 CalculateSwathAndDETConfiguration_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeCThisState;
7055 CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &mode_lib->ms.UnboundedRequestEnabledThisState;
7056 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &s->dummy_integer[2];
7057 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &s->dummy_integer[1];
7058 CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &mode_lib->ms.CompressedBufferSizeInkByteThisState;
7059 CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = s->dummy_boolean_array[0];
7060 CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &mode_lib->ms.support.ViewportSizeSupport[j];
7061
7062 CalculateSwathAndDETConfiguration(&mode_lib->scratch,
7063 CalculateSwathAndDETConfiguration_params);
7064
7065 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7066 mode_lib->ms.swath_width_luma_ub_all_states[j][k] = mode_lib->ms.swath_width_luma_ub_this_state[k];
7067 mode_lib->ms.swath_width_chroma_ub_all_states[j][k] = mode_lib->ms.swath_width_chroma_ub_this_state[k];
7068 mode_lib->ms.SwathWidthYAllStates[j][k] = mode_lib->ms.SwathWidthYThisState[k];
7069 mode_lib->ms.SwathWidthCAllStates[j][k] = mode_lib->ms.SwathWidthCThisState[k];
7070 mode_lib->ms.SwathHeightYAllStates[j][k] = mode_lib->ms.SwathHeightYThisState[k];
7071 mode_lib->ms.SwathHeightCAllStates[j][k] = mode_lib->ms.SwathHeightCThisState[k];
7072 mode_lib->ms.UnboundedRequestEnabledAllStates[j] = mode_lib->ms.UnboundedRequestEnabledThisState;
7073 mode_lib->ms.CompressedBufferSizeInkByteAllStates[j] = mode_lib->ms.CompressedBufferSizeInkByteThisState;
7074 mode_lib->ms.DETBufferSizeInKByteAllStates[j][k] = mode_lib->ms.DETBufferSizeInKByteThisState[k];
7075 mode_lib->ms.DETBufferSizeYAllStates[j][k] = mode_lib->ms.DETBufferSizeYThisState[k];
7076 mode_lib->ms.DETBufferSizeCAllStates[j][k] = mode_lib->ms.DETBufferSizeCThisState[k];
7077 }
7078 }
7079
7080 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7081 mode_lib->ms.cursor_bw[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
7082 }
7083
7084 CalculateSurfaceSizeInMall(
7085 mode_lib->ms.num_active_planes,
7086 mode_lib->ms.soc.mall_allocated_for_dcn_mbytes,
7087 mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen,
7088 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
7089 mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
7090 mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
7091 mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
7092 mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
7093 mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
7094 mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
7095 mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
7096 mode_lib->ms.BytePerPixelY,
7097 mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma,
7098 mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma,
7099 mode_lib->ms.BytePerPixelC,
7100 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
7101 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
7102 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
7103 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
7104 mode_lib->ms.Read256BlockWidthY,
7105 mode_lib->ms.Read256BlockWidthC,
7106 mode_lib->ms.Read256BlockHeightY,
7107 mode_lib->ms.Read256BlockHeightC,
7108 mode_lib->ms.MacroTileWidthY,
7109 mode_lib->ms.MacroTileWidthC,
7110 mode_lib->ms.MacroTileHeightY,
7111 mode_lib->ms.MacroTileHeightC,
7112
7113 /* Output */
7114 mode_lib->ms.SurfaceSizeInMALL,
7115 &mode_lib->ms.support.ExceededMALLSize);
7116
7117 for (j = 0; j < 2; j++) {
7118 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7119 mode_lib->ms.swath_width_luma_ub_this_state[k] = mode_lib->ms.swath_width_luma_ub_all_states[j][k];
7120 mode_lib->ms.swath_width_chroma_ub_this_state[k] = mode_lib->ms.swath_width_chroma_ub_all_states[j][k];
7121 mode_lib->ms.SwathWidthYThisState[k] = mode_lib->ms.SwathWidthYAllStates[j][k];
7122 mode_lib->ms.SwathWidthCThisState[k] = mode_lib->ms.SwathWidthCAllStates[j][k];
7123 mode_lib->ms.SwathHeightYThisState[k] = mode_lib->ms.SwathHeightYAllStates[j][k];
7124 mode_lib->ms.SwathHeightCThisState[k] = mode_lib->ms.SwathHeightCAllStates[j][k];
7125 mode_lib->ms.DETBufferSizeInKByteThisState[k] = mode_lib->ms.DETBufferSizeInKByteAllStates[j][k];
7126 mode_lib->ms.DETBufferSizeYThisState[k] = mode_lib->ms.DETBufferSizeYAllStates[j][k];
7127 mode_lib->ms.DETBufferSizeCThisState[k] = mode_lib->ms.DETBufferSizeCAllStates[j][k];
7128 mode_lib->ms.RequiredDPPCLKThisState[k] = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
7129 mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
7130 }
7131
7132 mode_lib->ms.TotalNumberOfDCCActiveDPP[j] = 0;
7133 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7134 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
7135 mode_lib->ms.TotalNumberOfDCCActiveDPP[j] = mode_lib->ms.TotalNumberOfDCCActiveDPP[j] + mode_lib->ms.NoOfDPP[j][k];
7136 }
7137 }
7138
7139 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7140 s->SurfParameters[k].PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
7141 s->SurfParameters[k].DPPPerSurface = mode_lib->ms.NoOfDPP[j][k];
7142 s->SurfParameters[k].SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
7143 s->SurfParameters[k].ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
7144 s->SurfParameters[k].ViewportHeightChroma = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
7145 s->SurfParameters[k].BlockWidth256BytesY = mode_lib->ms.Read256BlockWidthY[k];
7146 s->SurfParameters[k].BlockHeight256BytesY = mode_lib->ms.Read256BlockHeightY[k];
7147 s->SurfParameters[k].BlockWidth256BytesC = mode_lib->ms.Read256BlockWidthC[k];
7148 s->SurfParameters[k].BlockHeight256BytesC = mode_lib->ms.Read256BlockHeightC[k];
7149 s->SurfParameters[k].BlockWidthY = mode_lib->ms.MacroTileWidthY[k];
7150 s->SurfParameters[k].BlockHeightY = mode_lib->ms.MacroTileHeightY[k];
7151 s->SurfParameters[k].BlockWidthC = mode_lib->ms.MacroTileWidthC[k];
7152 s->SurfParameters[k].BlockHeightC = mode_lib->ms.MacroTileHeightC[k];
7153 s->SurfParameters[k].InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
7154 s->SurfParameters[k].HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
7155 s->SurfParameters[k].DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
7156 s->SurfParameters[k].SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
7157 s->SurfParameters[k].SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k];
7158 s->SurfParameters[k].BytePerPixelY = mode_lib->ms.BytePerPixelY[k];
7159 s->SurfParameters[k].BytePerPixelC = mode_lib->ms.BytePerPixelC[k];
7160 s->SurfParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
7161 s->SurfParameters[k].VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio[k];
7162 s->SurfParameters[k].VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
7163 s->SurfParameters[k].VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps[k];
7164 s->SurfParameters[k].VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k];
7165 s->SurfParameters[k].PitchY = mode_lib->ms.cache_display_cfg.surface.PitchY[k];
7166 s->SurfParameters[k].DCCMetaPitchY = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
7167 s->SurfParameters[k].PitchC = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
7168 s->SurfParameters[k].DCCMetaPitchC = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
7169 s->SurfParameters[k].ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary[k];
7170 s->SurfParameters[k].ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart[k];
7171 s->SurfParameters[k].ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart[k];
7172 s->SurfParameters[k].ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC[k];
7173 s->SurfParameters[k].ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC[k];
7174 s->SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->ms.cache_display_cfg.plane.ForceOneRowForFrame[k];
7175 s->SurfParameters[k].SwathHeightY = mode_lib->ms.SwathHeightYThisState[k];
7176 s->SurfParameters[k].SwathHeightC = mode_lib->ms.SwathHeightCThisState[k];
7177 }
7178
7179 CalculateVMRowAndSwath_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7180 CalculateVMRowAndSwath_params->myPipe = s->SurfParameters;
7181 CalculateVMRowAndSwath_params->SurfaceSizeInMALL = mode_lib->ms.SurfaceSizeInMALL;
7182 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsLuma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_luma;
7183 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsChroma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_chroma;
7184 CalculateVMRowAndSwath_params->DCCMetaBufferSizeBytes = mode_lib->ms.ip.dcc_meta_buffer_size_bytes;
7185 CalculateVMRowAndSwath_params->UseMALLForStaticScreen = mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen;
7186 CalculateVMRowAndSwath_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7187 CalculateVMRowAndSwath_params->MALLAllocatedForDCN = mode_lib->ms.soc.mall_allocated_for_dcn_mbytes;
7188 CalculateVMRowAndSwath_params->SwathWidthY = mode_lib->ms.SwathWidthYThisState;
7189 CalculateVMRowAndSwath_params->SwathWidthC = mode_lib->ms.SwathWidthCThisState;
7190 CalculateVMRowAndSwath_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
7191 CalculateVMRowAndSwath_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
7192 CalculateVMRowAndSwath_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
7193 CalculateVMRowAndSwath_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
7194 CalculateVMRowAndSwath_params->GPUVMMinPageSizeKBytes = mode_lib->ms.cache_display_cfg.plane.GPUVMMinPageSizeKBytes;
7195 CalculateVMRowAndSwath_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes;
7196 CalculateVMRowAndSwath_params->PTEBufferModeOverrideEn = mode_lib->ms.cache_display_cfg.plane.PTEBufferModeOverrideEn;
7197 CalculateVMRowAndSwath_params->PTEBufferModeOverrideVal = mode_lib->ms.cache_display_cfg.plane.PTEBufferMode;
7198 CalculateVMRowAndSwath_params->PTEBufferSizeNotExceeded = mode_lib->ms.PTEBufferSizeNotExceededPerState;
7199 CalculateVMRowAndSwath_params->DCCMetaBufferSizeNotExceeded = mode_lib->ms.DCCMetaBufferSizeNotExceededPerState;
7200 CalculateVMRowAndSwath_params->dpte_row_width_luma_ub = s->dummy_integer_array[0];
7201 CalculateVMRowAndSwath_params->dpte_row_width_chroma_ub = s->dummy_integer_array[1];
7202 CalculateVMRowAndSwath_params->dpte_row_height_luma = mode_lib->ms.dpte_row_height;
7203 CalculateVMRowAndSwath_params->dpte_row_height_chroma = mode_lib->ms.dpte_row_height_chroma;
7204 CalculateVMRowAndSwath_params->dpte_row_height_linear_luma = s->dummy_integer_array[2]; // VBA_DELTA
7205 CalculateVMRowAndSwath_params->dpte_row_height_linear_chroma = s->dummy_integer_array[3]; // VBA_DELTA
7206 CalculateVMRowAndSwath_params->meta_req_width = s->dummy_integer_array[4];
7207 CalculateVMRowAndSwath_params->meta_req_width_chroma = s->dummy_integer_array[5];
7208 CalculateVMRowAndSwath_params->meta_req_height = s->dummy_integer_array[6];
7209 CalculateVMRowAndSwath_params->meta_req_height_chroma = s->dummy_integer_array[7];
7210 CalculateVMRowAndSwath_params->meta_row_width = s->dummy_integer_array[8];
7211 CalculateVMRowAndSwath_params->meta_row_width_chroma = s->dummy_integer_array[9];
7212 CalculateVMRowAndSwath_params->meta_row_height = mode_lib->ms.meta_row_height;
7213 CalculateVMRowAndSwath_params->meta_row_height_chroma = mode_lib->ms.meta_row_height_chroma;
7214 CalculateVMRowAndSwath_params->vm_group_bytes = s->dummy_integer_array[10];
7215 CalculateVMRowAndSwath_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
7216 CalculateVMRowAndSwath_params->PixelPTEReqWidthY = s->dummy_integer_array[11];
7217 CalculateVMRowAndSwath_params->PixelPTEReqHeightY = s->dummy_integer_array[12];
7218 CalculateVMRowAndSwath_params->PTERequestSizeY = s->dummy_integer_array[13];
7219 CalculateVMRowAndSwath_params->PixelPTEReqWidthC = s->dummy_integer_array[14];
7220 CalculateVMRowAndSwath_params->PixelPTEReqHeightC = s->dummy_integer_array[15];
7221 CalculateVMRowAndSwath_params->PTERequestSizeC = s->dummy_integer_array[16];
7222 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_l = s->dummy_integer_array[17];
7223 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_l = s->dummy_integer_array[18];
7224 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_c = s->dummy_integer_array[19];
7225 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_c = s->dummy_integer_array[20];
7226 CalculateVMRowAndSwath_params->PrefetchSourceLinesY = mode_lib->ms.PrefetchLinesYThisState;
7227 CalculateVMRowAndSwath_params->PrefetchSourceLinesC = mode_lib->ms.PrefetchLinesCThisState;
7228 CalculateVMRowAndSwath_params->VInitPreFillY = mode_lib->ms.PrefillY;
7229 CalculateVMRowAndSwath_params->VInitPreFillC = mode_lib->ms.PrefillC;
7230 CalculateVMRowAndSwath_params->MaxNumSwathY = mode_lib->ms.MaxNumSwY;
7231 CalculateVMRowAndSwath_params->MaxNumSwathC = mode_lib->ms.MaxNumSwC;
7232 CalculateVMRowAndSwath_params->meta_row_bw = mode_lib->ms.meta_row_bandwidth_this_state;
7233 CalculateVMRowAndSwath_params->dpte_row_bw = mode_lib->ms.dpte_row_bandwidth_this_state;
7234 CalculateVMRowAndSwath_params->PixelPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRowThisState;
7235 CalculateVMRowAndSwath_params->PDEAndMetaPTEBytesFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrameThisState;
7236 CalculateVMRowAndSwath_params->MetaRowByte = mode_lib->ms.MetaRowBytesThisState;
7237 CalculateVMRowAndSwath_params->use_one_row_for_frame = mode_lib->ms.use_one_row_for_frame_this_state;
7238 CalculateVMRowAndSwath_params->use_one_row_for_frame_flip = mode_lib->ms.use_one_row_for_frame_flip_this_state;
7239 CalculateVMRowAndSwath_params->UsesMALLForStaticScreen = s->dummy_boolean_array[0];
7240 CalculateVMRowAndSwath_params->PTE_BUFFER_MODE = s->dummy_boolean_array[1];
7241 CalculateVMRowAndSwath_params->BIGK_FRAGMENT_SIZE = s->dummy_integer_array[21];
7242
7243 CalculateVMRowAndSwath(&mode_lib->scratch,
7244 CalculateVMRowAndSwath_params);
7245
7246 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7247 mode_lib->ms.PrefetchLinesY[j][k] = mode_lib->ms.PrefetchLinesYThisState[k];
7248 mode_lib->ms.PrefetchLinesC[j][k] = mode_lib->ms.PrefetchLinesCThisState[k];
7249 mode_lib->ms.meta_row_bandwidth[j][k] = mode_lib->ms.meta_row_bandwidth_this_state[k];
7250 mode_lib->ms.dpte_row_bandwidth[j][k] = mode_lib->ms.dpte_row_bandwidth_this_state[k];
7251 mode_lib->ms.DPTEBytesPerRow[j][k] = mode_lib->ms.DPTEBytesPerRowThisState[k];
7252 mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k] = mode_lib->ms.PDEAndMetaPTEBytesPerFrameThisState[k];
7253 mode_lib->ms.MetaRowBytes[j][k] = mode_lib->ms.MetaRowBytesThisState[k];
7254 mode_lib->ms.use_one_row_for_frame[j][k] = mode_lib->ms.use_one_row_for_frame_this_state[k];
7255 mode_lib->ms.use_one_row_for_frame_flip[j][k] = mode_lib->ms.use_one_row_for_frame_flip_this_state[k];
7256 }
7257
7258 mode_lib->ms.support.PTEBufferSizeNotExceeded[j] = true;
7259
7260 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7261 if (mode_lib->ms.PTEBufferSizeNotExceededPerState[k] == false)
7262 mode_lib->ms.support.PTEBufferSizeNotExceeded[j] = false;
7263#ifdef __DML_VBA_DEBUG__
7264 dml_print("DML::%s: j=%u k=%u, PTEBufferSizeNotExceededPerState[%u] = %u\n", __func__, j, k, k, mode_lib->ms.PTEBufferSizeNotExceededPerState[k]);
7265#endif
7266 }
7267#ifdef __DML_VBA_DEBUG__
7268 dml_print("DML::%s: PTEBufferSizeNotExceeded[%u] = %u\n", __func__, j, mode_lib->ms.support.PTEBufferSizeNotExceeded[j]);
7269#endif
7270
7271 mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] = true;
7272 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7273 if (mode_lib->ms.DCCMetaBufferSizeNotExceededPerState[k] == false)
7274 mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] = false;
7275 }
7276
7277 mode_lib->ms.UrgLatency = CalculateUrgentLatency(mode_lib->ms.state.urgent_latency_pixel_data_only_us,
7278 mode_lib->ms.state.urgent_latency_pixel_mixed_with_vm_data_us,
7279 mode_lib->ms.state.urgent_latency_vm_data_only_us,
7280 mode_lib->ms.soc.do_urgent_latency_adjustment,
7281 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_component_us,
7282 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_reference_mhz,
7283 mode_lib->ms.state.fabricclk_mhz);
7284
7285 /* Getter functions work at mp interface so copy the urgent latency to mp*/
7286 mode_lib->mp.UrgentLatency = mode_lib->ms.UrgLatency;
7287
7288 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7289 CalculateUrgentBurstFactor(
7290 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
7291 mode_lib->ms.swath_width_luma_ub_this_state[k],
7292 mode_lib->ms.swath_width_chroma_ub_this_state[k],
7293 mode_lib->ms.SwathHeightYThisState[k],
7294 mode_lib->ms.SwathHeightCThisState[k],
7295 (dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7296 mode_lib->ms.UrgLatency,
7297 mode_lib->ms.ip.cursor_buffer_size,
7298 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
7299 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
7300 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
7301 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
7302 mode_lib->ms.BytePerPixelInDETY[k],
7303 mode_lib->ms.BytePerPixelInDETC[k],
7304 mode_lib->ms.DETBufferSizeYThisState[k],
7305 mode_lib->ms.DETBufferSizeCThisState[k],
7306 /* Output */
7307 &mode_lib->ms.UrgentBurstFactorCursor[k],
7308 &mode_lib->ms.UrgentBurstFactorLuma[k],
7309 &mode_lib->ms.UrgentBurstFactorChroma[k],
7310 &mode_lib->ms.NotUrgentLatencyHiding[k]);
7311 }
7312
7313 CalculateDCFCLKDeepSleep(
7314 mode_lib->ms.num_active_planes,
7315 mode_lib->ms.BytePerPixelY,
7316 mode_lib->ms.BytePerPixelC,
7317 mode_lib->ms.cache_display_cfg.plane.VRatio,
7318 mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
7319 mode_lib->ms.SwathWidthYThisState,
7320 mode_lib->ms.SwathWidthCThisState,
7321 mode_lib->ms.NoOfDPPThisState,
7322 mode_lib->ms.cache_display_cfg.plane.HRatio,
7323 mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
7324 mode_lib->ms.cache_display_cfg.timing.PixelClock,
7325 mode_lib->ms.PSCL_FACTOR,
7326 mode_lib->ms.PSCL_FACTOR_CHROMA,
7327 mode_lib->ms.RequiredDPPCLKThisState,
7328 mode_lib->ms.ReadBandwidthLuma,
7329 mode_lib->ms.ReadBandwidthChroma,
7330 mode_lib->ms.soc.return_bus_width_bytes,
7331
7332 /* Output */
7333 &mode_lib->ms.ProjectedDCFCLKDeepSleep[j]);
7334 }
7335
7336 //Calculate Return BW
7337 for (j = 0; j < 2; ++j) {
7338 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7339 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
7340 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
7341 mode_lib->ms.WritebackDelayTime[k] = mode_lib->ms.state.writeback_latency_us + CalculateWriteBackDelay(
7342 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
7343 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
7344 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
7345 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
7346 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
7347 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k],
7348 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k],
7349 mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / mode_lib->ms.RequiredDISPCLK[j];
7350 } else {
7351 mode_lib->ms.WritebackDelayTime[k] = 0.0;
7352 }
7353 for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
7354 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[m] == k && mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[m] == true) {
7355 mode_lib->ms.WritebackDelayTime[k] = dml_max(mode_lib->ms.WritebackDelayTime[k],
7356 mode_lib->ms.state.writeback_latency_us + CalculateWriteBackDelay(
7357 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[m],
7358 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[m],
7359 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[m],
7360 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[m],
7361 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[m],
7362 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[m],
7363 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[m],
7364 mode_lib->ms.cache_display_cfg.timing.HTotal[m]) / mode_lib->ms.RequiredDISPCLK[j]);
7365 }
7366 }
7367 }
7368 }
7369 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7370 for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
7371 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == m) {
7372 mode_lib->ms.WritebackDelayTime[k] = mode_lib->ms.WritebackDelayTime[m];
7373 }
7374 }
7375 }
7376 s->MaxVStartupAllPlanes[j] = 0; // max vstartup among all planes
7377
7378 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7379 s->MaximumVStartup[j][k] = CalculateMaxVStartup(k,
7380 mode_lib->ms.ip.ptoi_supported,
7381 mode_lib->ms.ip.vblank_nom_default_us,
7382 &mode_lib->ms.cache_display_cfg.timing,
7383 mode_lib->ms.WritebackDelayTime[k]);
7384
7385 s->MaxVStartupAllPlanes[j] = (dml_uint_t)(dml_max(s->MaxVStartupAllPlanes[j], s->MaximumVStartup[j][k]));
7386#ifdef __DML_VBA_DEBUG__
7387 dml_print("DML::%s: k=%u, MaxVStartupAllPlanes[%u] = %u\n", __func__, k, j, s->MaxVStartupAllPlanes[j]);
7388 dml_print("DML::%s: k=%u, MaximumVStartup[%u][%u] = %u\n", __func__, k, j, k, s->MaximumVStartup[j][k]);
7389#endif
7390 }
7391 }
7392
7393 s->ReorderingBytes = (dml_uint_t)(mode_lib->ms.soc.num_chans * dml_max3(mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_only_bytes,
7394 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes,
7395 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_vm_only_bytes));
7396
7397 for (j = 0; j < 2; ++j) {
7398 mode_lib->ms.DCFCLKState[j] = mode_lib->ms.state.dcfclk_mhz;
7399 }
7400
7401 /* Immediate Flip and MALL parameters */
7402 s->ImmediateFlipRequiredFinal = false;
7403 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7404 s->ImmediateFlipRequiredFinal = s->ImmediateFlipRequiredFinal || (mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
7405 }
7406
7407 mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
7408 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7409 mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified ||
7410 ((mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_required) &&
7411 (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required));
7412 }
7413 mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified && s->ImmediateFlipRequiredFinal;
7414
7415 mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
7416 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7417 mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
7418 mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe || ((mode_lib->ms.cache_display_cfg.plane.HostVMEnable == true || mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) &&
7419 (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame || mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe));
7420 }
7421
7422 mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
7423 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7424 mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen = mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen ||
7425 ((mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable || mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_optimize) && (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe)) ||
7426 ((mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_disable || mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_optimize) && (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame));
7427 }
7428
7429 s->FullFrameMALLPStateMethod = false;
7430 s->SubViewportMALLPStateMethod = false;
7431 s->PhantomPipeMALLPStateMethod = false;
7432 s->SubViewportMALLRefreshGreaterThan120Hz = false;
7433 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7434 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame)
7435 s->FullFrameMALLPStateMethod = true;
7436 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) {
7437 s->SubViewportMALLPStateMethod = true;
7438 if (mode_lib->ms.cache_display_cfg.timing.RefreshRate[k] > 120)
7439 s->SubViewportMALLRefreshGreaterThan120Hz = true;
7440 }
7441 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe)
7442 s->PhantomPipeMALLPStateMethod = true;
7443 }
7444 mode_lib->ms.support.InvalidCombinationOfMALLUseForPState = (s->SubViewportMALLPStateMethod != s->PhantomPipeMALLPStateMethod)
7445 || (s->SubViewportMALLPStateMethod && s->FullFrameMALLPStateMethod) || s->SubViewportMALLRefreshGreaterThan120Hz;
7446
7447 if (mode_lib->ms.policy.UseMinimumRequiredDCFCLK == true) {
7448 UseMinimumDCFCLK_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7449 UseMinimumDCFCLK_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
7450 UseMinimumDCFCLK_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
7451 UseMinimumDCFCLK_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
7452 UseMinimumDCFCLK_params->MaxPrefetchMode = dml_prefetch_support_stutter;
7453 UseMinimumDCFCLK_params->DRAMClockChangeLatencyFinal = mode_lib->ms.state.dram_clock_change_latency_us;
7454 UseMinimumDCFCLK_params->FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
7455 UseMinimumDCFCLK_params->SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
7456 UseMinimumDCFCLK_params->ReturnBusWidth = mode_lib->ms.soc.return_bus_width_bytes;
7457 UseMinimumDCFCLK_params->RoundTripPingLatencyCycles = mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles;
7458 UseMinimumDCFCLK_params->ReorderingBytes = s->ReorderingBytes;
7459 UseMinimumDCFCLK_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
7460 UseMinimumDCFCLK_params->MetaChunkSize = mode_lib->ms.ip.meta_chunk_size_kbytes;
7461 UseMinimumDCFCLK_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
7462 UseMinimumDCFCLK_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
7463 UseMinimumDCFCLK_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
7464 UseMinimumDCFCLK_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7465 UseMinimumDCFCLK_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes;
7466 UseMinimumDCFCLK_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
7467 UseMinimumDCFCLK_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
7468 UseMinimumDCFCLK_params->ImmediateFlipRequirement = s->ImmediateFlipRequiredFinal;
7469 UseMinimumDCFCLK_params->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
7470 UseMinimumDCFCLK_params->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation = mode_lib->ms.soc.max_avg_sdp_bw_use_normal_percent;
7471 UseMinimumDCFCLK_params->PercentOfIdealSDPPortBWReceivedAfterUrgLatency = mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent;
7472 UseMinimumDCFCLK_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
7473 UseMinimumDCFCLK_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
7474 UseMinimumDCFCLK_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes;
7475 UseMinimumDCFCLK_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired;
7476 UseMinimumDCFCLK_params->Interlace = mode_lib->ms.cache_display_cfg.timing.Interlace;
7477 UseMinimumDCFCLK_params->RequiredDPPCLKPerSurface = mode_lib->ms.RequiredDPPCLKPerSurface;
7478 UseMinimumDCFCLK_params->RequiredDISPCLK = mode_lib->ms.RequiredDISPCLK;
7479 UseMinimumDCFCLK_params->UrgLatency = mode_lib->ms.UrgLatency;
7480 UseMinimumDCFCLK_params->NoOfDPP = mode_lib->ms.NoOfDPP;
7481 UseMinimumDCFCLK_params->ProjectedDCFCLKDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep;
7482 UseMinimumDCFCLK_params->MaximumVStartup = s->MaximumVStartup;
7483 UseMinimumDCFCLK_params->TotalNumberOfActiveDPP = mode_lib->ms.TotalNumberOfActiveDPP;
7484 UseMinimumDCFCLK_params->TotalNumberOfDCCActiveDPP = mode_lib->ms.TotalNumberOfDCCActiveDPP;
7485 UseMinimumDCFCLK_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
7486 UseMinimumDCFCLK_params->PrefetchLinesY = mode_lib->ms.PrefetchLinesY;
7487 UseMinimumDCFCLK_params->PrefetchLinesC = mode_lib->ms.PrefetchLinesC;
7488 UseMinimumDCFCLK_params->swath_width_luma_ub_all_states = mode_lib->ms.swath_width_luma_ub_all_states;
7489 UseMinimumDCFCLK_params->swath_width_chroma_ub_all_states = mode_lib->ms.swath_width_chroma_ub_all_states;
7490 UseMinimumDCFCLK_params->BytePerPixelY = mode_lib->ms.BytePerPixelY;
7491 UseMinimumDCFCLK_params->BytePerPixelC = mode_lib->ms.BytePerPixelC;
7492 UseMinimumDCFCLK_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
7493 UseMinimumDCFCLK_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
7494 UseMinimumDCFCLK_params->PDEAndMetaPTEBytesPerFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrame;
7495 UseMinimumDCFCLK_params->DPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRow;
7496 UseMinimumDCFCLK_params->MetaRowBytes = mode_lib->ms.MetaRowBytes;
7497 UseMinimumDCFCLK_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable;
7498 UseMinimumDCFCLK_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
7499 UseMinimumDCFCLK_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
7500 UseMinimumDCFCLK_params->DCFCLKPerState = mode_lib->ms.state.dcfclk_mhz;
7501 UseMinimumDCFCLK_params->DCFCLKState = mode_lib->ms.DCFCLKState;
7502
7503 UseMinimumDCFCLK(&mode_lib->scratch,
7504 UseMinimumDCFCLK_params);
7505
7506 } // UseMinimumRequiredDCFCLK == true
7507
7508 for (j = 0; j < 2; ++j) {
7509 mode_lib->ms.ReturnBWPerState[j] = dml_get_return_bw_mbps(&mode_lib->ms.soc, mode_lib->ms.state.use_ideal_dram_bw_strobe,
7510 mode_lib->ms.cache_display_cfg.plane.HostVMEnable, mode_lib->ms.DCFCLKState[j], mode_lib->ms.state.fabricclk_mhz,
7511 mode_lib->ms.state.dram_speed_mts);
7512 mode_lib->ms.ReturnDRAMBWPerState[j] = dml_get_return_dram_bw_mbps(&mode_lib->ms.soc, mode_lib->ms.state.use_ideal_dram_bw_strobe,
7513 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
7514 mode_lib->ms.state.dram_speed_mts);
7515 }
7516
7517 //Re-ordering Buffer Support Check
7518 for (j = 0; j < 2; ++j) {
7519 if ((mode_lib->ms.ip.rob_buffer_size_kbytes - mode_lib->ms.ip.pixel_chunk_size_kbytes) * 1024 / mode_lib->ms.ReturnBWPerState[j] >
7520 (mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles + 32) / mode_lib->ms.DCFCLKState[j] + s->ReorderingBytes / mode_lib->ms.ReturnBWPerState[j]) {
7521 mode_lib->ms.support.ROBSupport[j] = true;
7522 } else {
7523 mode_lib->ms.support.ROBSupport[j] = false;
7524 }
7525 dml_print("DML::%s: DEBUG ROBSupport[%u] = %u (%u)\n", __func__, j, mode_lib->ms.support.ROBSupport[j], __LINE__);
7526 }
7527
7528 //Vertical Active BW support check
7529 s->MaxTotalVActiveRDBandwidth = 0;
7530 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7531 s->MaxTotalVActiveRDBandwidth = s->MaxTotalVActiveRDBandwidth + mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k];
7532 }
7533
7534 for (j = 0; j < 2; ++j) {
7535 mode_lib->ms.support.MaxTotalVerticalActiveAvailableBandwidth[j] = dml_min3(mode_lib->ms.soc.return_bus_width_bytes * mode_lib->ms.DCFCLKState[j] * mode_lib->ms.soc.max_avg_sdp_bw_use_normal_percent / 100.0,
7536 mode_lib->ms.state.fabricclk_mhz * mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes * mode_lib->ms.soc.max_avg_fabric_bw_use_normal_percent / 100.0,
7537 mode_lib->ms.state.dram_speed_mts * mode_lib->ms.soc.num_chans * mode_lib->ms.soc.dram_channel_width_bytes *
7538 ((mode_lib->ms.state.use_ideal_dram_bw_strobe && !mode_lib->ms.cache_display_cfg.plane.HostVMEnable) ?
7539 mode_lib->ms.soc.max_avg_dram_bw_use_normal_strobe_percent : mode_lib->ms.soc.max_avg_dram_bw_use_normal_percent) / 100.0);
7540
7541 if (s->MaxTotalVActiveRDBandwidth <= mode_lib->ms.support.MaxTotalVerticalActiveAvailableBandwidth[j]) {
7542 mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] = true;
7543 } else {
7544 mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] = false;
7545 }
7546 }
7547
7548 /* Prefetch Check */
7549
7550 for (j = 0; j < 2; ++j) {
7551 mode_lib->ms.TimeCalc = 24 / mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
7552
7553 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7554 mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
7555 mode_lib->ms.swath_width_luma_ub_this_state[k] = mode_lib->ms.swath_width_luma_ub_all_states[j][k];
7556 mode_lib->ms.swath_width_chroma_ub_this_state[k] = mode_lib->ms.swath_width_chroma_ub_all_states[j][k];
7557 mode_lib->ms.SwathWidthYThisState[k] = mode_lib->ms.SwathWidthYAllStates[j][k];
7558 mode_lib->ms.SwathWidthCThisState[k] = mode_lib->ms.SwathWidthCAllStates[j][k];
7559 mode_lib->ms.SwathHeightYThisState[k] = mode_lib->ms.SwathHeightYAllStates[j][k];
7560 mode_lib->ms.SwathHeightCThisState[k] = mode_lib->ms.SwathHeightCAllStates[j][k];
7561 mode_lib->ms.UnboundedRequestEnabledThisState = mode_lib->ms.UnboundedRequestEnabledAllStates[j];
7562 mode_lib->ms.CompressedBufferSizeInkByteThisState = mode_lib->ms.CompressedBufferSizeInkByteAllStates[j];
7563 mode_lib->ms.DETBufferSizeInKByteThisState[k] = mode_lib->ms.DETBufferSizeInKByteAllStates[j][k];
7564 mode_lib->ms.DETBufferSizeYThisState[k] = mode_lib->ms.DETBufferSizeYAllStates[j][k];
7565 mode_lib->ms.DETBufferSizeCThisState[k] = mode_lib->ms.DETBufferSizeCAllStates[j][k];
7566 }
7567
7568 mode_lib->ms.support.VActiveBandwithSupport[j] = CalculateVActiveBandwithSupport(
7569 mode_lib->ms.num_active_planes,
7570 mode_lib->ms.ReturnBWPerState[j],
7571 mode_lib->ms.NotUrgentLatencyHiding,
7572 mode_lib->ms.ReadBandwidthLuma,
7573 mode_lib->ms.ReadBandwidthChroma,
7574 mode_lib->ms.cursor_bw,
7575 mode_lib->ms.meta_row_bandwidth_this_state,
7576 mode_lib->ms.dpte_row_bandwidth_this_state,
7577 mode_lib->ms.NoOfDPPThisState,
7578 mode_lib->ms.UrgentBurstFactorLuma,
7579 mode_lib->ms.UrgentBurstFactorChroma,
7580 mode_lib->ms.UrgentBurstFactorCursor);
7581
7582 s->VMDataOnlyReturnBWPerState = dml_get_return_bw_mbps_vm_only(
7583 &mode_lib->ms.soc,
7584 mode_lib->ms.state.use_ideal_dram_bw_strobe,
7585 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
7586 mode_lib->ms.DCFCLKState[j],
7587 mode_lib->ms.state.fabricclk_mhz,
7588 mode_lib->ms.state.dram_speed_mts);
7589
7590 s->HostVMInefficiencyFactor = 1;
7591 if (mode_lib->ms.cache_display_cfg.plane.GPUVMEnable && mode_lib->ms.cache_display_cfg.plane.HostVMEnable)
7592 s->HostVMInefficiencyFactor = mode_lib->ms.ReturnBWPerState[j] / s->VMDataOnlyReturnBWPerState;
7593
7594 mode_lib->ms.ExtraLatency = CalculateExtraLatency(
7595 mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles,
7596 s->ReorderingBytes,
7597 mode_lib->ms.DCFCLKState[j],
7598 mode_lib->ms.TotalNumberOfActiveDPP[j],
7599 mode_lib->ms.ip.pixel_chunk_size_kbytes,
7600 mode_lib->ms.TotalNumberOfDCCActiveDPP[j],
7601 mode_lib->ms.ip.meta_chunk_size_kbytes,
7602 mode_lib->ms.ReturnBWPerState[j],
7603 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
7604 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
7605 mode_lib->ms.num_active_planes,
7606 mode_lib->ms.NoOfDPPThisState,
7607 mode_lib->ms.dpte_group_bytes,
7608 s->HostVMInefficiencyFactor,
7609 mode_lib->ms.soc.hostvm_min_page_size_kbytes,
7610 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels);
7611
7612 s->NextMaxVStartup = s->MaxVStartupAllPlanes[j];
7613 s->MaxVStartup = 0;
7614 s->AllPrefetchModeTested = true;
7615 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7616 CalculatePrefetchMode(mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k], &s->MinPrefetchMode[k], &s->MaxPrefetchMode[k]);
7617 s->NextPrefetchMode[k] = s->MinPrefetchMode[k];
7618 }
7619
7620 do {
7621 s->MaxVStartup = s->NextMaxVStartup;
7622 s->AllPrefetchModeTested = true;
7623
7624 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7625 mode_lib->ms.PrefetchMode[k] = s->NextPrefetchMode[k];
7626 mode_lib->ms.TWait = CalculateTWait(
7627 mode_lib->ms.PrefetchMode[k],
7628 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
7629 mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
7630 mode_lib->ms.cache_display_cfg.timing.DRRDisplay[k],
7631 mode_lib->ms.state.dram_clock_change_latency_us,
7632 mode_lib->ms.state.fclk_change_latency_us,
7633 mode_lib->ms.UrgLatency,
7634 mode_lib->ms.state.sr_enter_plus_exit_time_us);
7635
7636 myPipe = &s->myPipe;
7637 myPipe->Dppclk = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
7638 myPipe->Dispclk = mode_lib->ms.RequiredDISPCLK[j];
7639 myPipe->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
7640 myPipe->DCFClkDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
7641 myPipe->DPPPerSurface = mode_lib->ms.NoOfDPP[j][k];
7642 myPipe->ScalerEnabled = mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k];
7643 myPipe->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
7644 myPipe->BlockWidth256BytesY = mode_lib->ms.Read256BlockWidthY[k];
7645 myPipe->BlockHeight256BytesY = mode_lib->ms.Read256BlockHeightY[k];
7646 myPipe->BlockWidth256BytesC = mode_lib->ms.Read256BlockWidthC[k];
7647 myPipe->BlockHeight256BytesC = mode_lib->ms.Read256BlockHeightC[k];
7648 myPipe->InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
7649 myPipe->NumberOfCursors = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k];
7650 myPipe->VBlank = mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k];
7651 myPipe->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
7652 myPipe->HActive = mode_lib->ms.cache_display_cfg.timing.HActive[k];
7653 myPipe->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
7654 myPipe->ODMMode = mode_lib->ms.ODMModePerState[k];
7655 myPipe->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
7656 myPipe->BytePerPixelY = mode_lib->ms.BytePerPixelY[k];
7657 myPipe->BytePerPixelC = mode_lib->ms.BytePerPixelC[k];
7658 myPipe->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
7659
7660#ifdef __DML_VBA_DEBUG__
7661 dml_print("DML::%s: Calling CalculatePrefetchSchedule for j=%u, k=%u\n", __func__, j, k);
7662 dml_print("DML::%s: MaximumVStartup = %u\n", __func__, s->MaximumVStartup[j][k]);
7663 dml_print("DML::%s: MaxVStartup = %u\n", __func__, s->MaxVStartup);
7664 dml_print("DML::%s: NextPrefetchMode = %u\n", __func__, s->NextPrefetchMode[k]);
7665 dml_print("DML::%s: AllowForPStateChangeOrStutterInVBlank = %u\n", __func__, mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k]);
7666 dml_print("DML::%s: PrefetchMode = %u\n", __func__, mode_lib->ms.PrefetchMode[k]);
7667#endif
7668
7669 CalculatePrefetchSchedule_params->EnhancedPrefetchScheduleAccelerationFinal = mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal;
7670 CalculatePrefetchSchedule_params->HostVMInefficiencyFactor = s->HostVMInefficiencyFactor;
7671 CalculatePrefetchSchedule_params->myPipe = myPipe;
7672 CalculatePrefetchSchedule_params->DSCDelay = mode_lib->ms.DSCDelayPerState[k];
7673 CalculatePrefetchSchedule_params->DPPCLKDelaySubtotalPlusCNVCFormater = mode_lib->ms.ip.dppclk_delay_subtotal + mode_lib->ms.ip.dppclk_delay_cnvc_formatter;
7674 CalculatePrefetchSchedule_params->DPPCLKDelaySCL = mode_lib->ms.ip.dppclk_delay_scl;
7675 CalculatePrefetchSchedule_params->DPPCLKDelaySCLLBOnly = mode_lib->ms.ip.dppclk_delay_scl_lb_only;
7676 CalculatePrefetchSchedule_params->DPPCLKDelayCNVCCursor = mode_lib->ms.ip.dppclk_delay_cnvc_cursor;
7677 CalculatePrefetchSchedule_params->DISPCLKDelaySubtotal = mode_lib->ms.ip.dispclk_delay_subtotal;
7678 CalculatePrefetchSchedule_params->DPP_RECOUT_WIDTH = (dml_uint_t)(mode_lib->ms.SwathWidthYThisState[k] / mode_lib->ms.cache_display_cfg.plane.HRatio[k]);
7679 CalculatePrefetchSchedule_params->OutputFormat = mode_lib->ms.cache_display_cfg.output.OutputFormat[k];
7680 CalculatePrefetchSchedule_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
7681 CalculatePrefetchSchedule_params->VStartup = (dml_uint_t)(dml_min(s->MaxVStartup, s->MaximumVStartup[j][k]));
7682 CalculatePrefetchSchedule_params->MaxVStartup = s->MaximumVStartup[j][k];
7683 CalculatePrefetchSchedule_params->GPUVMPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
7684 CalculatePrefetchSchedule_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
7685 CalculatePrefetchSchedule_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
7686 CalculatePrefetchSchedule_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
7687 CalculatePrefetchSchedule_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes;
7688 CalculatePrefetchSchedule_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k];
7689 CalculatePrefetchSchedule_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
7690 CalculatePrefetchSchedule_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired[k];
7691 CalculatePrefetchSchedule_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes[k];
7692 CalculatePrefetchSchedule_params->UrgentLatency = mode_lib->ms.UrgLatency;
7693 CalculatePrefetchSchedule_params->UrgentExtraLatency = mode_lib->ms.ExtraLatency;
7694 CalculatePrefetchSchedule_params->TCalc = mode_lib->ms.TimeCalc;
7695 CalculatePrefetchSchedule_params->PDEAndMetaPTEBytesFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k];
7696 CalculatePrefetchSchedule_params->MetaRowByte = mode_lib->ms.MetaRowBytes[j][k];
7697 CalculatePrefetchSchedule_params->PixelPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRow[j][k];
7698 CalculatePrefetchSchedule_params->PrefetchSourceLinesY = mode_lib->ms.PrefetchLinesY[j][k];
7699 CalculatePrefetchSchedule_params->VInitPreFillY = mode_lib->ms.PrefillY[k];
7700 CalculatePrefetchSchedule_params->MaxNumSwathY = mode_lib->ms.MaxNumSwY[k];
7701 CalculatePrefetchSchedule_params->PrefetchSourceLinesC = mode_lib->ms.PrefetchLinesC[j][k];
7702 CalculatePrefetchSchedule_params->VInitPreFillC = mode_lib->ms.PrefillC[k];
7703 CalculatePrefetchSchedule_params->MaxNumSwathC = mode_lib->ms.MaxNumSwC[k];
7704 CalculatePrefetchSchedule_params->swath_width_luma_ub = mode_lib->ms.swath_width_luma_ub_this_state[k];
7705 CalculatePrefetchSchedule_params->swath_width_chroma_ub = mode_lib->ms.swath_width_chroma_ub_this_state[k];
7706 CalculatePrefetchSchedule_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState[k];
7707 CalculatePrefetchSchedule_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState[k];
7708 CalculatePrefetchSchedule_params->TWait = mode_lib->ms.TWait;
7709 CalculatePrefetchSchedule_params->DSTXAfterScaler = &s->DSTXAfterScaler[k];
7710 CalculatePrefetchSchedule_params->DSTYAfterScaler = &s->DSTYAfterScaler[k];
7711 CalculatePrefetchSchedule_params->DestinationLinesForPrefetch = &mode_lib->ms.LineTimesForPrefetch[k];
7712 CalculatePrefetchSchedule_params->DestinationLinesToRequestVMInVBlank = &mode_lib->ms.LinesForMetaPTE[k];
7713 CalculatePrefetchSchedule_params->DestinationLinesToRequestRowInVBlank = &mode_lib->ms.LinesForMetaAndDPTERow[k];
7714 CalculatePrefetchSchedule_params->VRatioPrefetchY = &mode_lib->ms.VRatioPreY[j][k];
7715 CalculatePrefetchSchedule_params->VRatioPrefetchC = &mode_lib->ms.VRatioPreC[j][k];
7716 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWLuma = &mode_lib->ms.RequiredPrefetchPixelDataBWLuma[k];
7717 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWChroma = &mode_lib->ms.RequiredPrefetchPixelDataBWChroma[k];
7718 CalculatePrefetchSchedule_params->NotEnoughTimeForDynamicMetadata = &mode_lib->ms.support.NoTimeForDynamicMetadata[j][k];
7719 CalculatePrefetchSchedule_params->Tno_bw = &mode_lib->ms.Tno_bw[k];
7720 CalculatePrefetchSchedule_params->prefetch_vmrow_bw = &mode_lib->ms.prefetch_vmrow_bw[k];
7721 CalculatePrefetchSchedule_params->Tdmdl_vm = &s->dummy_single[0];
7722 CalculatePrefetchSchedule_params->Tdmdl = &s->dummy_single[1];
7723 CalculatePrefetchSchedule_params->TSetup = &s->dummy_single[2];
7724 CalculatePrefetchSchedule_params->VUpdateOffsetPix = &s->dummy_integer[0];
7725 CalculatePrefetchSchedule_params->VUpdateWidthPix = &s->dummy_integer[1];
7726 CalculatePrefetchSchedule_params->VReadyOffsetPix = &s->dummy_integer[2];
7727
7728 mode_lib->ms.support.NoTimeForPrefetch[j][k] =
7729 CalculatePrefetchSchedule(&mode_lib->scratch,
7730 CalculatePrefetchSchedule_params);
7731 }
7732
7733 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7734 CalculateUrgentBurstFactor(
7735 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
7736 mode_lib->ms.swath_width_luma_ub_this_state[k],
7737 mode_lib->ms.swath_width_chroma_ub_this_state[k],
7738 mode_lib->ms.SwathHeightYThisState[k],
7739 mode_lib->ms.SwathHeightCThisState[k],
7740 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7741 mode_lib->ms.UrgLatency,
7742 mode_lib->ms.ip.cursor_buffer_size,
7743 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
7744 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
7745 mode_lib->ms.VRatioPreY[j][k],
7746 mode_lib->ms.VRatioPreC[j][k],
7747 mode_lib->ms.BytePerPixelInDETY[k],
7748 mode_lib->ms.BytePerPixelInDETC[k],
7749 mode_lib->ms.DETBufferSizeYThisState[k],
7750 mode_lib->ms.DETBufferSizeCThisState[k],
7751 /* Output */
7752 &mode_lib->ms.UrgentBurstFactorCursorPre[k],
7753 &mode_lib->ms.UrgentBurstFactorLumaPre[k],
7754 &mode_lib->ms.UrgentBurstFactorChroma[k],
7755 &mode_lib->ms.NotUrgentLatencyHidingPre[k]);
7756
7757 mode_lib->ms.cursor_bw_pre[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] *
7758 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
7759 mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.VRatioPreY[j][k];
7760 }
7761
7762 {
7763 CalculatePrefetchBandwithSupport(
7764 mode_lib->ms.num_active_planes,
7765 mode_lib->ms.ReturnBWPerState[j],
7766 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
7767 mode_lib->ms.NotUrgentLatencyHidingPre,
7768 mode_lib->ms.ReadBandwidthLuma,
7769 mode_lib->ms.ReadBandwidthChroma,
7770 mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
7771 mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
7772 mode_lib->ms.cursor_bw,
7773 mode_lib->ms.meta_row_bandwidth_this_state,
7774 mode_lib->ms.dpte_row_bandwidth_this_state,
7775 mode_lib->ms.cursor_bw_pre,
7776 mode_lib->ms.prefetch_vmrow_bw,
7777 mode_lib->ms.NoOfDPPThisState,
7778 mode_lib->ms.UrgentBurstFactorLuma,
7779 mode_lib->ms.UrgentBurstFactorChroma,
7780 mode_lib->ms.UrgentBurstFactorCursor,
7781 mode_lib->ms.UrgentBurstFactorLumaPre,
7782 mode_lib->ms.UrgentBurstFactorChromaPre,
7783 mode_lib->ms.UrgentBurstFactorCursorPre,
7784
7785 /* output */
7786 &s->dummy_single[0], // dml_float_t *PrefetchBandwidth
7787 &s->dummy_single[1], // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
7788 &mode_lib->mp.FractionOfUrgentBandwidth, // dml_float_t *FractionOfUrgentBandwidth
7789 &mode_lib->ms.support.PrefetchSupported[j]);
7790 }
7791
7792 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7793 if (mode_lib->ms.LineTimesForPrefetch[k] < 2.0
7794 || mode_lib->ms.LinesForMetaPTE[k] >= 32.0
7795 || mode_lib->ms.LinesForMetaAndDPTERow[k] >= 16.0
7796 || mode_lib->ms.support.NoTimeForPrefetch[j][k] == true) {
7797 mode_lib->ms.support.PrefetchSupported[j] = false;
7798 }
7799 }
7800
7801 mode_lib->ms.support.DynamicMetadataSupported[j] = true;
7802 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7803 if (mode_lib->ms.support.NoTimeForDynamicMetadata[j][k] == true) {
7804 mode_lib->ms.support.DynamicMetadataSupported[j] = false;
7805 }
7806 }
7807
7808 mode_lib->ms.support.VRatioInPrefetchSupported[j] = true;
7809 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7810 if (mode_lib->ms.support.NoTimeForPrefetch[j][k] == true ||
7811 mode_lib->ms.VRatioPreY[j][k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
7812 mode_lib->ms.VRatioPreC[j][k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
7813 ((s->MaxVStartup < s->MaximumVStartup[j][k] || mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal == 0) &&
7814 (mode_lib->ms.VRatioPreY[j][k] > __DML_MAX_VRATIO_PRE__ || mode_lib->ms.VRatioPreC[j][k] > __DML_MAX_VRATIO_PRE__))) {
7815 mode_lib->ms.support.VRatioInPrefetchSupported[j] = false;
7816 }
7817 }
7818
7819 s->AnyLinesForVMOrRowTooLarge = false;
7820 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7821 if (mode_lib->ms.LinesForMetaAndDPTERow[k] >= 16 || mode_lib->ms.LinesForMetaPTE[k] >= 32) {
7822 s->AnyLinesForVMOrRowTooLarge = true;
7823 }
7824 }
7825
7826 if (mode_lib->ms.support.PrefetchSupported[j] == true && mode_lib->ms.support.VRatioInPrefetchSupported[j] == true) {
7827 mode_lib->ms.BandwidthAvailableForImmediateFlip = CalculateBandwidthAvailableForImmediateFlip(
7828 mode_lib->ms.num_active_planes,
7829 mode_lib->ms.ReturnBWPerState[j],
7830 mode_lib->ms.ReadBandwidthLuma,
7831 mode_lib->ms.ReadBandwidthChroma,
7832 mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
7833 mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
7834 mode_lib->ms.cursor_bw,
7835 mode_lib->ms.cursor_bw_pre,
7836 mode_lib->ms.NoOfDPPThisState,
7837 mode_lib->ms.UrgentBurstFactorLuma,
7838 mode_lib->ms.UrgentBurstFactorChroma,
7839 mode_lib->ms.UrgentBurstFactorCursor,
7840 mode_lib->ms.UrgentBurstFactorLumaPre,
7841 mode_lib->ms.UrgentBurstFactorChromaPre,
7842 mode_lib->ms.UrgentBurstFactorCursorPre);
7843
7844 mode_lib->ms.TotImmediateFlipBytes = 0;
7845 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7846 if (!(mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_not_required)) {
7847 mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k] + mode_lib->ms.MetaRowBytes[j][k];
7848 if (mode_lib->ms.use_one_row_for_frame_flip[j][k]) {
7849 mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * (2 * mode_lib->ms.DPTEBytesPerRow[j][k]);
7850 } else {
7851 mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * mode_lib->ms.DPTEBytesPerRow[j][k];
7852 }
7853 }
7854 }
7855
7856 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7857 CalculateFlipSchedule(
7858 s->HostVMInefficiencyFactor,
7859 mode_lib->ms.ExtraLatency,
7860 mode_lib->ms.UrgLatency,
7861 mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
7862 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
7863 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels,
7864 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
7865 mode_lib->ms.soc.hostvm_min_page_size_kbytes,
7866 mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k],
7867 mode_lib->ms.MetaRowBytes[j][k],
7868 mode_lib->ms.DPTEBytesPerRow[j][k],
7869 mode_lib->ms.BandwidthAvailableForImmediateFlip,
7870 mode_lib->ms.TotImmediateFlipBytes,
7871 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
7872 (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]),
7873 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
7874 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
7875 mode_lib->ms.Tno_bw[k],
7876 mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
7877 mode_lib->ms.dpte_row_height[k],
7878 mode_lib->ms.meta_row_height[k],
7879 mode_lib->ms.dpte_row_height_chroma[k],
7880 mode_lib->ms.meta_row_height_chroma[k],
7881 mode_lib->ms.use_one_row_for_frame_flip[j][k], // 24
7882
7883 /* Output */
7884 &mode_lib->ms.DestinationLinesToRequestVMInImmediateFlip[k],
7885 &mode_lib->ms.DestinationLinesToRequestRowInImmediateFlip[k],
7886 &mode_lib->ms.final_flip_bw[k],
7887 &mode_lib->ms.ImmediateFlipSupportedForPipe[k]);
7888 }
7889
7890 {
7891 CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
7892 mode_lib->ms.ReturnBWPerState[j],
7893 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
7894 mode_lib->ms.policy.ImmediateFlipRequirement,
7895 mode_lib->ms.final_flip_bw,
7896 mode_lib->ms.ReadBandwidthLuma,
7897 mode_lib->ms.ReadBandwidthChroma,
7898 mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
7899 mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
7900 mode_lib->ms.cursor_bw,
7901 mode_lib->ms.meta_row_bandwidth_this_state,
7902 mode_lib->ms.dpte_row_bandwidth_this_state,
7903 mode_lib->ms.cursor_bw_pre,
7904 mode_lib->ms.prefetch_vmrow_bw,
7905 mode_lib->ms.NoOfDPP[j], // VBA_ERROR DPPPerSurface is not assigned at this point, should use NoOfDpp here
7906 mode_lib->ms.UrgentBurstFactorLuma,
7907 mode_lib->ms.UrgentBurstFactorChroma,
7908 mode_lib->ms.UrgentBurstFactorCursor,
7909 mode_lib->ms.UrgentBurstFactorLumaPre,
7910 mode_lib->ms.UrgentBurstFactorChromaPre,
7911 mode_lib->ms.UrgentBurstFactorCursorPre,
7912
7913 /* output */
7914 &s->dummy_single[0], // dml_float_t *TotalBandwidth
7915 &s->dummy_single[1], // dml_float_t *TotalBandwidthNotIncludingMALLPrefetch
7916 &s->dummy_single[2], // dml_float_t *FractionOfUrgentBandwidth
7917 &mode_lib->ms.support.ImmediateFlipSupportedForState[j]); // dml_bool_t *ImmediateFlipBandwidthSupport
7918 }
7919
7920 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7921 if (!(mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_not_required) && (mode_lib->ms.ImmediateFlipSupportedForPipe[k] == false))
7922 mode_lib->ms.support.ImmediateFlipSupportedForState[j] = false;
7923 }
7924
7925 } else { // if prefetch not support, assume iflip not supported
7926 mode_lib->ms.support.ImmediateFlipSupportedForState[j] = false;
7927 }
7928
7929 if (s->MaxVStartup <= __DML_VBA_MIN_VSTARTUP__ || s->AnyLinesForVMOrRowTooLarge == false) {
7930 s->NextMaxVStartup = s->MaxVStartupAllPlanes[j];
7931 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7932 s->NextPrefetchMode[k] = s->NextPrefetchMode[k] + 1;
7933
7934 if (s->NextPrefetchMode[k] <= s->MaxPrefetchMode[k])
7935 s->AllPrefetchModeTested = false;
7936 }
7937 } else {
7938 s->NextMaxVStartup = s->NextMaxVStartup - 1;
7939 }
7940 } while (!((mode_lib->ms.support.PrefetchSupported[j] == true && mode_lib->ms.support.DynamicMetadataSupported[j] == true &&
7941 mode_lib->ms.support.VRatioInPrefetchSupported[j] == true &&
7942 // consider flip support is okay if when there is no hostvm and the user does't require a iflip OR the flip bw is ok
7943 // If there is hostvm, DCN needs to support iflip for invalidation
7944 ((s->ImmediateFlipRequiredFinal) || mode_lib->ms.support.ImmediateFlipSupportedForState[j] == true)) ||
7945 (s->NextMaxVStartup == s->MaxVStartupAllPlanes[j] && s->AllPrefetchModeTested)));
7946
7947 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7948 mode_lib->ms.use_one_row_for_frame_this_state[k] = mode_lib->ms.use_one_row_for_frame[j][k];
7949 }
7950
7951 s->mSOCParameters.UrgentLatency = mode_lib->ms.UrgLatency;
7952 s->mSOCParameters.ExtraLatency = mode_lib->ms.ExtraLatency;
7953 s->mSOCParameters.WritebackLatency = mode_lib->ms.state.writeback_latency_us;
7954 s->mSOCParameters.DRAMClockChangeLatency = mode_lib->ms.state.dram_clock_change_latency_us;
7955 s->mSOCParameters.FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
7956 s->mSOCParameters.SRExitTime = mode_lib->ms.state.sr_exit_time_us;
7957 s->mSOCParameters.SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
7958 s->mSOCParameters.SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
7959 s->mSOCParameters.SREnterPlusExitZ8Time = mode_lib->ms.state.sr_enter_plus_exit_z8_time_us;
7960 s->mSOCParameters.USRRetrainingLatency = mode_lib->ms.state.usr_retraining_latency_us;
7961 s->mSOCParameters.SMNLatency = mode_lib->ms.soc.smn_latency_us;
7962
7963 CalculateWatermarks_params->USRRetrainingRequiredFinal = mode_lib->ms.policy.USRRetrainingRequiredFinal;
7964 CalculateWatermarks_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7965 CalculateWatermarks_params->PrefetchMode = mode_lib->ms.PrefetchMode;
7966 CalculateWatermarks_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7967 CalculateWatermarks_params->MaxLineBufferLines = mode_lib->ms.ip.max_line_buffer_lines;
7968 CalculateWatermarks_params->LineBufferSize = mode_lib->ms.ip.line_buffer_size_bits;
7969 CalculateWatermarks_params->WritebackInterfaceBufferSize = mode_lib->ms.ip.writeback_interface_buffer_size_kbytes;
7970 CalculateWatermarks_params->DCFCLK = mode_lib->ms.DCFCLKState[j];
7971 CalculateWatermarks_params->ReturnBW = mode_lib->ms.ReturnBWPerState[j];
7972 CalculateWatermarks_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
7973 CalculateWatermarks_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
7974 CalculateWatermarks_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
7975 CalculateWatermarks_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
7976 CalculateWatermarks_params->meta_row_height = mode_lib->ms.meta_row_height;
7977 CalculateWatermarks_params->meta_row_height_chroma = mode_lib->ms.meta_row_height_chroma;
7978 CalculateWatermarks_params->mmSOCParameters = s->mSOCParameters;
7979 CalculateWatermarks_params->WritebackChunkSize = mode_lib->ms.ip.writeback_chunk_size_kbytes;
7980 CalculateWatermarks_params->SOCCLK = mode_lib->ms.state.socclk_mhz;
7981 CalculateWatermarks_params->DCFClkDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
7982 CalculateWatermarks_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeYThisState;
7983 CalculateWatermarks_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeCThisState;
7984 CalculateWatermarks_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState;
7985 CalculateWatermarks_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState;
7986 CalculateWatermarks_params->LBBitPerPixel = mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel;
7987 CalculateWatermarks_params->SwathWidthY = mode_lib->ms.SwathWidthYThisState;
7988 CalculateWatermarks_params->SwathWidthC = mode_lib->ms.SwathWidthCThisState;
7989 CalculateWatermarks_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
7990 CalculateWatermarks_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
7991 CalculateWatermarks_params->VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps;
7992 CalculateWatermarks_params->VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma;
7993 CalculateWatermarks_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
7994 CalculateWatermarks_params->VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma;
7995 CalculateWatermarks_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
7996 CalculateWatermarks_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
7997 CalculateWatermarks_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
7998 CalculateWatermarks_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
7999 CalculateWatermarks_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
8000 CalculateWatermarks_params->DPPPerSurface = mode_lib->ms.NoOfDPPThisState;
8001 CalculateWatermarks_params->BytePerPixelDETY = mode_lib->ms.BytePerPixelInDETY;
8002 CalculateWatermarks_params->BytePerPixelDETC = mode_lib->ms.BytePerPixelInDETC;
8003 CalculateWatermarks_params->DSTXAfterScaler = s->DSTXAfterScaler;
8004 CalculateWatermarks_params->DSTYAfterScaler = s->DSTYAfterScaler;
8005 CalculateWatermarks_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
8006 CalculateWatermarks_params->WritebackPixelFormat = mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat;
8007 CalculateWatermarks_params->WritebackDestinationWidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth;
8008 CalculateWatermarks_params->WritebackDestinationHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight;
8009 CalculateWatermarks_params->WritebackSourceHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight;
8010 CalculateWatermarks_params->UnboundedRequestEnabled = mode_lib->ms.UnboundedRequestEnabledThisState;
8011 CalculateWatermarks_params->CompressedBufferSizeInkByte = mode_lib->ms.CompressedBufferSizeInkByteThisState;
8012
8013 // Output
8014 CalculateWatermarks_params->Watermark = &s->dummy_watermark; // Watermarks *Watermark
8015 CalculateWatermarks_params->DRAMClockChangeSupport = &mode_lib->ms.support.DRAMClockChangeSupport[j];
8016 CalculateWatermarks_params->MaxActiveDRAMClockChangeLatencySupported = &s->dummy_single_array[0]; // dml_float_t *MaxActiveDRAMClockChangeLatencySupported[]
8017 CalculateWatermarks_params->SubViewportLinesNeededInMALL = &mode_lib->ms.SubViewportLinesNeededInMALL[j]; // dml_uint_t SubViewportLinesNeededInMALL[]
8018 CalculateWatermarks_params->FCLKChangeSupport = &mode_lib->ms.support.FCLKChangeSupport[j];
8019 CalculateWatermarks_params->MaxActiveFCLKChangeLatencySupported = &s->dummy_single[0]; // dml_float_t *MaxActiveFCLKChangeLatencySupported
8020 CalculateWatermarks_params->USRRetrainingSupport = &mode_lib->ms.support.USRRetrainingSupport[j];
8021 CalculateWatermarks_params->ActiveDRAMClockChangeLatencyMargin = mode_lib->ms.support.ActiveDRAMClockChangeLatencyMargin;
8022
8023 CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(&mode_lib->scratch,
8024 CalculateWatermarks_params);
8025
8026 } // for j
8027 // End of Prefetch Check
8028 dml_print("DML::%s: Done prefetch calculation\n", __func__);
8029
8030 /*Cursor Support Check*/
8031 mode_lib->ms.support.CursorSupport = true;
8032 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8033 if (mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] > 0.0) {
8034 if (mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] == 64 && mode_lib->ms.ip.cursor_64bpp_support == false) {
8035 mode_lib->ms.support.CursorSupport = false;
8036 }
8037 }
8038 }
8039
8040 /*Valid Pitch Check*/
8041 mode_lib->ms.support.PitchSupport = true;
8042 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8043 mode_lib->ms.support.AlignedYPitch[k] = dml_ceil(
8044 dml_max(mode_lib->ms.cache_display_cfg.surface.PitchY[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k]),
8045 mode_lib->ms.MacroTileWidthY[k]);
8046 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
8047 mode_lib->ms.support.AlignedDCCMetaPitchY[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k]), 64.0 * mode_lib->ms.Read256BlockWidthY[k]);
8048 } else {
8049 mode_lib->ms.support.AlignedDCCMetaPitchY[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
8050 }
8051 if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
8052 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
8053 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
8054 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
8055 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
8056 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8) {
8057 mode_lib->ms.support.AlignedCPitch[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.PitchC[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k]), mode_lib->ms.MacroTileWidthC[k]);
8058 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
8059 mode_lib->ms.support.AlignedDCCMetaPitchC[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k]), 64.0 * mode_lib->ms.Read256BlockWidthC[k]);
8060 } else {
8061 mode_lib->ms.support.AlignedDCCMetaPitchC[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8062 }
8063 } else {
8064 mode_lib->ms.support.AlignedCPitch[k] = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
8065 mode_lib->ms.support.AlignedDCCMetaPitchC[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8066 }
8067 if (mode_lib->ms.support.AlignedYPitch[k] > mode_lib->ms.cache_display_cfg.surface.PitchY[k] || mode_lib->ms.support.AlignedCPitch[k] > mode_lib->ms.cache_display_cfg.surface.PitchC[k] ||
8068 mode_lib->ms.support.AlignedDCCMetaPitchY[k] > mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k] || mode_lib->ms.support.AlignedDCCMetaPitchC[k] > mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k]) {
8069 mode_lib->ms.support.PitchSupport = false;
8070 }
8071 }
8072
8073 mode_lib->ms.support.ViewportExceedsSurface = false;
8074 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8075 if (mode_lib->ms.cache_display_cfg.plane.ViewportWidth[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k] || mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY[k]) {
8076 mode_lib->ms.support.ViewportExceedsSurface = true;
8077 if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32 &&
8078 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_8 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe) {
8079 if (mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k] || mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC[k]) {
8080 mode_lib->ms.support.ViewportExceedsSurface = true;
8081 }
8082 }
8083 }
8084 }
8085
8086 /*Mode Support, Voltage State and SOC Configuration*/
8087 for (j = 0; j < 2; j++) { // j iterator is for the combine mode off or on
8088 dml_print("DML::%s: checking support for j=%u\n", __func__, j);
8089 dml_print("DML::%s: state_idx=%0d max_state_idx=%0d\n", __func__, mode_lib->ms.state_idx, mode_lib->ms.max_state_idx);
8090
8091 s->is_max_pwr_state = (mode_lib->ms.max_state_idx == mode_lib->ms.state_idx);
8092 s->is_max_dram_pwr_state = (mode_lib->ms.max_state.dram_speed_mts == mode_lib->ms.state.dram_speed_mts);
8093
8094 s->dram_clock_change_support = (!mode_lib->ms.policy.DRAMClockChangeRequirementFinal ||
8095 (s->is_max_dram_pwr_state && mode_lib->policy.AssumeModeSupportAtMaxPwrStateEvenDRAMClockChangeNotSupported) ||
8096 mode_lib->ms.support.DRAMClockChangeSupport[j] != dml_dram_clock_change_unsupported);
8097 s->f_clock_change_support = (!mode_lib->ms.policy.FCLKChangeRequirementFinal ||
8098 (s->is_max_pwr_state && mode_lib->policy.AssumeModeSupportAtMaxPwrStateEvenFClockChangeNotSupported) ||
8099 mode_lib->ms.support.FCLKChangeSupport[j] != dml_fclock_change_unsupported);
8100
8101 if (mode_lib->ms.support.ScaleRatioAndTapsSupport == true
8102 && mode_lib->ms.support.SourceFormatPixelAndScanSupport == true
8103 && mode_lib->ms.support.ViewportSizeSupport[j] == true
8104 && !mode_lib->ms.support.LinkRateDoesNotMatchDPVersion
8105 && !mode_lib->ms.support.LinkRateForMultistreamNotIndicated
8106 && !mode_lib->ms.support.BPPForMultistreamNotIndicated
8107 && !mode_lib->ms.support.MultistreamWithHDMIOreDP
8108 && !mode_lib->ms.support.ExceededMultistreamSlots
8109 && !mode_lib->ms.support.MSOOrODMSplitWithNonDPLink
8110 && !mode_lib->ms.support.NotEnoughLanesForMSO
8111 && mode_lib->ms.support.LinkCapacitySupport == true
8112 && !mode_lib->ms.support.P2IWith420
8113 && !mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP
8114 && !mode_lib->ms.support.DSC422NativeNotSupported
8115 && !mode_lib->ms.support.MPCCombineMethodIncompatible
8116 && mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK == true
8117 && mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK == true
8118 && mode_lib->ms.support.NotEnoughDSCUnits == false
8119 && !mode_lib->ms.support.NotEnoughDSCSlices
8120 && !mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
8121 && !mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen
8122 && mode_lib->ms.support.DSCCLKRequiredMoreThanSupported == false
8123 && mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport
8124 && mode_lib->ms.support.DTBCLKRequiredMoreThanSupported == false
8125 && !mode_lib->ms.support.InvalidCombinationOfMALLUseForPState
8126 && !mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
8127 && mode_lib->ms.support.ROBSupport[j] == true
8128 && mode_lib->ms.support.DISPCLK_DPPCLK_Support[j] == true
8129 && mode_lib->ms.support.TotalAvailablePipesSupport[j] == true
8130 && mode_lib->ms.support.NumberOfOTGSupport == true
8131 && mode_lib->ms.support.NumberOfHDMIFRLSupport == true
8132 && mode_lib->ms.support.NumberOfDP2p0Support == true
8133 && mode_lib->ms.support.EnoughWritebackUnits == true
8134 && mode_lib->ms.support.WritebackLatencySupport == true
8135 && mode_lib->ms.support.WritebackScaleRatioAndTapsSupport == true
8136 && mode_lib->ms.support.CursorSupport == true
8137 && mode_lib->ms.support.PitchSupport == true
8138 && mode_lib->ms.support.ViewportExceedsSurface == false
8139 && mode_lib->ms.support.PrefetchSupported[j] == true
8140 && mode_lib->ms.support.VActiveBandwithSupport[j] == true
8141 && mode_lib->ms.support.DynamicMetadataSupported[j] == true
8142 && mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] == true
8143 && mode_lib->ms.support.VRatioInPrefetchSupported[j] == true
8144 && mode_lib->ms.support.PTEBufferSizeNotExceeded[j] == true
8145 && mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] == true
8146 && mode_lib->ms.support.NonsupportedDSCInputBPC == false
8147 && !mode_lib->ms.support.ExceededMALLSize
8148 && ((mode_lib->ms.cache_display_cfg.plane.HostVMEnable == false && !s->ImmediateFlipRequiredFinal) || mode_lib->ms.support.ImmediateFlipSupportedForState[j])
8149 && s->dram_clock_change_support == true
8150 && s->f_clock_change_support == true
8151 && (!mode_lib->ms.policy.USRRetrainingRequiredFinal || mode_lib->ms.support.USRRetrainingSupport[j])) {
8152 dml_print("DML::%s: mode is supported\n", __func__);
8153 mode_lib->ms.support.ModeSupport[j] = true;
8154 } else {
8155 dml_print("DML::%s: mode is NOT supported\n", __func__);
8156 mode_lib->ms.support.ModeSupport[j] = false;
8157 dml_print_mode_support(mode_lib, j);
8158 }
8159 }
8160
8161 mode_lib->ms.support.MaximumMPCCombine = 0;
8162 mode_lib->ms.support.ModeIsSupported = 0;
8163 if (mode_lib->ms.support.ModeSupport[0] == true || mode_lib->ms.support.ModeSupport[1] == true) { // if the mode is supported by either no combine or mpccombine
8164 mode_lib->ms.support.ModeIsSupported = mode_lib->ms.support.ModeSupport[0] == true || mode_lib->ms.support.ModeSupport[1] == true;
8165
8166 // Determine if MPC combine is necessary, depends on if using MPC combine will help dram clock change or fclk change, etc.
8167 if ((mode_lib->ms.support.ModeSupport[0] == false && mode_lib->ms.support.ModeSupport[1] == true) || s->MPCCombineMethodAsPossible ||
8168 (s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && mode_lib->ms.policy.DRAMClockChangeRequirementFinal &&
8169 (((mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive_w_mall_sub_vp) &&
8170 !(mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive || mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive_w_mall_sub_vp)) ||
8171 ((mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr
8172 || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr_w_mall_full_frame
8173 || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_w_mall_sub_vp || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr_w_mall_sub_vp
8174 ) &&
8175 mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_unsupported)))
8176 || (s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && mode_lib->ms.policy.FCLKChangeRequirementFinal &&
8177 ((mode_lib->ms.support.FCLKChangeSupport[1] == dml_fclock_change_vactive && mode_lib->ms.support.FCLKChangeSupport[0] != dml_fclock_change_vactive) ||
8178 (mode_lib->ms.support.FCLKChangeSupport[1] == dml_fclock_change_vblank && mode_lib->ms.support.FCLKChangeSupport[0] == dml_fclock_change_unsupported)))) {
8179 mode_lib->ms.support.MaximumMPCCombine = 1;
8180 } else {
8181 mode_lib->ms.support.MaximumMPCCombine = 0;
8182 }
8183 }
8184
8185 // Since now the mode_support work on 1 particular power state, so there is only 1 state idx (index 0).
8186 mode_lib->ms.support.ImmediateFlipSupport = mode_lib->ms.support.ImmediateFlipSupportedForState[mode_lib->ms.support.MaximumMPCCombine]; // Consider flip support if max combine support imm flip
8187 mode_lib->ms.support.UnboundedRequestEnabled = mode_lib->ms.UnboundedRequestEnabledAllStates[mode_lib->ms.support.MaximumMPCCombine]; // Not used, informational
8188 mode_lib->ms.support.CompressedBufferSizeInkByte = mode_lib->ms.CompressedBufferSizeInkByteAllStates[mode_lib->ms.support.MaximumMPCCombine]; // Not used, informational
8189
8190 dml_print("DML::%s: ModeIsSupported = %u\n", __func__, mode_lib->ms.support.ModeIsSupported);
8191 dml_print("DML::%s: MaximumMPCCombine = %u\n", __func__, mode_lib->ms.support.MaximumMPCCombine);
8192 dml_print("DML::%s: ImmediateFlipSupport = %u\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
8193 dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, mode_lib->ms.support.UnboundedRequestEnabled);
8194 dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, mode_lib->ms.support.CompressedBufferSizeInkByte);
8195
8196 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8197 mode_lib->ms.support.MPCCombineEnable[k] = mode_lib->ms.MPCCombine[mode_lib->ms.support.MaximumMPCCombine][k];
8198 mode_lib->ms.support.DPPPerSurface[k] = mode_lib->ms.NoOfDPP[mode_lib->ms.support.MaximumMPCCombine][k];
8199 mode_lib->ms.SwathHeightY[k] = mode_lib->ms.SwathHeightYAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8200 mode_lib->ms.SwathHeightC[k] = mode_lib->ms.SwathHeightCAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8201 mode_lib->ms.DETBufferSizeInKByte[k] = mode_lib->ms.DETBufferSizeInKByteAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8202 mode_lib->ms.DETBufferSizeY[k] = mode_lib->ms.DETBufferSizeYAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8203 mode_lib->ms.DETBufferSizeC[k] = mode_lib->ms.DETBufferSizeCAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8204 }
8205
8206 mode_lib->ms.DRAMSpeed = mode_lib->ms.state.dram_speed_mts;
8207 mode_lib->ms.FabricClock = mode_lib->ms.state.fabricclk_mhz;
8208 mode_lib->ms.SOCCLK = mode_lib->ms.state.socclk_mhz;
8209 mode_lib->ms.DCFCLK = mode_lib->ms.DCFCLKState[mode_lib->ms.support.MaximumMPCCombine];
8210 mode_lib->ms.ReturnBW = mode_lib->ms.ReturnBWPerState[mode_lib->ms.support.MaximumMPCCombine];
8211 mode_lib->ms.ReturnDRAMBW = mode_lib->ms.ReturnDRAMBWPerState[mode_lib->ms.support.MaximumMPCCombine];
8212
8213 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8214 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8215 mode_lib->ms.support.ODMMode[k] = mode_lib->ms.ODMModePerState[k];
8216 } else {
8217 mode_lib->ms.support.ODMMode[k] = dml_odm_mode_bypass;
8218 }
8219
8220 mode_lib->ms.support.DSCEnabled[k] = mode_lib->ms.RequiresDSC[k];
8221 mode_lib->ms.support.FECEnabled[k] = mode_lib->ms.RequiresFEC[k];
8222 mode_lib->ms.support.OutputBpp[k] = mode_lib->ms.OutputBppPerState[k];
8223 mode_lib->ms.support.OutputType[k] = mode_lib->ms.OutputTypePerState[k];
8224 mode_lib->ms.support.OutputRate[k] = mode_lib->ms.OutputRatePerState[k];
8225 mode_lib->ms.support.SubViewportLinesNeededInMALL[k] = mode_lib->ms.SubViewportLinesNeededInMALL[k];
8226 }
8227
8228 return mode_lib->ms.support.ModeIsSupported;
8229} // dml_core_mode_support
8230
8231/// @brief This function calculates some parameters thats are needed ahead of the mode programming function all
8232void dml_core_mode_support_partial(struct display_mode_lib_st *mode_lib)
8233{
8234 CalculateMaxDETAndMinCompressedBufferSize(
8235 mode_lib->ms.ip.config_return_buffer_size_in_kbytes,
8236 mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes,
8237 mode_lib->ms.ip.rob_buffer_size_kbytes,
8238 mode_lib->ms.ip.max_num_dpp,
8239 mode_lib->ms.policy.NomDETInKByteOverrideEnable,
8240 mode_lib->ms.policy.NomDETInKByteOverrideValue,
8241
8242 /* Output */
8243 &mode_lib->ms.MaxTotalDETInKByte,
8244 &mode_lib->ms.NomDETInKByte,
8245 &mode_lib->ms.MinCompressedBufferSizeInKByte);
8246
8247 PixelClockAdjustmentForProgressiveToInterlaceUnit(&mode_lib->ms.cache_display_cfg, mode_lib->ms.ip.ptoi_supported);
8248
8249 mode_lib->ms.ReturnBW = dml_get_return_bw_mbps(&mode_lib->ms.soc,
8250 mode_lib->ms.state.use_ideal_dram_bw_strobe,
8251 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8252 mode_lib->ms.DCFCLK,
8253 mode_lib->ms.FabricClock,
8254 mode_lib->ms.DRAMSpeed);
8255 dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->ms.ReturnBW);
8256
8257} // dml_core_mode_support_partial
8258
8259/// @brief This is the mode programming function. It is assumed the display cfg is support at the given power state
8260void dml_core_mode_programming(struct display_mode_lib_st *mode_lib, const struct dml_clk_cfg_st *clk_cfg)
8261{
8262 struct dml_core_mode_programming_locals_st *s = &mode_lib->scratch.dml_core_mode_programming_locals;
8263 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *CalculateWatermarks_params = &mode_lib->scratch.CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params;
8264 struct CalculateVMRowAndSwath_params_st *CalculateVMRowAndSwath_params = &mode_lib->scratch.CalculateVMRowAndSwath_params;
8265 struct CalculateSwathAndDETConfiguration_params_st *CalculateSwathAndDETConfiguration_params = &mode_lib->scratch.CalculateSwathAndDETConfiguration_params;
8266 struct CalculateStutterEfficiency_params_st *CalculateStutterEfficiency_params = &mode_lib->scratch.CalculateStutterEfficiency_params;
8267 struct CalculatePrefetchSchedule_params_st *CalculatePrefetchSchedule_params = &mode_lib->scratch.CalculatePrefetchSchedule_params;
8268
8269 struct mode_program_st *locals = &mode_lib->mp;
8270 struct DmlPipe *myPipe;
8271 dml_uint_t j = 0, k = 0;
8272 dml_float_t TWait;
8273 dml_bool_t isInterlaceTiming;
8274
8275 mode_lib->ms.num_active_planes = dml_get_num_active_planes(&mode_lib->ms.cache_display_cfg);
8276 mode_lib->mp.num_active_pipes = dml_get_num_active_pipes(&mode_lib->ms.cache_display_cfg);
8277 dml_calc_pipe_plane_mapping(&mode_lib->ms.cache_display_cfg.hw, mode_lib->mp.pipe_plane);
8278
8279#ifdef __DML_VBA_DEBUG__
8280 dml_print("DML::%s: --- START --- \n", __func__);
8281 dml_print("DML::%s: num_active_planes = %u\n", __func__, mode_lib->ms.num_active_planes);
8282 dml_print("DML::%s: num_active_pipes = %u\n", __func__, mode_lib->mp.num_active_pipes);
8283#endif
8284
8285 s->DSCFormatFactor = 0;
8286
8287 // Unlike dppclk and dispclk which can be calculated in mode_programming
8288 // DCFCLK is calculated in mode_support (which is the state bbox dcfclk or min dcfclk if min dcfclk option is used in mode support calculation)
8289 if (clk_cfg->dcfclk_option != dml_use_override_freq)
8290 locals->Dcfclk = mode_lib->ms.DCFCLK;
8291 else
8292 locals->Dcfclk = clk_cfg->dcfclk_freq_mhz;
8293
8294#ifdef __DML_VBA_DEBUG__
8295 dml_print_dml_policy(&mode_lib->ms.policy);
8296 dml_print_soc_state_bounding_box(&mode_lib->ms.state);
8297 dml_print_soc_bounding_box(&mode_lib->ms.soc);
8298 dml_print_clk_cfg(clk_cfg);
8299
8300 dml_print("DML::%s: ImmediateFlipSupport = %u\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
8301 dml_print("DML::%s: Using DCFCLK = %f\n", __func__, locals->Dcfclk);
8302 dml_print("DML::%s: Using SOCCLK = %f\n", __func__, mode_lib->ms.SOCCLK);
8303#endif
8304
8305 locals->WritebackDISPCLK = 0.0;
8306 locals->GlobalDPPCLK = 0.0;
8307
8308 // DISPCLK and DPPCLK Calculation
8309 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8310 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k]) {
8311 locals->WritebackDISPCLK =
8312 dml_max(
8313 locals->WritebackDISPCLK,
8314 CalculateWriteBackDISPCLK(
8315 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
8316 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8317 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
8318 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
8319 mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k],
8320 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
8321 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceWidth[k],
8322 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
8323 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
8324 mode_lib->ms.ip.writeback_line_buffer_buffer_size,
8325 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz));
8326 }
8327 }
8328
8329 locals->Dispclk_calculated = locals->WritebackDISPCLK;
8330
8331 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8332 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8333 locals->Dispclk_calculated = dml_max(locals->Dispclk_calculated, CalculateRequiredDispclk(
8334 mode_lib->ms.cache_display_cfg.hw.ODMMode[k],
8335 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8336 mode_lib->ms.soc.dcn_downspread_percent,
8337 mode_lib->ms.ip.dispclk_ramp_margin_percent,
8338 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
8339 mode_lib->ms.max_state.dispclk_mhz));
8340 }
8341 }
8342 if (clk_cfg->dispclk_option == dml_use_required_freq)
8343 locals->Dispclk = locals->Dispclk_calculated;
8344 else if (clk_cfg->dispclk_option == dml_use_override_freq)
8345 locals->Dispclk = clk_cfg->dispclk_freq_mhz;
8346 else
8347 locals->Dispclk = mode_lib->ms.state.dispclk_mhz;
8348#ifdef __DML_VBA_DEBUG__
8349 dml_print("DML::%s: Using Dispclk = %f\n", __func__, locals->Dispclk);
8350#endif
8351
8352 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8353 CalculateSinglePipeDPPCLKAndSCLThroughput(
8354 mode_lib->ms.cache_display_cfg.plane.HRatio[k],
8355 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k],
8356 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
8357 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
8358 mode_lib->ms.ip.max_dchub_pscl_bw_pix_per_clk,
8359 mode_lib->ms.ip.max_pscl_lb_bw_pix_per_clk,
8360 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8361 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
8362 mode_lib->ms.cache_display_cfg.plane.HTaps[k],
8363 mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k],
8364 mode_lib->ms.cache_display_cfg.plane.VTaps[k],
8365 mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k],
8366
8367 /* Output */
8368 &locals->PSCL_THROUGHPUT[k],
8369 &locals->PSCL_THROUGHPUT_CHROMA[k],
8370 &locals->DPPCLKUsingSingleDPP[k]);
8371 }
8372
8373 CalculateDPPCLK(mode_lib->ms.num_active_planes,
8374 mode_lib->ms.soc.dcn_downspread_percent,
8375 mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
8376 locals->DPPCLKUsingSingleDPP,
8377 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8378 /* Output */
8379 &locals->GlobalDPPCLK,
8380 locals->Dppclk_calculated);
8381
8382 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8383 if (clk_cfg->dppclk_option[k] == dml_use_required_freq)
8384 locals->Dppclk[k] = locals->Dppclk_calculated[k];
8385 else if (clk_cfg->dppclk_option[k] == dml_use_override_freq)
8386 locals->Dppclk[k] = clk_cfg->dppclk_freq_mhz[k];
8387 else
8388 locals->Dppclk[k] = mode_lib->ms.state.dppclk_mhz;
8389#ifdef __DML_VBA_DEBUG__
8390 dml_print("DML::%s: Using Dppclk[%0d] = %f\n", __func__, k, locals->Dppclk[k]);
8391#endif
8392 }
8393
8394 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8395 CalculateBytePerPixelAndBlockSizes(
8396 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
8397 mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
8398
8399 /* Output */
8400 &locals->BytePerPixelY[k],
8401 &locals->BytePerPixelC[k],
8402 &locals->BytePerPixelDETY[k],
8403 &locals->BytePerPixelDETC[k],
8404 &locals->BlockHeight256BytesY[k],
8405 &locals->BlockHeight256BytesC[k],
8406 &locals->BlockWidth256BytesY[k],
8407 &locals->BlockWidth256BytesC[k],
8408 &locals->BlockHeightY[k],
8409 &locals->BlockHeightC[k],
8410 &locals->BlockWidthY[k],
8411 &locals->BlockWidthC[k]);
8412 }
8413
8414
8415 dml_print("DML::%s: %u\n", __func__, __LINE__);
8416 CalculateSwathWidth(
8417 false, // ForceSingleDPP
8418 mode_lib->ms.num_active_planes,
8419 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat,
8420 mode_lib->ms.cache_display_cfg.plane.SourceScan,
8421 mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
8422 mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
8423 mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
8424 mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
8425 mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
8426 mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
8427 mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
8428 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
8429 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
8430 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
8431 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
8432 mode_lib->ms.cache_display_cfg.hw.ODMMode,
8433 locals->BytePerPixelY,
8434 locals->BytePerPixelC,
8435 locals->BlockHeight256BytesY,
8436 locals->BlockHeight256BytesC,
8437 locals->BlockWidth256BytesY,
8438 locals->BlockWidth256BytesC,
8439 mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming,
8440 mode_lib->ms.cache_display_cfg.timing.HActive,
8441 mode_lib->ms.cache_display_cfg.plane.HRatio,
8442 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8443
8444 /* Output */
8445 locals->SwathWidthSingleDPPY,
8446 locals->SwathWidthSingleDPPC,
8447 locals->SwathWidthY,
8448 locals->SwathWidthC,
8449 s->dummy_integer_array[0], // dml_uint_t MaximumSwathHeightY[]
8450 s->dummy_integer_array[1], // dml_uint_t MaximumSwathHeightC[]
8451 locals->swath_width_luma_ub,
8452 locals->swath_width_chroma_ub);
8453
8454 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8455 locals->ReadBandwidthSurfaceLuma[k] = locals->SwathWidthSingleDPPY[k] * locals->BytePerPixelY[k] / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8456 locals->ReadBandwidthSurfaceChroma[k] = locals->SwathWidthSingleDPPC[k] * locals->BytePerPixelC[k] / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
8457 dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
8458 dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
8459 }
8460
8461 CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
8462 CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
8463 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
8464 CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
8465 CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
8466 CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
8467 CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
8468 CalculateSwathAndDETConfiguration_params->ForceSingleDPP = false;
8469 CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
8470 CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
8471 CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
8472 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
8473 CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
8474 CalculateSwathAndDETConfiguration_params->Output = s->dummy_output_encoder_array;
8475 CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = locals->ReadBandwidthSurfaceLuma;
8476 CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = locals->ReadBandwidthSurfaceChroma;
8477 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = s->dummy_single_array[0];
8478 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = s->dummy_single_array[1];
8479 CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
8480 CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
8481 CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
8482 CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
8483 CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
8484 CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
8485 CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
8486 CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
8487 CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
8488 CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
8489 CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
8490 CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
8491 CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
8492 CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
8493 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = locals->BlockHeight256BytesY;
8494 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = locals->BlockHeight256BytesC;
8495 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = locals->BlockWidth256BytesY;
8496 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = locals->BlockWidth256BytesC;
8497 CalculateSwathAndDETConfiguration_params->ODMMode = mode_lib->ms.cache_display_cfg.hw.ODMMode;
8498 CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
8499 CalculateSwathAndDETConfiguration_params->BytePerPixY = locals->BytePerPixelY;
8500 CalculateSwathAndDETConfiguration_params->BytePerPixC = locals->BytePerPixelC;
8501 CalculateSwathAndDETConfiguration_params->BytePerPixDETY = locals->BytePerPixelDETY;
8502 CalculateSwathAndDETConfiguration_params->BytePerPixDETC = locals->BytePerPixelDETC;
8503 CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
8504 CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
8505 CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
8506 CalculateSwathAndDETConfiguration_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
8507 CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = s->dummy_long_array[0];
8508 CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = s->dummy_long_array[1];
8509 CalculateSwathAndDETConfiguration_params->SwathWidth = s->dummy_long_array[2];
8510 CalculateSwathAndDETConfiguration_params->SwathWidthChroma = s->dummy_long_array[3];
8511 CalculateSwathAndDETConfiguration_params->SwathHeightY = locals->SwathHeightY;
8512 CalculateSwathAndDETConfiguration_params->SwathHeightC = locals->SwathHeightC;
8513 CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = locals->DETBufferSizeInKByte;
8514 CalculateSwathAndDETConfiguration_params->DETBufferSizeY = locals->DETBufferSizeY;
8515 CalculateSwathAndDETConfiguration_params->DETBufferSizeC = locals->DETBufferSizeC;
8516 CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &locals->UnboundedRequestEnabled;
8517 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &locals->compbuf_reserved_space_64b;
8518 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &locals->compbuf_reserved_space_zs;
8519 CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &locals->CompressedBufferSizeInkByte;
8520 CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = &s->dummy_boolean_array[0][0];
8521 CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &s->dummy_boolean[0];
8522
8523 // VBA_DELTA
8524 // Calculate DET size, swath height here. In VBA, they are calculated in mode check stage
8525 CalculateSwathAndDETConfiguration(&mode_lib->scratch,
8526 CalculateSwathAndDETConfiguration_params);
8527
8528 // DCFCLK Deep Sleep
8529 CalculateDCFCLKDeepSleep(
8530 mode_lib->ms.num_active_planes,
8531 locals->BytePerPixelY,
8532 locals->BytePerPixelC,
8533 mode_lib->ms.cache_display_cfg.plane.VRatio,
8534 mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
8535 locals->SwathWidthY,
8536 locals->SwathWidthC,
8537 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8538 mode_lib->ms.cache_display_cfg.plane.HRatio,
8539 mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
8540 mode_lib->ms.cache_display_cfg.timing.PixelClock,
8541 locals->PSCL_THROUGHPUT,
8542 locals->PSCL_THROUGHPUT_CHROMA,
8543 locals->Dppclk,
8544 locals->ReadBandwidthSurfaceLuma,
8545 locals->ReadBandwidthSurfaceChroma,
8546 mode_lib->ms.soc.return_bus_width_bytes,
8547
8548 /* Output */
8549 &locals->DCFCLKDeepSleep);
8550
8551 // DSCCLK
8552 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8553 if ((mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] != k) || !mode_lib->ms.cache_display_cfg.hw.DSCEnabled[k]) {
8554 locals->DSCCLK_calculated[k] = 0.0;
8555 } else {
8556 if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420)
8557 s->DSCFormatFactor = 2;
8558 else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_444)
8559 s->DSCFormatFactor = 1;
8560 else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)
8561 s->DSCFormatFactor = 2;
8562 else
8563 s->DSCFormatFactor = 1;
8564 if (mode_lib->ms.cache_display_cfg.hw.ODMMode[k] == dml_odm_mode_combine_4to1)
8565 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 12 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8566 else if (mode_lib->ms.cache_display_cfg.hw.ODMMode[k] == dml_odm_mode_combine_2to1)
8567 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 6 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8568 else
8569 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 3 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8570 }
8571 }
8572
8573 // DSC Delay
8574 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8575 locals->DSCDelay[k] = DSCDelayRequirement(mode_lib->ms.cache_display_cfg.hw.DSCEnabled[k],
8576 mode_lib->ms.cache_display_cfg.hw.ODMMode[k],
8577 mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
8578 mode_lib->ms.cache_display_cfg.output.OutputBpp[k],
8579 mode_lib->ms.cache_display_cfg.timing.HActive[k],
8580 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
8581 mode_lib->ms.cache_display_cfg.hw.NumberOfDSCSlices[k],
8582 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
8583 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
8584 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8585 mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
8586 }
8587
8588 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8589 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) // NumberOfSurfaces
8590 if (j != k && mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == j && mode_lib->ms.cache_display_cfg.hw.DSCEnabled[j])
8591 locals->DSCDelay[k] = locals->DSCDelay[j];
8592
8593 // Prefetch
8594 CalculateSurfaceSizeInMall(
8595 mode_lib->ms.num_active_planes,
8596 mode_lib->ms.soc.mall_allocated_for_dcn_mbytes,
8597 mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen,
8598 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
8599 mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
8600 mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
8601 mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
8602 mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
8603 mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
8604 mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
8605 mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
8606 locals->BytePerPixelY,
8607 mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma,
8608 mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma,
8609 locals->BytePerPixelC,
8610 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
8611 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
8612 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
8613 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
8614 locals->BlockWidth256BytesY,
8615 locals->BlockWidth256BytesC,
8616 locals->BlockHeight256BytesY,
8617 locals->BlockHeight256BytesC,
8618 locals->BlockWidthY,
8619 locals->BlockWidthC,
8620 locals->BlockHeightY,
8621 locals->BlockHeightC,
8622
8623 /* Output */
8624 locals->SurfaceSizeInTheMALL,
8625 &s->dummy_boolean[0]); /* dml_bool_t *ExceededMALLSize */
8626
8627 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8628 s->SurfaceParameters[k].PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
8629 s->SurfaceParameters[k].DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8630 s->SurfaceParameters[k].SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
8631 s->SurfaceParameters[k].ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
8632 s->SurfaceParameters[k].ViewportHeightChroma = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
8633 s->SurfaceParameters[k].BlockWidth256BytesY = locals->BlockWidth256BytesY[k];
8634 s->SurfaceParameters[k].BlockHeight256BytesY = locals->BlockHeight256BytesY[k];
8635 s->SurfaceParameters[k].BlockWidth256BytesC = locals->BlockWidth256BytesC[k];
8636 s->SurfaceParameters[k].BlockHeight256BytesC = locals->BlockHeight256BytesC[k];
8637 s->SurfaceParameters[k].BlockWidthY = locals->BlockWidthY[k];
8638 s->SurfaceParameters[k].BlockHeightY = locals->BlockHeightY[k];
8639 s->SurfaceParameters[k].BlockWidthC = locals->BlockWidthC[k];
8640 s->SurfaceParameters[k].BlockHeightC = locals->BlockHeightC[k];
8641 s->SurfaceParameters[k].InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
8642 s->SurfaceParameters[k].HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
8643 s->SurfaceParameters[k].DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
8644 s->SurfaceParameters[k].SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
8645 s->SurfaceParameters[k].SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k];
8646 s->SurfaceParameters[k].BytePerPixelY = locals->BytePerPixelY[k];
8647 s->SurfaceParameters[k].BytePerPixelC = locals->BytePerPixelC[k];
8648 s->SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
8649 s->SurfaceParameters[k].VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8650 s->SurfaceParameters[k].VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
8651 s->SurfaceParameters[k].VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps[k];
8652 s->SurfaceParameters[k].VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k];
8653 s->SurfaceParameters[k].PitchY = mode_lib->ms.cache_display_cfg.surface.PitchY[k];
8654 s->SurfaceParameters[k].DCCMetaPitchY = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
8655 s->SurfaceParameters[k].PitchC = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
8656 s->SurfaceParameters[k].DCCMetaPitchC = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8657 s->SurfaceParameters[k].ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary[k];
8658 s->SurfaceParameters[k].ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart[k];
8659 s->SurfaceParameters[k].ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart[k];
8660 s->SurfaceParameters[k].ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC[k];
8661 s->SurfaceParameters[k].ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC[k];
8662 s->SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->ms.cache_display_cfg.plane.ForceOneRowForFrame[k];
8663 s->SurfaceParameters[k].SwathHeightY = locals->SwathHeightY[k];
8664 s->SurfaceParameters[k].SwathHeightC = locals->SwathHeightC[k];
8665 }
8666
8667 CalculateVMRowAndSwath_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
8668 CalculateVMRowAndSwath_params->myPipe = s->SurfaceParameters;
8669 CalculateVMRowAndSwath_params->SurfaceSizeInMALL = locals->SurfaceSizeInTheMALL;
8670 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsLuma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_luma;
8671 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsChroma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_chroma;
8672 CalculateVMRowAndSwath_params->DCCMetaBufferSizeBytes = mode_lib->ms.ip.dcc_meta_buffer_size_bytes;
8673 CalculateVMRowAndSwath_params->UseMALLForStaticScreen = mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen;
8674 CalculateVMRowAndSwath_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
8675 CalculateVMRowAndSwath_params->MALLAllocatedForDCN = mode_lib->ms.soc.mall_allocated_for_dcn_mbytes;
8676 CalculateVMRowAndSwath_params->SwathWidthY = locals->SwathWidthY;
8677 CalculateVMRowAndSwath_params->SwathWidthC = locals->SwathWidthC;
8678 CalculateVMRowAndSwath_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
8679 CalculateVMRowAndSwath_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
8680 CalculateVMRowAndSwath_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
8681 CalculateVMRowAndSwath_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
8682 CalculateVMRowAndSwath_params->GPUVMMinPageSizeKBytes = mode_lib->ms.cache_display_cfg.plane.GPUVMMinPageSizeKBytes;
8683 CalculateVMRowAndSwath_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes;
8684 CalculateVMRowAndSwath_params->PTEBufferModeOverrideEn = mode_lib->ms.cache_display_cfg.plane.PTEBufferModeOverrideEn;
8685 CalculateVMRowAndSwath_params->PTEBufferModeOverrideVal = mode_lib->ms.cache_display_cfg.plane.PTEBufferMode;
8686 CalculateVMRowAndSwath_params->PTEBufferSizeNotExceeded = s->dummy_boolean_array[0];
8687 CalculateVMRowAndSwath_params->DCCMetaBufferSizeNotExceeded = s->dummy_boolean_array[1];
8688 CalculateVMRowAndSwath_params->dpte_row_width_luma_ub = locals->dpte_row_width_luma_ub;
8689 CalculateVMRowAndSwath_params->dpte_row_width_chroma_ub = locals->dpte_row_width_chroma_ub;
8690 CalculateVMRowAndSwath_params->dpte_row_height_luma = locals->dpte_row_height;
8691 CalculateVMRowAndSwath_params->dpte_row_height_chroma = locals->dpte_row_height_chroma;
8692 CalculateVMRowAndSwath_params->dpte_row_height_linear_luma = locals->dpte_row_height_linear;
8693 CalculateVMRowAndSwath_params->dpte_row_height_linear_chroma = locals->dpte_row_height_linear_chroma;
8694 CalculateVMRowAndSwath_params->meta_req_width = locals->meta_req_width;
8695 CalculateVMRowAndSwath_params->meta_req_width_chroma = locals->meta_req_width_chroma;
8696 CalculateVMRowAndSwath_params->meta_req_height = locals->meta_req_height;
8697 CalculateVMRowAndSwath_params->meta_req_height_chroma = locals->meta_req_height_chroma;
8698 CalculateVMRowAndSwath_params->meta_row_width = locals->meta_row_width;
8699 CalculateVMRowAndSwath_params->meta_row_width_chroma = locals->meta_row_width_chroma;
8700 CalculateVMRowAndSwath_params->meta_row_height = locals->meta_row_height;
8701 CalculateVMRowAndSwath_params->meta_row_height_chroma = locals->meta_row_height_chroma;
8702 CalculateVMRowAndSwath_params->vm_group_bytes = locals->vm_group_bytes;
8703 CalculateVMRowAndSwath_params->dpte_group_bytes = locals->dpte_group_bytes;
8704 CalculateVMRowAndSwath_params->PixelPTEReqWidthY = locals->PixelPTEReqWidthY;
8705 CalculateVMRowAndSwath_params->PixelPTEReqHeightY = locals->PixelPTEReqHeightY;
8706 CalculateVMRowAndSwath_params->PTERequestSizeY = locals->PTERequestSizeY;
8707 CalculateVMRowAndSwath_params->PixelPTEReqWidthC = locals->PixelPTEReqWidthC;
8708 CalculateVMRowAndSwath_params->PixelPTEReqHeightC = locals->PixelPTEReqHeightC;
8709 CalculateVMRowAndSwath_params->PTERequestSizeC = locals->PTERequestSizeC;
8710 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_l = locals->dpde0_bytes_per_frame_ub_l;
8711 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_l = locals->meta_pte_bytes_per_frame_ub_l;
8712 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_c = locals->dpde0_bytes_per_frame_ub_c;
8713 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_c = locals->meta_pte_bytes_per_frame_ub_c;
8714 CalculateVMRowAndSwath_params->PrefetchSourceLinesY = locals->PrefetchSourceLinesY;
8715 CalculateVMRowAndSwath_params->PrefetchSourceLinesC = locals->PrefetchSourceLinesC;
8716 CalculateVMRowAndSwath_params->VInitPreFillY = locals->VInitPreFillY;
8717 CalculateVMRowAndSwath_params->VInitPreFillC = locals->VInitPreFillC;
8718 CalculateVMRowAndSwath_params->MaxNumSwathY = locals->MaxNumSwathY;
8719 CalculateVMRowAndSwath_params->MaxNumSwathC = locals->MaxNumSwathC;
8720 CalculateVMRowAndSwath_params->meta_row_bw = locals->meta_row_bw;
8721 CalculateVMRowAndSwath_params->dpte_row_bw = locals->dpte_row_bw;
8722 CalculateVMRowAndSwath_params->PixelPTEBytesPerRow = locals->PixelPTEBytesPerRow;
8723 CalculateVMRowAndSwath_params->PDEAndMetaPTEBytesFrame = locals->PDEAndMetaPTEBytesFrame;
8724 CalculateVMRowAndSwath_params->MetaRowByte = locals->MetaRowByte;
8725 CalculateVMRowAndSwath_params->use_one_row_for_frame = locals->use_one_row_for_frame;
8726 CalculateVMRowAndSwath_params->use_one_row_for_frame_flip = locals->use_one_row_for_frame_flip;
8727 CalculateVMRowAndSwath_params->UsesMALLForStaticScreen = locals->UsesMALLForStaticScreen;
8728 CalculateVMRowAndSwath_params->PTE_BUFFER_MODE = locals->PTE_BUFFER_MODE;
8729 CalculateVMRowAndSwath_params->BIGK_FRAGMENT_SIZE = locals->BIGK_FRAGMENT_SIZE;
8730
8731 CalculateVMRowAndSwath(&mode_lib->scratch,
8732 CalculateVMRowAndSwath_params);
8733
8734 s->ReorderBytes = (dml_uint_t)(mode_lib->ms.soc.num_chans * dml_max3(
8735 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_only_bytes,
8736 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes,
8737 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_vm_only_bytes));
8738
8739 s->VMDataOnlyReturnBW = dml_get_return_bw_mbps_vm_only(&mode_lib->ms.soc,
8740 mode_lib->ms.state.use_ideal_dram_bw_strobe,
8741 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8742 locals->Dcfclk,
8743 mode_lib->ms.FabricClock,
8744 mode_lib->ms.DRAMSpeed);
8745
8746#ifdef __DML_VBA_DEBUG__
8747 dml_print("DML::%s: locals->Dcfclk = %f\n", __func__, locals->Dcfclk);
8748 dml_print("DML::%s: mode_lib->ms.soc.return_bus_width_bytes = %u\n", __func__, mode_lib->ms.soc.return_bus_width_bytes);
8749 dml_print("DML::%s: mode_lib->ms.FabricClock = %f\n", __func__, mode_lib->ms.FabricClock);
8750 dml_print("DML::%s: mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes = %u\n", __func__, mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes);
8751 dml_print("DML::%s: mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent = %f\n", __func__, mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent);
8752 dml_print("DML::%s: mode_lib->ms.DRAMSpeed = %f\n", __func__, mode_lib->ms.DRAMSpeed);
8753 dml_print("DML::%s: mode_lib->ms.soc.num_chans = %u\n", __func__, mode_lib->ms.soc.num_chans);
8754 dml_print("DML::%s: mode_lib->ms.soc.dram_channel_width_bytes = %u\n", __func__, mode_lib->ms.soc.dram_channel_width_bytes);
8755 dml_print("DML::%s: mode_lib->ms.state_idx = %u\n", __func__, mode_lib->ms.state_idx);
8756 dml_print("DML::%s: mode_lib->ms.max_state_idx = %u\n", __func__, mode_lib->ms.max_state_idx);
8757 dml_print("DML::%s: mode_lib->ms.state.use_ideal_dram_bw_strobe = %u\n", __func__, mode_lib->ms.state.use_ideal_dram_bw_strobe);
8758 dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, s->VMDataOnlyReturnBW);
8759 dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->ms.ReturnBW);
8760#endif
8761
8762 s->HostVMInefficiencyFactor = 1.0;
8763 if (mode_lib->ms.cache_display_cfg.plane.GPUVMEnable && mode_lib->ms.cache_display_cfg.plane.HostVMEnable)
8764 s->HostVMInefficiencyFactor = mode_lib->ms.ReturnBW / s->VMDataOnlyReturnBW;
8765
8766 s->TotalDCCActiveDPP = 0;
8767 s->TotalActiveDPP = 0;
8768 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8769 s->TotalActiveDPP = s->TotalActiveDPP + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8770 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k])
8771 s->TotalDCCActiveDPP = s->TotalDCCActiveDPP + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8772 }
8773
8774 locals->UrgentExtraLatency = CalculateExtraLatency(
8775 mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles,
8776 s->ReorderBytes,
8777 locals->Dcfclk,
8778 s->TotalActiveDPP,
8779 mode_lib->ms.ip.pixel_chunk_size_kbytes,
8780 s->TotalDCCActiveDPP,
8781 mode_lib->ms.ip.meta_chunk_size_kbytes,
8782 mode_lib->ms.ReturnBW,
8783 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
8784 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8785 mode_lib->ms.num_active_planes,
8786 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8787 locals->dpte_group_bytes,
8788 s->HostVMInefficiencyFactor,
8789 mode_lib->ms.soc.hostvm_min_page_size_kbytes,
8790 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels);
8791
8792 locals->TCalc = 24.0 / locals->DCFCLKDeepSleep;
8793
8794 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8795 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8796 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
8797 locals->WritebackDelay[k] =
8798 mode_lib->ms.state.writeback_latency_us
8799 + CalculateWriteBackDelay(
8800 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
8801 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
8802 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
8803 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
8804 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
8805 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k],
8806 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k],
8807 mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / locals->Dispclk;
8808 } else
8809 locals->WritebackDelay[k] = 0;
8810 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
8811 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[j] == k
8812 && mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[j] == true) {
8813 locals->WritebackDelay[k] =
8814 dml_max(
8815 locals->WritebackDelay[k],
8816 mode_lib->ms.state.writeback_latency_us
8817 + CalculateWriteBackDelay(
8818 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[j],
8819 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[j],
8820 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[j],
8821 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[j],
8822 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[j],
8823 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[j],
8824 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[j],
8825 mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / locals->Dispclk);
8826 }
8827 }
8828 }
8829 }
8830
8831 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8832 for (j = 0; j < mode_lib->ms.num_active_planes; ++j)
8833 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == j)
8834 locals->WritebackDelay[k] = locals->WritebackDelay[j];
8835
8836 locals->UrgentLatency = CalculateUrgentLatency(mode_lib->ms.state.urgent_latency_pixel_data_only_us,
8837 mode_lib->ms.state.urgent_latency_pixel_mixed_with_vm_data_us,
8838 mode_lib->ms.state.urgent_latency_vm_data_only_us,
8839 mode_lib->ms.soc.do_urgent_latency_adjustment,
8840 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_component_us,
8841 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_reference_mhz,
8842 mode_lib->ms.FabricClock);
8843
8844 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8845 CalculateUrgentBurstFactor(mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
8846 locals->swath_width_luma_ub[k],
8847 locals->swath_width_chroma_ub[k],
8848 locals->SwathHeightY[k],
8849 locals->SwathHeightC[k],
8850 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8851 locals->UrgentLatency,
8852 mode_lib->ms.ip.cursor_buffer_size,
8853 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
8854 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
8855 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
8856 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
8857 locals->BytePerPixelDETY[k],
8858 locals->BytePerPixelDETC[k],
8859 locals->DETBufferSizeY[k],
8860 locals->DETBufferSizeC[k],
8861
8862 /* output */
8863 &locals->UrgBurstFactorCursor[k],
8864 &locals->UrgBurstFactorLuma[k],
8865 &locals->UrgBurstFactorChroma[k],
8866 &locals->NoUrgentLatencyHiding[k]);
8867
8868 locals->cursor_bw[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 /
8869 ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8870 }
8871
8872 s->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
8873 s->MaxVStartupAllPlanes = 0;
8874
8875 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8876 s->MaxVStartupLines[k] = CalculateMaxVStartup(k,
8877 mode_lib->ms.ip.ptoi_supported,
8878 mode_lib->ms.ip.vblank_nom_default_us,
8879 &mode_lib->ms.cache_display_cfg.timing,
8880 locals->WritebackDelay[k]);
8881
8882#ifdef __DML_VBA_DEBUG__
8883 dml_print("DML::%s: k=%u MaxVStartupLines = %u\n", __func__, k, s->MaxVStartupLines[k]);
8884 dml_print("DML::%s: k=%u WritebackDelay = %f\n", __func__, k, locals->WritebackDelay[k]);
8885#endif
8886 }
8887
8888 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8889 s->MaxVStartupAllPlanes = (dml_uint_t)(dml_max(s->MaxVStartupAllPlanes, s->MaxVStartupLines[k]));
8890
8891 s->ImmediateFlipRequirementFinal = false;
8892 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8893 s->ImmediateFlipRequirementFinal = s->ImmediateFlipRequirementFinal || (mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
8894 }
8895#ifdef __DML_VBA_DEBUG__
8896 dml_print("DML::%s: ImmediateFlipRequirementFinal = %u\n", __func__, s->ImmediateFlipRequirementFinal);
8897#endif
8898
8899 // The prefetch scheduling should only be calculated once as per AllowForPStateChangeOrStutterInVBlank requirement
8900 // If the AllowForPStateChangeOrStutterInVBlank requirement is not strict (i.e. only try those power saving feature
8901 // if possible, then will try to program for the best power saving features in order of diffculty (dram, fclk, stutter)
8902 s->iteration = 0;
8903 s->MaxTotalRDBandwidth = 0;
8904 s->AllPrefetchModeTested = false;
8905 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8906 CalculatePrefetchMode(mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k], &s->MinPrefetchMode[k], &s->MaxPrefetchMode[k]);
8907 s->NextPrefetchMode[k] = s->MinPrefetchMode[k];
8908 }
8909
8910 do {
8911 s->MaxTotalRDBandwidthNoUrgentBurst = 0.0;
8912 s->DestinationLineTimesForPrefetchLessThan2 = false;
8913 s->VRatioPrefetchMoreThanMax = false;
8914
8915 dml_print("DML::%s: Start one iteration: VStartupLines = %u\n", __func__, s->VStartupLines);
8916
8917 s->AllPrefetchModeTested = true;
8918 s->MaxTotalRDBandwidth = 0;
8919 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8920 locals->PrefetchMode[k] = s->NextPrefetchMode[k];
8921 TWait = CalculateTWait(
8922 locals->PrefetchMode[k],
8923 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
8924 mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
8925 mode_lib->ms.cache_display_cfg.timing.DRRDisplay[k],
8926 mode_lib->ms.state.dram_clock_change_latency_us,
8927 mode_lib->ms.state.fclk_change_latency_us,
8928 locals->UrgentLatency,
8929 mode_lib->ms.state.sr_enter_plus_exit_time_us);
8930
8931 myPipe = &s->myPipe;
8932 myPipe->Dppclk = locals->Dppclk[k];
8933 myPipe->Dispclk = locals->Dispclk;
8934 myPipe->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
8935 myPipe->DCFClkDeepSleep = locals->DCFCLKDeepSleep;
8936 myPipe->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8937 myPipe->ScalerEnabled = mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k];
8938 myPipe->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
8939 myPipe->BlockWidth256BytesY = locals->BlockWidth256BytesY[k];
8940 myPipe->BlockHeight256BytesY = locals->BlockHeight256BytesY[k];
8941 myPipe->BlockWidth256BytesC = locals->BlockWidth256BytesC[k];
8942 myPipe->BlockHeight256BytesC = locals->BlockHeight256BytesC[k];
8943 myPipe->InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
8944 myPipe->NumberOfCursors = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k];
8945 myPipe->VBlank = mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k];
8946 myPipe->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
8947 myPipe->HActive = mode_lib->ms.cache_display_cfg.timing.HActive[k];
8948 myPipe->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
8949 myPipe->ODMMode = mode_lib->ms.cache_display_cfg.hw.ODMMode[k];
8950 myPipe->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
8951 myPipe->BytePerPixelY = locals->BytePerPixelY[k];
8952 myPipe->BytePerPixelC = locals->BytePerPixelC[k];
8953 myPipe->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
8954
8955#ifdef __DML_VBA_DEBUG__
8956 dml_print("DML::%s: Calling CalculatePrefetchSchedule for k=%u\n", __func__, k);
8957 dml_print("DML::%s: AllowForPStateChangeOrStutterInVBlank = %u\n", __func__, mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k]);
8958 dml_print("DML::%s: PrefetchMode[k] = %u (Min=%u Max=%u)\n", __func__, locals->PrefetchMode[k], s->MinPrefetchMode[k], s->MaxPrefetchMode[k]);
8959#endif
8960
8961 CalculatePrefetchSchedule_params->EnhancedPrefetchScheduleAccelerationFinal = mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal;
8962 CalculatePrefetchSchedule_params->HostVMInefficiencyFactor = s->HostVMInefficiencyFactor;
8963 CalculatePrefetchSchedule_params->myPipe = myPipe;
8964 CalculatePrefetchSchedule_params->DSCDelay = locals->DSCDelay[k];
8965 CalculatePrefetchSchedule_params->DPPCLKDelaySubtotalPlusCNVCFormater = mode_lib->ms.ip.dppclk_delay_subtotal + mode_lib->ms.ip.dppclk_delay_cnvc_formatter;
8966 CalculatePrefetchSchedule_params->DPPCLKDelaySCL = mode_lib->ms.ip.dppclk_delay_scl;
8967 CalculatePrefetchSchedule_params->DPPCLKDelaySCLLBOnly = mode_lib->ms.ip.dppclk_delay_scl_lb_only;
8968 CalculatePrefetchSchedule_params->DPPCLKDelayCNVCCursor = mode_lib->ms.ip.dppclk_delay_cnvc_cursor;
8969 CalculatePrefetchSchedule_params->DISPCLKDelaySubtotal = mode_lib->ms.ip.dispclk_delay_subtotal;
8970 CalculatePrefetchSchedule_params->DPP_RECOUT_WIDTH = (dml_uint_t)(locals->SwathWidthY[k] / mode_lib->ms.cache_display_cfg.plane.HRatio[k]);
8971 CalculatePrefetchSchedule_params->OutputFormat = mode_lib->ms.cache_display_cfg.output.OutputFormat[k];
8972 CalculatePrefetchSchedule_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
8973 CalculatePrefetchSchedule_params->VStartup = (dml_uint_t)(dml_min(s->VStartupLines, s->MaxVStartupLines[k]));
8974 CalculatePrefetchSchedule_params->MaxVStartup = s->MaxVStartupLines[k];
8975 CalculatePrefetchSchedule_params->GPUVMPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
8976 CalculatePrefetchSchedule_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
8977 CalculatePrefetchSchedule_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
8978 CalculatePrefetchSchedule_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
8979 CalculatePrefetchSchedule_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes;
8980 CalculatePrefetchSchedule_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k];
8981 CalculatePrefetchSchedule_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
8982 CalculatePrefetchSchedule_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired[k];
8983 CalculatePrefetchSchedule_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes[k];
8984 CalculatePrefetchSchedule_params->UrgentLatency = locals->UrgentLatency;
8985 CalculatePrefetchSchedule_params->UrgentExtraLatency = locals->UrgentExtraLatency;
8986 CalculatePrefetchSchedule_params->TCalc = locals->TCalc;
8987 CalculatePrefetchSchedule_params->PDEAndMetaPTEBytesFrame = locals->PDEAndMetaPTEBytesFrame[k];
8988 CalculatePrefetchSchedule_params->MetaRowByte = locals->MetaRowByte[k];
8989 CalculatePrefetchSchedule_params->PixelPTEBytesPerRow = locals->PixelPTEBytesPerRow[k];
8990 CalculatePrefetchSchedule_params->PrefetchSourceLinesY = locals->PrefetchSourceLinesY[k];
8991 CalculatePrefetchSchedule_params->VInitPreFillY = locals->VInitPreFillY[k];
8992 CalculatePrefetchSchedule_params->MaxNumSwathY = locals->MaxNumSwathY[k];
8993 CalculatePrefetchSchedule_params->PrefetchSourceLinesC = locals->PrefetchSourceLinesC[k];
8994 CalculatePrefetchSchedule_params->VInitPreFillC = locals->VInitPreFillC[k];
8995 CalculatePrefetchSchedule_params->MaxNumSwathC = locals->MaxNumSwathC[k];
8996 CalculatePrefetchSchedule_params->swath_width_luma_ub = locals->swath_width_luma_ub[k];
8997 CalculatePrefetchSchedule_params->swath_width_chroma_ub = locals->swath_width_chroma_ub[k];
8998 CalculatePrefetchSchedule_params->SwathHeightY = locals->SwathHeightY[k];
8999 CalculatePrefetchSchedule_params->SwathHeightC = locals->SwathHeightC[k];
9000 CalculatePrefetchSchedule_params->TWait = TWait;
9001 CalculatePrefetchSchedule_params->DSTXAfterScaler = &locals->DSTXAfterScaler[k];
9002 CalculatePrefetchSchedule_params->DSTYAfterScaler = &locals->DSTYAfterScaler[k];
9003 CalculatePrefetchSchedule_params->DestinationLinesForPrefetch = &locals->DestinationLinesForPrefetch[k];
9004 CalculatePrefetchSchedule_params->DestinationLinesToRequestVMInVBlank = &locals->DestinationLinesToRequestVMInVBlank[k];
9005 CalculatePrefetchSchedule_params->DestinationLinesToRequestRowInVBlank = &locals->DestinationLinesToRequestRowInVBlank[k];
9006 CalculatePrefetchSchedule_params->VRatioPrefetchY = &locals->VRatioPrefetchY[k];
9007 CalculatePrefetchSchedule_params->VRatioPrefetchC = &locals->VRatioPrefetchC[k];
9008 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWLuma = &locals->RequiredPrefetchPixDataBWLuma[k];
9009 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWChroma = &locals->RequiredPrefetchPixDataBWChroma[k];
9010 CalculatePrefetchSchedule_params->NotEnoughTimeForDynamicMetadata = &locals->NotEnoughTimeForDynamicMetadata[k];
9011 CalculatePrefetchSchedule_params->Tno_bw = &locals->Tno_bw[k];
9012 CalculatePrefetchSchedule_params->prefetch_vmrow_bw = &locals->prefetch_vmrow_bw[k];
9013 CalculatePrefetchSchedule_params->Tdmdl_vm = &locals->Tdmdl_vm[k];
9014 CalculatePrefetchSchedule_params->Tdmdl = &locals->Tdmdl[k];
9015 CalculatePrefetchSchedule_params->TSetup = &locals->TSetup[k];
9016 CalculatePrefetchSchedule_params->VUpdateOffsetPix = &locals->VUpdateOffsetPix[k];
9017 CalculatePrefetchSchedule_params->VUpdateWidthPix = &locals->VUpdateWidthPix[k];
9018 CalculatePrefetchSchedule_params->VReadyOffsetPix = &locals->VReadyOffsetPix[k];
9019
9020 locals->NoTimeToPrefetch[k] =
9021 CalculatePrefetchSchedule(&mode_lib->scratch,
9022 CalculatePrefetchSchedule_params);
9023
9024#ifdef __DML_VBA_DEBUG__
9025 dml_print("DML::%s: k=%0u NoTimeToPrefetch=%0d\n", __func__, k, locals->NoTimeToPrefetch[k]);
9026#endif
9027 locals->VStartup[k] = (dml_uint_t)(dml_min(s->VStartupLines, s->MaxVStartupLines[k]));
9028 locals->VStartupMin[k] = locals->VStartup[k];
9029 }
9030
9031 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9032 CalculateUrgentBurstFactor(
9033 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
9034 locals->swath_width_luma_ub[k],
9035 locals->swath_width_chroma_ub[k],
9036 locals->SwathHeightY[k],
9037 locals->SwathHeightC[k],
9038 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
9039 locals->UrgentLatency,
9040 mode_lib->ms.ip.cursor_buffer_size,
9041 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
9042 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
9043 locals->VRatioPrefetchY[k],
9044 locals->VRatioPrefetchC[k],
9045 locals->BytePerPixelDETY[k],
9046 locals->BytePerPixelDETC[k],
9047 locals->DETBufferSizeY[k],
9048 locals->DETBufferSizeC[k],
9049 /* Output */
9050 &locals->UrgBurstFactorCursorPre[k],
9051 &locals->UrgBurstFactorLumaPre[k],
9052 &locals->UrgBurstFactorChromaPre[k],
9053 &locals->NoUrgentLatencyHidingPre[k]);
9054
9055 locals->cursor_bw_pre[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * locals->VRatioPrefetchY[k];
9056
9057#ifdef __DML_VBA_DEBUG__
9058 dml_print("DML::%s: k=%0u DPPPerSurface=%u\n", __func__, k, mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k]);
9059 dml_print("DML::%s: k=%0u UrgBurstFactorLuma=%f\n", __func__, k, locals->UrgBurstFactorLuma[k]);
9060 dml_print("DML::%s: k=%0u UrgBurstFactorChroma=%f\n", __func__, k, locals->UrgBurstFactorChroma[k]);
9061 dml_print("DML::%s: k=%0u UrgBurstFactorLumaPre=%f\n", __func__, k, locals->UrgBurstFactorLumaPre[k]);
9062 dml_print("DML::%s: k=%0u UrgBurstFactorChromaPre=%f\n", __func__, k, locals->UrgBurstFactorChromaPre[k]);
9063
9064 dml_print("DML::%s: k=%0u VRatioPrefetchY=%f\n", __func__, k, locals->VRatioPrefetchY[k]);
9065 dml_print("DML::%s: k=%0u VRatioY=%f\n", __func__, k, mode_lib->ms.cache_display_cfg.plane.VRatio[k]);
9066
9067 dml_print("DML::%s: k=%0u prefetch_vmrow_bw=%f\n", __func__, k, locals->prefetch_vmrow_bw[k]);
9068 dml_print("DML::%s: k=%0u ReadBandwidthSurfaceLuma=%f\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
9069 dml_print("DML::%s: k=%0u ReadBandwidthSurfaceChroma=%f\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
9070 dml_print("DML::%s: k=%0u cursor_bw=%f\n", __func__, k, locals->cursor_bw[k]);
9071 dml_print("DML::%s: k=%0u meta_row_bw=%f\n", __func__, k, locals->meta_row_bw[k]);
9072 dml_print("DML::%s: k=%0u dpte_row_bw=%f\n", __func__, k, locals->dpte_row_bw[k]);
9073 dml_print("DML::%s: k=%0u RequiredPrefetchPixDataBWLuma=%f\n", __func__, k, locals->RequiredPrefetchPixDataBWLuma[k]);
9074 dml_print("DML::%s: k=%0u RequiredPrefetchPixDataBWChroma=%f\n", __func__, k, locals->RequiredPrefetchPixDataBWChroma[k]);
9075 dml_print("DML::%s: k=%0u cursor_bw_pre=%f\n", __func__, k, locals->cursor_bw_pre[k]);
9076 dml_print("DML::%s: k=%0u MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k, s->MaxTotalRDBandwidthNoUrgentBurst);
9077#endif
9078 if (locals->DestinationLinesForPrefetch[k] < 2)
9079 s->DestinationLineTimesForPrefetchLessThan2 = true;
9080
9081 if (locals->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
9082 locals->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
9083 ((s->VStartupLines < s->MaxVStartupLines[k] || mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal == 0) &&
9084 (locals->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE__ || locals->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE__)))
9085 s->VRatioPrefetchMoreThanMax = true;
9086
9087 //dml_bool_t DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
9088 //dml_bool_t DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
9089 //if (locals->DestinationLinesToRequestVMInVBlank[k] >= 32) {
9090 // DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
9091 //}
9092
9093 //if (locals->DestinationLinesToRequestRowInVBlank[k] >= 16) {
9094 // DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
9095 //}
9096 }
9097
9098 locals->FractionOfUrgentBandwidth = s->MaxTotalRDBandwidthNoUrgentBurst / mode_lib->ms.ReturnBW;
9099
9100#ifdef __DML_VBA_DEBUG__
9101 dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f \n", __func__, s->MaxTotalRDBandwidthNoUrgentBurst);
9102 dml_print("DML::%s: ReturnBW=%f \n", __func__, mode_lib->ms.ReturnBW);
9103 dml_print("DML::%s: FractionOfUrgentBandwidth=%f \n", __func__, locals->FractionOfUrgentBandwidth);
9104#endif
9105
9106 CalculatePrefetchBandwithSupport(
9107 mode_lib->ms.num_active_planes,
9108 mode_lib->ms.ReturnBW,
9109 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9110 locals->NoUrgentLatencyHidingPre,
9111 locals->ReadBandwidthSurfaceLuma,
9112 locals->ReadBandwidthSurfaceChroma,
9113 locals->RequiredPrefetchPixDataBWLuma,
9114 locals->RequiredPrefetchPixDataBWChroma,
9115 locals->cursor_bw,
9116 locals->meta_row_bw,
9117 locals->dpte_row_bw,
9118 locals->cursor_bw_pre,
9119 locals->prefetch_vmrow_bw,
9120 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9121 locals->UrgBurstFactorLuma,
9122 locals->UrgBurstFactorChroma,
9123 locals->UrgBurstFactorCursor,
9124 locals->UrgBurstFactorLumaPre,
9125 locals->UrgBurstFactorChromaPre,
9126 locals->UrgBurstFactorCursorPre,
9127
9128 /* output */
9129 &s->MaxTotalRDBandwidth, // dml_float_t *PrefetchBandwidth
9130 &s->MaxTotalRDBandwidthNotIncludingMALLPrefetch, // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
9131 &s->dummy_single[0], // dml_float_t *FractionOfUrgentBandwidth
9132 &locals->PrefetchModeSupported);
9133
9134 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
9135 s->dummy_unit_vector[k] = 1.0;
9136
9137 CalculatePrefetchBandwithSupport(mode_lib->ms.num_active_planes,
9138 mode_lib->ms.ReturnBW,
9139 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9140 locals->NoUrgentLatencyHidingPre,
9141 locals->ReadBandwidthSurfaceLuma,
9142 locals->ReadBandwidthSurfaceChroma,
9143 locals->RequiredPrefetchPixDataBWLuma,
9144 locals->RequiredPrefetchPixDataBWChroma,
9145 locals->cursor_bw,
9146 locals->meta_row_bw,
9147 locals->dpte_row_bw,
9148 locals->cursor_bw_pre,
9149 locals->prefetch_vmrow_bw,
9150 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9151 s->dummy_unit_vector,
9152 s->dummy_unit_vector,
9153 s->dummy_unit_vector,
9154 s->dummy_unit_vector,
9155 s->dummy_unit_vector,
9156 s->dummy_unit_vector,
9157
9158 /* output */
9159 &s->NonUrgentMaxTotalRDBandwidth, // dml_float_t *PrefetchBandwidth
9160 &s->NonUrgentMaxTotalRDBandwidthNotIncludingMALLPrefetch, // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
9161 &locals->FractionOfUrgentBandwidth,
9162 &s->dummy_boolean[0]); // dml_bool_t *PrefetchBandwidthSupport
9163
9164 if (s->VRatioPrefetchMoreThanMax != false || s->DestinationLineTimesForPrefetchLessThan2 != false) {
9165 dml_print("DML::%s: VRatioPrefetchMoreThanMax = %u\n", __func__, s->VRatioPrefetchMoreThanMax);
9166 dml_print("DML::%s: DestinationLineTimesForPrefetchLessThan2 = %u\n", __func__, s->DestinationLineTimesForPrefetchLessThan2);
9167 locals->PrefetchModeSupported = false;
9168 }
9169
9170 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9171 if (locals->NoTimeToPrefetch[k] == true || locals->NotEnoughTimeForDynamicMetadata[k]) {
9172 dml_print("DML::%s: k=%u, NoTimeToPrefetch = %0d\n", __func__, k, locals->NoTimeToPrefetch[k]);
9173 dml_print("DML::%s: k=%u, NotEnoughTimeForDynamicMetadata=%u\n", __func__, k, locals->NotEnoughTimeForDynamicMetadata[k]);
9174 locals->PrefetchModeSupported = false;
9175 }
9176 }
9177
9178 if (locals->PrefetchModeSupported == true && mode_lib->ms.support.ImmediateFlipSupport == true) {
9179 locals->BandwidthAvailableForImmediateFlip = CalculateBandwidthAvailableForImmediateFlip(
9180 mode_lib->ms.num_active_planes,
9181 mode_lib->ms.ReturnBW,
9182 locals->ReadBandwidthSurfaceLuma,
9183 locals->ReadBandwidthSurfaceChroma,
9184 locals->RequiredPrefetchPixDataBWLuma,
9185 locals->RequiredPrefetchPixDataBWChroma,
9186 locals->cursor_bw,
9187 locals->cursor_bw_pre,
9188 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9189 locals->UrgBurstFactorLuma,
9190 locals->UrgBurstFactorChroma,
9191 locals->UrgBurstFactorCursor,
9192 locals->UrgBurstFactorLumaPre,
9193 locals->UrgBurstFactorChromaPre,
9194 locals->UrgBurstFactorCursorPre);
9195
9196 locals->TotImmediateFlipBytes = 0;
9197 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9198 if (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) {
9199 locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * (locals->PDEAndMetaPTEBytesFrame[k] + locals->MetaRowByte[k]);
9200 if (locals->use_one_row_for_frame_flip[k]) {
9201 locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * (2 * locals->PixelPTEBytesPerRow[k]);
9202 } else {
9203 locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * locals->PixelPTEBytesPerRow[k];
9204 }
9205#ifdef __DML_VBA_DEBUG__
9206 dml_print("DML::%s: k = %u\n", __func__, k);
9207 dml_print("DML::%s: DPPPerSurface = %u\n", __func__, mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k]);
9208 dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, locals->PDEAndMetaPTEBytesFrame[k]);
9209 dml_print("DML::%s: MetaRowByte = %u\n", __func__, locals->MetaRowByte[k]);
9210 dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, locals->PixelPTEBytesPerRow[k]);
9211 dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, locals->TotImmediateFlipBytes);
9212#endif
9213 }
9214 }
9215 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9216 CalculateFlipSchedule(
9217 s->HostVMInefficiencyFactor,
9218 locals->UrgentExtraLatency,
9219 locals->UrgentLatency,
9220 mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
9221 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
9222 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels,
9223 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9224 mode_lib->ms.soc.hostvm_min_page_size_kbytes,
9225 locals->PDEAndMetaPTEBytesFrame[k],
9226 locals->MetaRowByte[k],
9227 locals->PixelPTEBytesPerRow[k],
9228 locals->BandwidthAvailableForImmediateFlip,
9229 locals->TotImmediateFlipBytes,
9230 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
9231 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
9232 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
9233 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
9234 locals->Tno_bw[k],
9235 mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
9236 locals->dpte_row_height[k],
9237 locals->meta_row_height[k],
9238 locals->dpte_row_height_chroma[k],
9239 locals->meta_row_height_chroma[k],
9240 locals->use_one_row_for_frame_flip[k],
9241
9242 /* Output */
9243 &locals->DestinationLinesToRequestVMInImmediateFlip[k],
9244 &locals->DestinationLinesToRequestRowInImmediateFlip[k],
9245 &locals->final_flip_bw[k],
9246 &locals->ImmediateFlipSupportedForPipe[k]);
9247 }
9248
9249 CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
9250 mode_lib->ms.ReturnBW,
9251 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9252 mode_lib->ms.policy.ImmediateFlipRequirement,
9253 locals->final_flip_bw,
9254 locals->ReadBandwidthSurfaceLuma,
9255 locals->ReadBandwidthSurfaceChroma,
9256 locals->RequiredPrefetchPixDataBWLuma,
9257 locals->RequiredPrefetchPixDataBWChroma,
9258 locals->cursor_bw,
9259 locals->meta_row_bw,
9260 locals->dpte_row_bw,
9261 locals->cursor_bw_pre,
9262 locals->prefetch_vmrow_bw,
9263 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9264 locals->UrgBurstFactorLuma,
9265 locals->UrgBurstFactorChroma,
9266 locals->UrgBurstFactorCursor,
9267 locals->UrgBurstFactorLumaPre,
9268 locals->UrgBurstFactorChromaPre,
9269 locals->UrgBurstFactorCursorPre,
9270
9271 /* output */
9272 &locals->total_dcn_read_bw_with_flip, // dml_float_t *TotalBandwidth
9273 &locals->total_dcn_read_bw_with_flip_not_including_MALL_prefetch, // dml_float_t TotalBandwidthNotIncludingMALLPrefetch
9274 &s->dummy_single[0], // dml_float_t *FractionOfUrgentBandwidth
9275 &locals->ImmediateFlipSupported); // dml_bool_t *ImmediateFlipBandwidthSupport
9276
9277 CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
9278 mode_lib->ms.ReturnBW,
9279 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9280 mode_lib->ms.policy.ImmediateFlipRequirement,
9281 locals->final_flip_bw,
9282 locals->ReadBandwidthSurfaceLuma,
9283 locals->ReadBandwidthSurfaceChroma,
9284 locals->RequiredPrefetchPixDataBWLuma,
9285 locals->RequiredPrefetchPixDataBWChroma,
9286 locals->cursor_bw,
9287 locals->meta_row_bw,
9288 locals->dpte_row_bw,
9289 locals->cursor_bw_pre,
9290 locals->prefetch_vmrow_bw,
9291 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9292 s->dummy_unit_vector,
9293 s->dummy_unit_vector,
9294 s->dummy_unit_vector,
9295 s->dummy_unit_vector,
9296 s->dummy_unit_vector,
9297 s->dummy_unit_vector,
9298
9299 /* output */
9300 &locals->non_urgent_total_dcn_read_bw_with_flip, // dml_float_t *TotalBandwidth
9301 &locals->non_urgent_total_dcn_read_bw_with_flip_not_including_MALL_prefetch, // dml_float_t TotalBandwidthNotIncludingMALLPrefetch
9302 &locals->FractionOfUrgentBandwidthImmediateFlip, // dml_float_t *FractionOfUrgentBandwidth
9303 &s->dummy_boolean[0]); // dml_bool_t *ImmediateFlipBandwidthSupport
9304
9305 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9306 if (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required && locals->ImmediateFlipSupportedForPipe[k] == false) {
9307 locals->ImmediateFlipSupported = false;
9308#ifdef __DML_VBA_DEBUG__
5509e596 9309 dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
7966f319
QZ		 9310#endif
9311 }
9312 }
9313 } else {
9314 locals->ImmediateFlipSupported = false;
9315 locals->total_dcn_read_bw_with_flip = s->MaxTotalRDBandwidth;
9316 locals->total_dcn_read_bw_with_flip_not_including_MALL_prefetch = s->MaxTotalRDBandwidthNotIncludingMALLPrefetch;
9317 locals->non_urgent_total_dcn_read_bw_with_flip = s->NonUrgentMaxTotalRDBandwidth;
9318 locals->non_urgent_total_dcn_read_bw_with_flip_not_including_MALL_prefetch = s->NonUrgentMaxTotalRDBandwidthNotIncludingMALLPrefetch;
9319 }
9320
9321 /* consider flip support is okay if the flip bw is ok or (when user does't require a iflip and there is no host vm) */
9322 locals->PrefetchAndImmediateFlipSupported = (locals->PrefetchModeSupported == true &&
9323 ((!mode_lib->ms.support.ImmediateFlipSupport && !mode_lib->ms.cache_display_cfg.plane.HostVMEnable && !s->ImmediateFlipRequirementFinal) ||
9324 locals->ImmediateFlipSupported)) ? true : false;
9325
9326#ifdef __DML_VBA_DEBUG__
9327 dml_print("DML::%s: PrefetchModeSupported = %u\n", __func__, locals->PrefetchModeSupported);
9328 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
9329 dml_print("DML::%s: ImmediateFlipRequirement[%u] = %u\n", __func__, k, mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
9330 dml_print("DML::%s: HostVMEnable = %u\n", __func__, mode_lib->ms.cache_display_cfg.plane.HostVMEnable);
9331 dml_print("DML::%s: ImmediateFlipSupport = %u (from mode_support)\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
9332 dml_print("DML::%s: ImmediateFlipSupported = %u\n", __func__, locals->ImmediateFlipSupported);
9333 dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %u\n", __func__, locals->PrefetchAndImmediateFlipSupported);
9334#endif
9335 dml_print("DML::%s: Done one iteration: VStartupLines=%u, MaxVStartupAllPlanes=%u\n", __func__, s->VStartupLines, s->MaxVStartupAllPlanes);
9336
9337 s->VStartupLines = s->VStartupLines + 1;
9338
9339 if (s->VStartupLines > s->MaxVStartupAllPlanes) {
9340 s->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
9341
9342 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
9343 s->NextPrefetchMode[k] = s->NextPrefetchMode[k] + 1;
9344
9345 if (s->NextPrefetchMode[k] <= s->MaxPrefetchMode[k])
9346 s->AllPrefetchModeTested = false;
9347 dml_print("DML::%s: VStartupLines=%u, reaches max vstartup, try next prefetch mode=%u\n", __func__, s->VStartupLines-1, s->AllPrefetchModeTested);
9348 }
9349 } else {
9350 s->AllPrefetchModeTested = false;
9351 }
9352 s->iteration++;
9353 if (s->iteration > 2500) {
9354 dml_print("ERROR: DML::%s: Too many errors, exit now\n", __func__);
9355 ASSERT(0);
9356 }
9357 } while (!(locals->PrefetchAndImmediateFlipSupported || s->AllPrefetchModeTested));
9358
9359 if (locals->PrefetchAndImmediateFlipSupported) {
9360 dml_print("DML::%s: Good, Prefetch and flip scheduling solution found at VStartupLines=%u (MaxVStartupAllPlanes=%u)\n", __func__, s->VStartupLines-1, s->MaxVStartupAllPlanes);
9361 } else {
5509e596 9362 dml_print("DML::%s: Bad, Prefetch and flip scheduling solution did NOT find solution! (MaxVStartupAllPlanes=%u)\n", __func__, s->MaxVStartupAllPlanes);
7966f319
QZ		 9363 }
9364
9365 //Watermarks and NB P-State/DRAM Clock Change Support
9366 {
9367 s->mmSOCParameters.UrgentLatency = locals->UrgentLatency;
9368 s->mmSOCParameters.ExtraLatency = locals->UrgentExtraLatency;
9369 s->mmSOCParameters.WritebackLatency = mode_lib->ms.state.writeback_latency_us;
9370 s->mmSOCParameters.DRAMClockChangeLatency = mode_lib->ms.state.dram_clock_change_latency_us;
9371 s->mmSOCParameters.FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
9372 s->mmSOCParameters.SRExitTime = mode_lib->ms.state.sr_exit_time_us;
9373 s->mmSOCParameters.SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
9374 s->mmSOCParameters.SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
9375 s->mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->ms.state.sr_enter_plus_exit_z8_time_us;
9376 s->mmSOCParameters.USRRetrainingLatency = mode_lib->ms.state.usr_retraining_latency_us;
9377 s->mmSOCParameters.SMNLatency = mode_lib->ms.soc.smn_latency_us;
9378
9379 CalculateWatermarks_params->USRRetrainingRequiredFinal = mode_lib->ms.policy.USRRetrainingRequiredFinal;
9380 CalculateWatermarks_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
9381 CalculateWatermarks_params->PrefetchMode = locals->PrefetchMode;
9382 CalculateWatermarks_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
9383 CalculateWatermarks_params->MaxLineBufferLines = mode_lib->ms.ip.max_line_buffer_lines;
9384 CalculateWatermarks_params->LineBufferSize = mode_lib->ms.ip.line_buffer_size_bits;
9385 CalculateWatermarks_params->WritebackInterfaceBufferSize = mode_lib->ms.ip.writeback_interface_buffer_size_kbytes;
9386 CalculateWatermarks_params->DCFCLK = locals->Dcfclk;
9387 CalculateWatermarks_params->ReturnBW = mode_lib->ms.ReturnBW;
9388 CalculateWatermarks_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
9389 CalculateWatermarks_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
9390 CalculateWatermarks_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
9391 CalculateWatermarks_params->dpte_group_bytes = locals->dpte_group_bytes;
9392 CalculateWatermarks_params->meta_row_height = locals->meta_row_height;
9393 CalculateWatermarks_params->meta_row_height_chroma = locals->meta_row_height_chroma;
9394 CalculateWatermarks_params->mmSOCParameters = s->mmSOCParameters;
9395 CalculateWatermarks_params->WritebackChunkSize = mode_lib->ms.ip.writeback_chunk_size_kbytes;
9396 CalculateWatermarks_params->SOCCLK = mode_lib->ms.SOCCLK;
9397 CalculateWatermarks_params->DCFClkDeepSleep = locals->DCFCLKDeepSleep;
9398 CalculateWatermarks_params->DETBufferSizeY = locals->DETBufferSizeY;
9399 CalculateWatermarks_params->DETBufferSizeC = locals->DETBufferSizeC;
9400 CalculateWatermarks_params->SwathHeightY = locals->SwathHeightY;
9401 CalculateWatermarks_params->SwathHeightC = locals->SwathHeightC;
9402 CalculateWatermarks_params->LBBitPerPixel = mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel;
9403 CalculateWatermarks_params->SwathWidthY = locals->SwathWidthY;
9404 CalculateWatermarks_params->SwathWidthC = locals->SwathWidthC;
9405 CalculateWatermarks_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
9406 CalculateWatermarks_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
9407 CalculateWatermarks_params->VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps;
9408 CalculateWatermarks_params->VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma;
9409 CalculateWatermarks_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
9410 CalculateWatermarks_params->VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma;
9411 CalculateWatermarks_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
9412 CalculateWatermarks_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
9413 CalculateWatermarks_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
9414 CalculateWatermarks_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
9415 CalculateWatermarks_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
9416 CalculateWatermarks_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
9417 CalculateWatermarks_params->BytePerPixelDETY = locals->BytePerPixelDETY;
9418 CalculateWatermarks_params->BytePerPixelDETC = locals->BytePerPixelDETC;
9419 CalculateWatermarks_params->DSTXAfterScaler = locals->DSTXAfterScaler;
9420 CalculateWatermarks_params->DSTYAfterScaler = locals->DSTYAfterScaler;
9421 CalculateWatermarks_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
9422 CalculateWatermarks_params->WritebackPixelFormat = mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat;
9423 CalculateWatermarks_params->WritebackDestinationWidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth;
9424 CalculateWatermarks_params->WritebackDestinationHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight;
9425 CalculateWatermarks_params->WritebackSourceHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight;
9426 CalculateWatermarks_params->UnboundedRequestEnabled = locals->UnboundedRequestEnabled;
9427 CalculateWatermarks_params->CompressedBufferSizeInkByte = locals->CompressedBufferSizeInkByte;
9428
9429 // Output
9430 CalculateWatermarks_params->Watermark = &s->dummy_watermark; // Watermarks *Watermark
9431 CalculateWatermarks_params->DRAMClockChangeSupport = &mode_lib->ms.support.DRAMClockChangeSupport[j];
9432 CalculateWatermarks_params->MaxActiveDRAMClockChangeLatencySupported = &s->dummy_single_array[0][0]; // dml_float_t *MaxActiveDRAMClockChangeLatencySupported[]
9433 CalculateWatermarks_params->SubViewportLinesNeededInMALL = &mode_lib->ms.SubViewportLinesNeededInMALL[j]; // dml_uint_t SubViewportLinesNeededInMALL[]
9434 CalculateWatermarks_params->FCLKChangeSupport = &mode_lib->ms.support.FCLKChangeSupport[j];
9435 CalculateWatermarks_params->MaxActiveFCLKChangeLatencySupported = &s->dummy_single[0]; // dml_float_t *MaxActiveFCLKChangeLatencySupported
9436 CalculateWatermarks_params->USRRetrainingSupport = &mode_lib->ms.support.USRRetrainingSupport[j];
9437
9438 CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
9439 &mode_lib->scratch,
9440 CalculateWatermarks_params);
9441
9442 /* Copy the calculated watermarks to mp.Watermark as the getter functions are
9443 * implemented by the DML team to copy the calculated values from the mp.Watermark interface.
9444 */
9445 memcpy(&mode_lib->mp.Watermark, CalculateWatermarks_params->Watermark, sizeof(struct Watermarks));
9446
9447 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9448 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
9449 locals->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0, locals->VStartupMin[k] * mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
9450 mode_lib->ms.cache_display_cfg.timing.PixelClock[k] - locals->Watermark.WritebackDRAMClockChangeWatermark);
9451 locals->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0, locals->VStartupMin[k] * mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
9452 mode_lib->ms.cache_display_cfg.timing.PixelClock[k] - locals->Watermark.WritebackFCLKChangeWatermark);
9453 } else {
9454 locals->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
9455 locals->WritebackAllowFCLKChangeEndPosition[k] = 0;
9456 }
9457 }
9458 }
9459
9460 //Display Pipeline Delivery Time in Prefetch, Groups
9461 CalculatePixelDeliveryTimes(
9462 mode_lib->ms.num_active_planes,
9463 mode_lib->ms.cache_display_cfg.plane.VRatio,
9464 mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
9465 locals->VRatioPrefetchY,
9466 locals->VRatioPrefetchC,
9467 locals->swath_width_luma_ub,
9468 locals->swath_width_chroma_ub,
9469 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9470 mode_lib->ms.cache_display_cfg.plane.HRatio,
9471 mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
9472 mode_lib->ms.cache_display_cfg.timing.PixelClock,
9473 locals->PSCL_THROUGHPUT,
9474 locals->PSCL_THROUGHPUT_CHROMA,
9475 locals->Dppclk,
9476 locals->BytePerPixelC,
9477 mode_lib->ms.cache_display_cfg.plane.SourceScan,
9478 mode_lib->ms.cache_display_cfg.plane.NumberOfCursors,
9479 mode_lib->ms.cache_display_cfg.plane.CursorWidth,
9480 mode_lib->ms.cache_display_cfg.plane.CursorBPP,
9481 locals->BlockWidth256BytesY,
9482 locals->BlockHeight256BytesY,
9483 locals->BlockWidth256BytesC,
9484 locals->BlockHeight256BytesC,
9485
9486 /* Output */
9487 locals->DisplayPipeLineDeliveryTimeLuma,
9488 locals->DisplayPipeLineDeliveryTimeChroma,
9489 locals->DisplayPipeLineDeliveryTimeLumaPrefetch,
9490 locals->DisplayPipeLineDeliveryTimeChromaPrefetch,
9491 locals->DisplayPipeRequestDeliveryTimeLuma,
9492 locals->DisplayPipeRequestDeliveryTimeChroma,
9493 locals->DisplayPipeRequestDeliveryTimeLumaPrefetch,
9494 locals->DisplayPipeRequestDeliveryTimeChromaPrefetch,
9495 locals->CursorRequestDeliveryTime,
9496 locals->CursorRequestDeliveryTimePrefetch);
9497
9498 CalculateMetaAndPTETimes(
9499 locals->use_one_row_for_frame,
9500 mode_lib->ms.num_active_planes,
9501 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9502 mode_lib->ms.ip.meta_chunk_size_kbytes,
9503 mode_lib->ms.ip.min_meta_chunk_size_bytes,
9504 mode_lib->ms.cache_display_cfg.timing.HTotal,
9505 mode_lib->ms.cache_display_cfg.plane.VRatio,
9506 mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
9507 locals->DestinationLinesToRequestRowInVBlank,
9508 locals->DestinationLinesToRequestRowInImmediateFlip,
9509 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9510 mode_lib->ms.cache_display_cfg.timing.PixelClock,
9511 locals->BytePerPixelY,
9512 locals->BytePerPixelC,
9513 mode_lib->ms.cache_display_cfg.plane.SourceScan,
9514 locals->dpte_row_height,
9515 locals->dpte_row_height_chroma,
9516 locals->meta_row_width,
9517 locals->meta_row_width_chroma,
9518 locals->meta_row_height,
9519 locals->meta_row_height_chroma,
9520 locals->meta_req_width,
9521 locals->meta_req_width_chroma,
9522 locals->meta_req_height,
9523 locals->meta_req_height_chroma,
9524 locals->dpte_group_bytes,
9525 locals->PTERequestSizeY,
9526 locals->PTERequestSizeC,
9527 locals->PixelPTEReqWidthY,
9528 locals->PixelPTEReqHeightY,
9529 locals->PixelPTEReqWidthC,
9530 locals->PixelPTEReqHeightC,
9531 locals->dpte_row_width_luma_ub,
9532 locals->dpte_row_width_chroma_ub,
9533
9534 /* Output */
9535 locals->DST_Y_PER_PTE_ROW_NOM_L,
9536 locals->DST_Y_PER_PTE_ROW_NOM_C,
9537 locals->DST_Y_PER_META_ROW_NOM_L,
9538 locals->DST_Y_PER_META_ROW_NOM_C,
9539 locals->TimePerMetaChunkNominal,
9540 locals->TimePerChromaMetaChunkNominal,
9541 locals->TimePerMetaChunkVBlank,
9542 locals->TimePerChromaMetaChunkVBlank,
9543 locals->TimePerMetaChunkFlip,
9544 locals->TimePerChromaMetaChunkFlip,
9545 locals->time_per_pte_group_nom_luma,
9546 locals->time_per_pte_group_vblank_luma,
9547 locals->time_per_pte_group_flip_luma,
9548 locals->time_per_pte_group_nom_chroma,
9549 locals->time_per_pte_group_vblank_chroma,
9550 locals->time_per_pte_group_flip_chroma);
9551
9552 CalculateVMGroupAndRequestTimes(
9553 mode_lib->ms.num_active_planes,
9554 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9555 mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
9556 mode_lib->ms.cache_display_cfg.timing.HTotal,
9557 locals->BytePerPixelC,
9558 locals->DestinationLinesToRequestVMInVBlank,
9559 locals->DestinationLinesToRequestVMInImmediateFlip,
9560 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9561 mode_lib->ms.cache_display_cfg.timing.PixelClock,
9562 locals->dpte_row_width_luma_ub,
9563 locals->dpte_row_width_chroma_ub,
9564 locals->vm_group_bytes,
9565 locals->dpde0_bytes_per_frame_ub_l,
9566 locals->dpde0_bytes_per_frame_ub_c,
9567 locals->meta_pte_bytes_per_frame_ub_l,
9568 locals->meta_pte_bytes_per_frame_ub_c,
9569
9570 /* Output */
9571 locals->TimePerVMGroupVBlank,
9572 locals->TimePerVMGroupFlip,
9573 locals->TimePerVMRequestVBlank,
9574 locals->TimePerVMRequestFlip);
9575
9576 // Min TTUVBlank
9577 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9578 if (locals->PrefetchMode[k] == 0) {
9579 locals->MinTTUVBlank[k] = dml_max4(
9580 locals->Watermark.DRAMClockChangeWatermark,
9581 locals->Watermark.FCLKChangeWatermark,
9582 locals->Watermark.StutterEnterPlusExitWatermark,
9583 locals->Watermark.UrgentWatermark);
9584 } else if (locals->PrefetchMode[k] == 1) {
9585 locals->MinTTUVBlank[k] = dml_max3(
9586 locals->Watermark.FCLKChangeWatermark,
9587 locals->Watermark.StutterEnterPlusExitWatermark,
9588 locals->Watermark.UrgentWatermark);
9589 } else if (locals->PrefetchMode[k] == 2) {
9590 locals->MinTTUVBlank[k] = dml_max(
9591 locals->Watermark.StutterEnterPlusExitWatermark,
9592 locals->Watermark.UrgentWatermark);
9593 } else {
9594 locals->MinTTUVBlank[k] = locals->Watermark.UrgentWatermark;
9595 }
9596 if (!mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k])
9597 locals->MinTTUVBlank[k] = locals->TCalc + locals->MinTTUVBlank[k];
9598 }
9599
9600 // DCC Configuration
9601 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9602#ifdef __DML_VBA_DEBUG__
9603 dml_print("DML::%s: Calculate DCC configuration for surface k=%u\n", __func__, k);
9604#endif
9605 CalculateDCCConfiguration(
9606 mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
9607 mode_lib->ms.policy.DCCProgrammingAssumesScanDirectionUnknownFinal,
9608 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
9609 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k],
9610 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k],
9611 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY[k],
9612 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC[k],
9613 mode_lib->ms.NomDETInKByte,
9614 locals->BlockHeight256BytesY[k],
9615 locals->BlockHeight256BytesC[k],
9616 mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
9617 locals->BytePerPixelY[k],
9618 locals->BytePerPixelC[k],
9619 locals->BytePerPixelDETY[k],
9620 locals->BytePerPixelDETC[k],
9621 mode_lib->ms.cache_display_cfg.plane.SourceScan[k],
9622 /* Output */
9623 &locals->DCCYMaxUncompressedBlock[k],
9624 &locals->DCCCMaxUncompressedBlock[k],
9625 &locals->DCCYMaxCompressedBlock[k],
9626 &locals->DCCCMaxCompressedBlock[k],
9627 &locals->DCCYIndependentBlock[k],
9628 &locals->DCCCIndependentBlock[k]);
9629 }
9630
9631 // VStartup Adjustment
9632 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9633 s->Tvstartup_margin = (s->MaxVStartupLines[k] - locals->VStartupMin[k]) * mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
9634#ifdef __DML_VBA_DEBUG__
9635 dml_print("DML::%s: k=%u, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k, locals->MinTTUVBlank[k]);
9636#endif
9637
9638 locals->MinTTUVBlank[k] = locals->MinTTUVBlank[k] + s->Tvstartup_margin;
9639
9640#ifdef __DML_VBA_DEBUG__
9641 dml_print("DML::%s: k=%u, Tvstartup_margin = %f\n", __func__, k, s->Tvstartup_margin);
9642 dml_print("DML::%s: k=%u, MaxVStartupLines = %u\n", __func__, k, s->MaxVStartupLines[k]);
9643 dml_print("DML::%s: k=%u, MinTTUVBlank = %f\n", __func__, k, locals->MinTTUVBlank[k]);
9644#endif
9645
9646 locals->Tdmdl[k] = locals->Tdmdl[k] + s->Tvstartup_margin;
9647 if (mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k] && mode_lib->ms.ip.dynamic_metadata_vm_enabled) {
9648 locals->Tdmdl_vm[k] = locals->Tdmdl_vm[k] + s->Tvstartup_margin;
9649 }
9650
9651 isInterlaceTiming = (mode_lib->ms.cache_display_cfg.timing.Interlace[k] && !mode_lib->ms.ip.ptoi_supported);
9652
9653 // The actual positioning of the vstartup
9654 locals->VStartup[k] = (isInterlaceTiming ? (2 * s->MaxVStartupLines[k]) : s->MaxVStartupLines[k]);
9655
9656 s->dlg_vblank_start = ((isInterlaceTiming ? dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]) / 2.0, 1.0) :
9657 mode_lib->ms.cache_display_cfg.timing.VTotal[k]) - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]);
9658 s->LSetup = dml_floor(4.0 * locals->TSetup[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0) / 4.0;
9659 s->blank_lines_remaining = (mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k]) - locals->VStartup[k];
9660
9661 if (s->blank_lines_remaining < 0) {
9662 dml_print("ERROR: Vstartup is larger than vblank!?\n");
9663 s->blank_lines_remaining = 0;
9664 ASSERT(0);
9665 }
9666 locals->MIN_DST_Y_NEXT_START[k] = s->dlg_vblank_start + s->blank_lines_remaining + s->LSetup;
9667
9668 // debug only
9669 s->old_MIN_DST_Y_NEXT_START = ((isInterlaceTiming ? dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]) / 2.0, 1.0) :
9670 mode_lib->ms.cache_display_cfg.timing.VTotal[k]) - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k])
9671 + dml_max(1.0, dml_ceil((dml_float_t) locals->WritebackDelay[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0))
9672 + dml_floor(4.0 * locals->TSetup[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0) / 4.0;
9673
9674 if (((locals->VUpdateOffsetPix[k] + locals->VUpdateWidthPix[k] + locals->VReadyOffsetPix[k]) / mode_lib->ms.cache_display_cfg.timing.HTotal[k]) <=
9675 (isInterlaceTiming ?
9676 dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k] - locals->VStartup[k]) / 2.0, 1.0) :
9677 (int) (mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k] - locals->VStartup[k]))) {
9678 locals->VREADY_AT_OR_AFTER_VSYNC[k] = true;
9679 } else {
9680 locals->VREADY_AT_OR_AFTER_VSYNC[k] = false;
9681 }
9682#ifdef __DML_VBA_DEBUG__
9683 dml_print("DML::%s: k=%u, VStartup = %u (max)\n", __func__, k, locals->VStartup[k]);
9684 dml_print("DML::%s: k=%u, VStartupMin = %u (max)\n", __func__, k, locals->VStartupMin[k]);
9685 dml_print("DML::%s: k=%u, VUpdateOffsetPix = %u\n", __func__, k, locals->VUpdateOffsetPix[k]);
9686 dml_print("DML::%s: k=%u, VUpdateWidthPix = %u\n", __func__, k, locals->VUpdateWidthPix[k]);
9687 dml_print("DML::%s: k=%u, VReadyOffsetPix = %u\n", __func__, k, locals->VReadyOffsetPix[k]);
9688 dml_print("DML::%s: k=%u, HTotal = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.HTotal[k]);
9689 dml_print("DML::%s: k=%u, VTotal = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VTotal[k]);
9690 dml_print("DML::%s: k=%u, VActive = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VActive[k]);
9691 dml_print("DML::%s: k=%u, VFrontPorch = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]);
9692 dml_print("DML::%s: k=%u, TSetup = %f\n", __func__, k, locals->TSetup[k]);
9693 dml_print("DML::%s: k=%u, MIN_DST_Y_NEXT_START = %f\n", __func__, k, locals->MIN_DST_Y_NEXT_START[k]);
9694 dml_print("DML::%s: k=%u, MIN_DST_Y_NEXT_START = %f (old)\n", __func__, k, s->old_MIN_DST_Y_NEXT_START);
9695 dml_print("DML::%s: k=%u, VREADY_AT_OR_AFTER_VSYNC = %u\n", __func__, k, locals->VREADY_AT_OR_AFTER_VSYNC[k]);
9696#endif
9697 }
9698
9699 //Maximum Bandwidth Used
9700 s->TotalWRBandwidth = 0;
9701 s->WRBandwidth = 0;
9702 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9703 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true && mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k] == dml_444_32) {
9704 s->WRBandwidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k] /
9705 (mode_lib->ms.cache_display_cfg.timing.HTotal[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 4;
9706 } else if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
9707 s->WRBandwidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k] /
9708 (mode_lib->ms.cache_display_cfg.timing.HTotal[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 8;
9709 }
9710 s->TotalWRBandwidth = s->TotalWRBandwidth + s->WRBandwidth;
9711 }
9712
9713 locals->TotalDataReadBandwidth = 0;
9714 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9715 locals->TotalDataReadBandwidth = locals->TotalDataReadBandwidth + locals->ReadBandwidthSurfaceLuma[k] + locals->ReadBandwidthSurfaceChroma[k];
9716
9717#ifdef __DML_VBA_DEBUG__
9718 dml_print("DML::%s: k=%u, TotalDataReadBandwidth = %f\n", __func__, k, locals->TotalDataReadBandwidth);
9719 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
9720 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceChroma = %f\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
9721#endif
9722 }
9723
9724 locals->TotalDataReadBandwidthNotIncludingMALLPrefetch = 0;
9725 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9726 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
9727 locals->TotalDataReadBandwidthNotIncludingMALLPrefetch = locals->TotalDataReadBandwidthNotIncludingMALLPrefetch
9728 + locals->ReadBandwidthSurfaceLuma[k] + locals->ReadBandwidthSurfaceChroma[k];
9729 }
9730 }
9731
9732 CalculateStutterEfficiency_params->CompressedBufferSizeInkByte = locals->CompressedBufferSizeInkByte;
9733 CalculateStutterEfficiency_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
9734 CalculateStutterEfficiency_params->UnboundedRequestEnabled = locals->UnboundedRequestEnabled;
9735 CalculateStutterEfficiency_params->MetaFIFOSizeInKEntries = mode_lib->ms.ip.meta_fifo_size_in_kentries;
9736 CalculateStutterEfficiency_params->ZeroSizeBufferEntries = mode_lib->ms.ip.zero_size_buffer_entries;
9737 CalculateStutterEfficiency_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
9738 CalculateStutterEfficiency_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
9739 CalculateStutterEfficiency_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
9740 CalculateStutterEfficiency_params->TotalDataReadBandwidth = locals->TotalDataReadBandwidth;
9741 CalculateStutterEfficiency_params->DCFCLK = locals->Dcfclk;
9742 CalculateStutterEfficiency_params->ReturnBW = mode_lib->ms.ReturnBW;
9743 CalculateStutterEfficiency_params->CompbufReservedSpace64B = locals->compbuf_reserved_space_64b;
9744 CalculateStutterEfficiency_params->CompbufReservedSpaceZs = locals->compbuf_reserved_space_zs;
9745 CalculateStutterEfficiency_params->SRExitTime = mode_lib->ms.state.sr_exit_time_us;
9746 CalculateStutterEfficiency_params->SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
9747 CalculateStutterEfficiency_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
9748 CalculateStutterEfficiency_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
9749 CalculateStutterEfficiency_params->StutterEnterPlusExitWatermark = locals->Watermark.StutterEnterPlusExitWatermark;
9750 CalculateStutterEfficiency_params->Z8StutterEnterPlusExitWatermark = locals->Watermark.Z8StutterEnterPlusExitWatermark;
9751 CalculateStutterEfficiency_params->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
9752 CalculateStutterEfficiency_params->Interlace = mode_lib->ms.cache_display_cfg.timing.Interlace;
9753 CalculateStutterEfficiency_params->MinTTUVBlank = locals->MinTTUVBlank;
9754 CalculateStutterEfficiency_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
9755 CalculateStutterEfficiency_params->DETBufferSizeY = locals->DETBufferSizeY;
9756 CalculateStutterEfficiency_params->BytePerPixelY = locals->BytePerPixelY;
9757 CalculateStutterEfficiency_params->BytePerPixelDETY = locals->BytePerPixelDETY;
9758 CalculateStutterEfficiency_params->SwathWidthY = locals->SwathWidthY;
9759 CalculateStutterEfficiency_params->SwathHeightY = locals->SwathHeightY;
9760 CalculateStutterEfficiency_params->SwathHeightC = locals->SwathHeightC;
9761 CalculateStutterEfficiency_params->NetDCCRateLuma = mode_lib->ms.cache_display_cfg.surface.DCCRateLuma;
9762 CalculateStutterEfficiency_params->NetDCCRateChroma = mode_lib->ms.cache_display_cfg.surface.DCCRateChroma;
9763 CalculateStutterEfficiency_params->DCCFractionOfZeroSizeRequestsLuma = mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsLuma;
9764 CalculateStutterEfficiency_params->DCCFractionOfZeroSizeRequestsChroma = mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsChroma;
9765 CalculateStutterEfficiency_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
9766 CalculateStutterEfficiency_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
9767 CalculateStutterEfficiency_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
9768 CalculateStutterEfficiency_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
9769 CalculateStutterEfficiency_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
9770 CalculateStutterEfficiency_params->BlockHeight256BytesY = locals->BlockHeight256BytesY;
9771 CalculateStutterEfficiency_params->BlockWidth256BytesY = locals->BlockWidth256BytesY;
9772 CalculateStutterEfficiency_params->BlockHeight256BytesC = locals->BlockHeight256BytesC;
9773 CalculateStutterEfficiency_params->BlockWidth256BytesC = locals->BlockWidth256BytesC;
9774 CalculateStutterEfficiency_params->DCCYMaxUncompressedBlock = locals->DCCYMaxUncompressedBlock;
9775 CalculateStutterEfficiency_params->DCCCMaxUncompressedBlock = locals->DCCCMaxUncompressedBlock;
9776 CalculateStutterEfficiency_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
9777 CalculateStutterEfficiency_params->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable;
9778 CalculateStutterEfficiency_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
9779 CalculateStutterEfficiency_params->ReadBandwidthSurfaceLuma = locals->ReadBandwidthSurfaceLuma;
9780 CalculateStutterEfficiency_params->ReadBandwidthSurfaceChroma = locals->ReadBandwidthSurfaceChroma;
9781 CalculateStutterEfficiency_params->meta_row_bw = locals->meta_row_bw;
9782 CalculateStutterEfficiency_params->dpte_row_bw = locals->dpte_row_bw;
9783 CalculateStutterEfficiency_params->StutterEfficiencyNotIncludingVBlank = &locals->StutterEfficiencyNotIncludingVBlank;
9784 CalculateStutterEfficiency_params->StutterEfficiency = &locals->StutterEfficiency;
9785 CalculateStutterEfficiency_params->NumberOfStutterBurstsPerFrame = &locals->NumberOfStutterBurstsPerFrame;
9786 CalculateStutterEfficiency_params->Z8StutterEfficiencyNotIncludingVBlank = &locals->Z8StutterEfficiencyNotIncludingVBlank;
9787 CalculateStutterEfficiency_params->Z8StutterEfficiency = &locals->Z8StutterEfficiency;
9788 CalculateStutterEfficiency_params->Z8NumberOfStutterBurstsPerFrame = &locals->Z8NumberOfStutterBurstsPerFrame;
9789 CalculateStutterEfficiency_params->StutterPeriod = &locals->StutterPeriod;
9790 CalculateStutterEfficiency_params->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = &locals->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE;
9791
9792 // Stutter Efficiency
9793 CalculateStutterEfficiency(&mode_lib->scratch,
9794 CalculateStutterEfficiency_params);
9795
9796#ifdef __DML_VBA_ALLOW_DELTA__
9797 {
9798 dml_float_t dummy_single[2];
9799 dml_uint_t dummy_integer[1];
9800 dml_bool_t dummy_boolean[1];
9801
9802 // Calculate z8 stutter eff assuming 0 reserved space
9803 CalculateStutterEfficiency(
9804 locals->CompressedBufferSizeInkByte,
9805 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9806 locals->UnboundedRequestEnabled,
9807 mode_lib->ms.ip.meta_fifo_size_in_kentries,
9808 mode_lib->ms.ip.zero_size_buffer_entries,
9809 mode_lib->ms.ip.pixel_chunk_size_kbytes,
9810 mode_lib->ms.num_active_planes,
9811 mode_lib->ms.ip.rob_buffer_size_kbytes,
9812 locals->TotalDataReadBandwidth,
9813 locals->Dcfclk,
9814 mode_lib->ms.ReturnBW,
9815 0, //mode_lib->ms.ip.compbuf_reserved_space_64b,
9816 0, //mode_lib->ms.ip.compbuf_reserved_space_zs,
9817 mode_lib->ms.state.sr_exit_time_us,
9818 mode_lib->ms.state.sr_exit_z8_time_us,
9819 mode_lib->ms.policy.SynchronizeTimingsFinal,
9820 mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming,
9821 locals->Watermark.StutterEnterPlusExitWatermark,
9822 locals->Watermark.Z8StutterEnterPlusExitWatermark,
9823 mode_lib->ms.ip.ptoi_supported,
9824 mode_lib->ms.cache_display_cfg.timing.Interlace,
9825 locals->MinTTUVBlank,
9826 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9827 mode_lib->ms.DETBufferSizeY,
9828 locals->BytePerPixelY,
9829 locals->BytePerPixelDETY,
9830 locals->SwathWidthY,
9831 mode_lib->ms.SwathHeightY,
9832 mode_lib->ms.SwathHeightC,
9833 mode_lib->ms.cache_display_cfg.surface.DCCRateLuma,
9834 mode_lib->ms.cache_display_cfg.surface.DCCRateChroma,
9835 mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsLuma,
9836 mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsChroma,
9837 mode_lib->ms.cache_display_cfg.timing.HTotal,
9838 mode_lib->ms.cache_display_cfg.timing.VTotal,
9839 mode_lib->ms.cache_display_cfg.timing.PixelClock,
9840 mode_lib->ms.cache_display_cfg.plane.VRatio,
9841 mode_lib->ms.cache_display_cfg.plane.SourceScan,
9842 locals->BlockHeight256BytesY,
9843 locals->BlockWidth256BytesY,
9844 locals->BlockHeight256BytesC,
9845 locals->BlockWidth256BytesC,
9846 locals->DCCYMaxUncompressedBlock,
9847 locals->DCCCMaxUncompressedBlock,
9848 mode_lib->ms.cache_display_cfg.timing.VActive,
9849 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9850 mode_lib->ms.cache_display_cfg.writeback.WritebackEnable,
9851 locals->ReadBandwidthSurfaceLuma,
9852 locals->ReadBandwidthSurfaceChroma,
9853 locals->meta_row_bw,
9854 locals->dpte_row_bw,
9855
9856 /* Output */
9857 &dummy_single[0],
9858 &dummy_single[1],
9859 &dummy_integer[0],
9860 &locals->Z8StutterEfficiencyNotIncludingVBlankBestCase,
9861 &locals->Z8StutterEfficiencyBestCase,
9862 &locals->Z8NumberOfStutterBurstsPerFrameBestCase,
9863 &locals->StutterPeriodBestCase,
9864 &dummy_boolean[0]);
9865 }
9866#else
9867 locals->Z8StutterEfficiencyNotIncludingVBlankBestCase = locals->Z8StutterEfficiencyNotIncludingVBlank;
9868 locals->Z8StutterEfficiencyBestCase = locals->Z8StutterEfficiency;
9869 locals->Z8NumberOfStutterBurstsPerFrameBestCase = locals->Z8NumberOfStutterBurstsPerFrame;
9870 locals->StutterPeriodBestCase = locals->StutterPeriod;
9871#endif
9872
9873#ifdef __DML_VBA_DEBUG__
9874 dml_print("DML::%s: --- END --- \n", __func__);
9875#endif
9876} // dml_core_mode_programming
9877
9878/// Function: dml_core_get_row_heights
9879/// @brief Get row height for DPTE and META with minimal input.
9880void dml_core_get_row_heights(
9881 dml_uint_t *dpte_row_height,
9882 dml_uint_t *meta_row_height,
9883 const struct display_mode_lib_st *mode_lib,
9884 dml_bool_t is_plane1,
9885 enum dml_source_format_class SourcePixelFormat,
9886 enum dml_swizzle_mode SurfaceTiling,
9887 enum dml_rotation_angle ScanDirection,
9888 dml_uint_t pitch,
9889 dml_uint_t GPUVMMinPageSizeKBytes)
9890{
9891 dml_uint_t BytePerPixelY;
9892 dml_uint_t BytePerPixelC;
9893 dml_float_t BytePerPixelInDETY;
9894 dml_float_t BytePerPixelInDETC;
9895 dml_uint_t BlockHeight256BytesY;
9896 dml_uint_t BlockHeight256BytesC;
9897 dml_uint_t BlockWidth256BytesY;
9898 dml_uint_t BlockWidth256BytesC;
9899 dml_uint_t MacroTileWidthY;
9900 dml_uint_t MacroTileWidthC;
9901 dml_uint_t MacroTileHeightY;
9902 dml_uint_t MacroTileHeightC;
9903
9904 dml_uint_t BytePerPixel;
9905 dml_uint_t BlockHeight256Bytes;
9906 dml_uint_t BlockWidth256Bytes;
9907 dml_uint_t MacroTileWidth;
9908 dml_uint_t MacroTileHeight;
9909 dml_uint_t PTEBufferSizeInRequests;
9910
9911 dml_uint_t dummy_integer[16];
9912
9913 CalculateBytePerPixelAndBlockSizes(
9914 SourcePixelFormat,
9915 SurfaceTiling,
9916
9917 /* Output */
9918 &BytePerPixelY,
9919 &BytePerPixelC,
9920 &BytePerPixelInDETY,
9921 &BytePerPixelInDETC,
9922 &BlockHeight256BytesY,
9923 &BlockHeight256BytesC,
9924 &BlockWidth256BytesY,
9925 &BlockWidth256BytesC,
9926 &MacroTileHeightY,
9927 &MacroTileHeightC,
9928 &MacroTileWidthY,
9929 &MacroTileWidthC);
9930
9931 BytePerPixel = is_plane1 ? BytePerPixelC : BytePerPixelY;
9932 BlockHeight256Bytes = is_plane1 ? BlockHeight256BytesC : BlockHeight256BytesY;
9933 BlockWidth256Bytes = is_plane1 ? BlockWidth256BytesC : BlockWidth256BytesY;
9934 MacroTileWidth = is_plane1 ? MacroTileWidthC : MacroTileWidthY;
9935 MacroTileHeight = is_plane1 ? MacroTileHeightC : MacroTileHeightY;
9936 PTEBufferSizeInRequests = is_plane1 ? mode_lib->ip.dpte_buffer_size_in_pte_reqs_chroma : mode_lib->ip.dpte_buffer_size_in_pte_reqs_luma;
9937#ifdef __DML_RQ_DLG_CALC_DEBUG__
9938 dml_print("DML_DLG: %s: is_plane1 = %u\n", __func__, is_plane1);
9939 dml_print("DML_DLG: %s: BytePerPixel = %u\n", __func__, BytePerPixel);
9940 dml_print("DML_DLG: %s: BlockHeight256Bytes = %u\n", __func__, BlockHeight256Bytes);
9941 dml_print("DML_DLG: %s: BlockWidth256Bytes = %u\n", __func__, BlockWidth256Bytes);
9942 dml_print("DML_DLG: %s: MacroTileWidth = %u\n", __func__, MacroTileWidth);
9943 dml_print("DML_DLG: %s: MacroTileHeight = %u\n", __func__, MacroTileHeight);
9944 dml_print("DML_DLG: %s: PTEBufferSizeInRequests = %u\n", __func__, PTEBufferSizeInRequests);
9945 dml_print("DML_DLG: %s: dpte_buffer_size_in_pte_reqs_luma = %u\n", __func__, mode_lib->ip.dpte_buffer_size_in_pte_reqs_luma);
9946 dml_print("DML_DLG: %s: dpte_buffer_size_in_pte_reqs_chroma = %u\n", __func__, mode_lib->ip.dpte_buffer_size_in_pte_reqs_chroma);
9947 dml_print("DML_DLG: %s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
9948#endif
9949
9950 // just suppluy with enough parameters to calculate meta and dte
9951 CalculateVMAndRowBytes(
9952 0, // dml_bool_t ViewportStationary,
9953 1, // dml_bool_t DCCEnable,
9954 1, // dml_uint_t NumberOfDPPs,
9955 BlockHeight256Bytes,
9956 BlockWidth256Bytes,
9957 SourcePixelFormat,
9958 SurfaceTiling,
9959 BytePerPixel,
9960 ScanDirection,
9961 0, // dml_uint_t SwathWidth,
9962 0, // dml_uint_t ViewportHeight, (Note: DML calculates one_row_for_frame height regardless, would need test input if that height is useful)
9963 0, // dml_uint_t ViewportXStart,
9964 0, // dml_uint_t ViewportYStart,
9965 1, // dml_bool_t GPUVMEnable,
9966 4, // dml_uint_t GPUVMMaxPageTableLevels,
9967 GPUVMMinPageSizeKBytes,
9968 PTEBufferSizeInRequests,
9969 pitch,
9970 0, // dml_uint_t DCCMetaPitch,
9971 MacroTileWidth,
9972 MacroTileHeight,
9973
9974 // /* Output */
9975 &dummy_integer[0], // dml_uint_t *MetaRowByte,
9976 &dummy_integer[1], // dml_uint_t *PixelPTEBytesPerRow,
9977 &dummy_integer[2], // dml_uint_t *PixelPTEBytesPerRowStorage,
9978 &dummy_integer[3], // dml_uint_t *dpte_row_width_ub,
9979 dpte_row_height,
9980 &dummy_integer[4], // dml_uint_t *dpte_row_height_linear
9981 &dummy_integer[5], // dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
9982 &dummy_integer[6], // dml_uint_t *dpte_row_width_ub_one_row_per_frame,
9983 &dummy_integer[7], // dml_uint_t *dpte_row_height_one_row_per_frame,
9984 &dummy_integer[8], // dml_uint_t *MetaRequestWidth,
9985 &dummy_integer[9], // dml_uint_t *MetaRequestHeight,
9986 &dummy_integer[10], // dml_uint_t *meta_row_width,
9987 meta_row_height,
9988 &dummy_integer[11], // dml_uint_t *PixelPTEReqWidth,
9989 &dummy_integer[12], // dml_uint_t *PixelPTEReqHeight,
9990 &dummy_integer[13], // dml_uint_t *PTERequestSize,
9991 &dummy_integer[14], // dml_uint_t *DPDE0BytesFrame,
9992 &dummy_integer[15]); // dml_uint_t *MetaPTEBytesFrame)
9993
9994#ifdef __DML_RQ_DLG_CALC_DEBUG__
9995 dml_print("DML_DLG: %s: dpte_row_height = %u\n", __func__, *dpte_row_height);
9996 dml_print("DML_DLG: %s: meta_row_height = %u\n", __func__, *meta_row_height);
9997#endif
9998}
9999
10000static struct soc_state_bounding_box_st dml_get_soc_state_bounding_box(
10001 const struct soc_states_st *states,
10002 dml_uint_t state_idx)
10003{
10004 dml_print("DML::%s: state_idx=%u (num_states=%u)\n", __func__, state_idx, states->num_states);
10005
10006 if (state_idx >= (dml_uint_t)states->num_states) {
10007 dml_print("DML::%s: ERROR: Invalid state_idx=%u! num_states=%u\n", __func__, state_idx, states->num_states);
10008 ASSERT(0);
10009 }
10010 return (states->state_array[state_idx]);
10011}
10012
10013/// @brief Copy the parameters to a calculation struct, it actually only need when the DML needs to have
10014/// the intelligence to re-calculate when any of display cfg, bbox, or policy changes since last calculated.
10015///
10016static void cache_ip_soc_cfg(struct display_mode_lib_st *mode_lib,
10017 dml_uint_t state_idx)
10018{
10019 mode_lib->ms.state_idx = state_idx;
10020 mode_lib->ms.max_state_idx = mode_lib->states.num_states - 1;
10021 mode_lib->ms.soc = mode_lib->soc;
10022 mode_lib->ms.ip = mode_lib->ip;
10023 mode_lib->ms.policy = mode_lib->policy;
10024 mode_lib->ms.state = dml_get_soc_state_bounding_box(&mode_lib->states, state_idx);
10025 mode_lib->ms.max_state = dml_get_soc_state_bounding_box(&mode_lib->states, mode_lib->states.num_states - 1);
10026}
10027
10028static void cache_display_cfg(struct display_mode_lib_st *mode_lib,
10029 const struct dml_display_cfg_st *display_cfg)
10030{
10031 mode_lib->ms.cache_display_cfg = *display_cfg;
10032}
10033
10034static void fetch_socbb_params(struct display_mode_lib_st *mode_lib)
10035{
10036 struct soc_state_bounding_box_st *state = &mode_lib->ms.state;
10037
10038 // Default values, SOCCLK, DRAMSpeed, and FabricClock will be reassigned to the same state value in mode_check step
10039 // If UseMinimumRequiredDCFCLK is used, the DCFCLK will be the min dcflk for the mode support
10040 mode_lib->ms.SOCCLK = (dml_float_t)state->socclk_mhz;
10041 mode_lib->ms.DRAMSpeed = (dml_float_t)state->dram_speed_mts;
10042 mode_lib->ms.FabricClock = (dml_float_t)state->fabricclk_mhz;
10043 mode_lib->ms.DCFCLK = (dml_float_t)state->dcfclk_mhz;
10044}
10045
10046/// @brief Use display_cfg directly for mode_support calculation
10047/// Calculated values and informational output are stored in mode_lib.vba data struct
10048/// The display configuration is described with pipes struct and num_pipes
10049/// This function is used when physical resource mapping is not finalized (for example,
10050/// don't know how many pipes to represent a surface)
10051/// @param mode_lib Contains the bounding box and policy setting.
10052/// @param state_idx Power state index
10053/// @param display_cfg Display configurations. A display
10054dml_bool_t dml_mode_support(
10055 struct display_mode_lib_st *mode_lib,
10056 dml_uint_t state_idx,
10057 const struct dml_display_cfg_st *display_cfg)
10058{
10059 dml_bool_t is_mode_support;
10060
10061 dml_print("DML::%s: ------------- START ----------\n", __func__);
10062 cache_ip_soc_cfg(mode_lib, state_idx);
10063 cache_display_cfg(mode_lib, display_cfg);
10064
10065 fetch_socbb_params(mode_lib);
10066
10067 dml_print("DML::%s: state_idx = %u\n", __func__, state_idx);
10068
10069 is_mode_support = dml_core_mode_support(mode_lib);
10070
10071 dml_print("DML::%s: is_mode_support = %u\n", __func__, is_mode_support);
10072 dml_print("DML::%s: ------------- DONE ----------\n", __func__);
10073 return is_mode_support;
10074}
10075
10076/// @Brief A function to calculate the programming values for DCN DCHUB (Assume mode is supported)
10077/// The output will be stored in the mode_lib.mp (mode_program_st) data struct and those can be accessed via the getter functions
10078/// Calculated values include: watermarks, dlg, rq reg, different clock frequency
10079/// This function returns 1 when there is no error.
10080/// Note: In this function, it is assumed that DCFCLK, SOCCLK freq are the state values, and mode_program will just use the DML calculated DPPCLK and DISPCLK
10081/// @param mode_lib mode_lib data struct that house all the input/output/bbox and calculation values.
10082/// @param state_idx Power state idx chosen
10083/// @param display_cfg Display Congiuration
10084/// @param call_standalone Calling mode_programming without calling mode support. Some of the "support" struct member will be pre-calculated before doing mode programming
10085/// TODO: Add clk_cfg input, could be useful for standalone mode
10086dml_bool_t dml_mode_programming(
10087 struct display_mode_lib_st *mode_lib,
10088 dml_uint_t state_idx,
10089 const struct dml_display_cfg_st *display_cfg,
10090 bool call_standalone)
10091{
10092 struct dml_clk_cfg_st clk_cfg;
10093 memset(&clk_cfg, 0, sizeof(clk_cfg));
10094
10095 clk_cfg.dcfclk_option = dml_use_required_freq;
10096 clk_cfg.dispclk_option = dml_use_required_freq;
10097 for (dml_uint_t k = 0; k < __DML_NUM_PLANES__; ++k)
10098 clk_cfg.dppclk_option[k] = dml_use_required_freq;
10099
10100 dml_print("DML::%s: ------------- START ----------\n", __func__);
10101 dml_print("DML::%s: state_idx = %u\n", __func__, state_idx);
10102 dml_print("DML::%s: call_standalone = %u\n", __func__, call_standalone);
10103
10104 cache_ip_soc_cfg(mode_lib, state_idx);
10105 cache_display_cfg(mode_lib, display_cfg);
10106
10107 fetch_socbb_params(mode_lib);
10108 if (call_standalone) {
10109 mode_lib->ms.support.ImmediateFlipSupport = 1; // assume mode support say immediate flip ok at max state/combine
10110 dml_core_mode_support_partial(mode_lib);
10111 }
10112
10113 dml_core_mode_programming(mode_lib, &clk_cfg);
10114
10115 dml_print("DML::%s: ------------- DONE ----------\n", __func__);
10116 dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %0d\n", __func__, mode_lib->mp.PrefetchAndImmediateFlipSupported);
10117 return mode_lib->mp.PrefetchAndImmediateFlipSupported;
10118}
10119
10120static dml_uint_t mode_support_pwr_states(
10121 dml_uint_t *lowest_state_idx,
10122 struct display_mode_lib_st *mode_lib,
10123 const struct dml_display_cfg_st *display_cfg,
10124 dml_uint_t start_state_idx,
10125 dml_uint_t end_state_idx)
10126{
10127 dml_uint_t state_idx = 0;
10128 dml_bool_t mode_is_supported = 0;
10129 *lowest_state_idx = end_state_idx;
10130
10131 if (end_state_idx < start_state_idx)
10132 ASSERT(0);
10133
10134 if (end_state_idx >= mode_lib->states.num_states) // idx is 0-based
10135 ASSERT(0);
10136
10137 for (state_idx = start_state_idx; state_idx <= end_state_idx; state_idx++) {
10138 if (dml_mode_support(mode_lib, state_idx, display_cfg)) {
10139 dml_print("DML::%s: Mode is supported at power state_idx = %u\n", __func__, state_idx);
10140 mode_is_supported = 1;
10141 *lowest_state_idx = state_idx;
10142 break;
10143 }
10144 }
10145
10146 return mode_is_supported;
10147}
10148
10149dml_uint_t dml_mode_support_ex(struct dml_mode_support_ex_params_st *in_out_params)
10150{
10151 dml_uint_t result;
10152
10153 result = mode_support_pwr_states(&in_out_params->out_lowest_state_idx,
10154 in_out_params->mode_lib,
10155 in_out_params->in_display_cfg,
10156 0,
10157 in_out_params->mode_lib->states.num_states - 1);
10158
10159 if (result)
10160 *in_out_params->out_evaluation_info = in_out_params->mode_lib->ms.support;
10161
10162 return result;
10163}
10164
10165dml_bool_t dml_get_is_phantom_pipe(struct display_mode_lib_st *mode_lib, dml_uint_t pipe_idx)
10166{
10167 dml_uint_t plane_idx = mode_lib->mp.pipe_plane[pipe_idx];
10168 dml_print("DML::%s: pipe_idx=%d UseMALLForPStateChange=%0d\n", __func__, pipe_idx, mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[plane_idx]);
10169 return (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[plane_idx] == dml_use_mall_pstate_change_phantom_pipe);
10170}
10171
10172#define dml_get_per_surface_var_func(variable, type, interval_var) type dml_get_##variable(struct display_mode_lib_st *mode_lib, dml_uint_t surface_idx) \
10173{ \
10174 dml_uint_t plane_idx; \
10175 plane_idx = mode_lib->mp.pipe_plane[surface_idx]; \
10176 return (type) interval_var[plane_idx]; \
10177}
10178
10179#define dml_get_var_func(var, type, internal_var) type dml_get_##var(struct display_mode_lib_st *mode_lib) \
10180{ \
10181 return (type) internal_var; \
10182}
10183
10184dml_get_var_func(wm_urgent, dml_float_t, mode_lib->mp.Watermark.UrgentWatermark);
10185dml_get_var_func(wm_stutter_exit, dml_float_t, mode_lib->mp.Watermark.StutterExitWatermark);
10186dml_get_var_func(wm_stutter_enter_exit, dml_float_t, mode_lib->mp.Watermark.StutterEnterPlusExitWatermark);
10187dml_get_var_func(wm_memory_trip, dml_float_t, mode_lib->mp.UrgentLatency);
10188dml_get_var_func(wm_fclk_change, dml_float_t, mode_lib->mp.Watermark.FCLKChangeWatermark);
10189dml_get_var_func(wm_usr_retraining, dml_float_t, mode_lib->mp.Watermark.USRRetrainingWatermark);
10190dml_get_var_func(wm_dram_clock_change, dml_float_t, mode_lib->mp.Watermark.DRAMClockChangeWatermark);
eb918cbb
CL		 10191dml_get_var_func(wm_z8_stutter_enter_exit, dml_float_t, mode_lib->mp.Watermark.Z8StutterEnterPlusExitWatermark);
10192dml_get_var_func(wm_z8_stutter, dml_float_t, mode_lib->mp.Watermark.Z8StutterExitWatermark);
7966f319
QZ		 10193dml_get_var_func(fraction_of_urgent_bandwidth, dml_float_t, mode_lib->mp.FractionOfUrgentBandwidth);
10194dml_get_var_func(fraction_of_urgent_bandwidth_imm_flip, dml_float_t, mode_lib->mp.FractionOfUrgentBandwidthImmediateFlip);
10195dml_get_var_func(urgent_latency, dml_float_t, mode_lib->mp.UrgentLatency);
10196dml_get_var_func(clk_dcf_deepsleep, dml_float_t, mode_lib->mp.DCFCLKDeepSleep);
10197dml_get_var_func(wm_writeback_dram_clock_change, dml_float_t, mode_lib->mp.Watermark.WritebackDRAMClockChangeWatermark);
10198dml_get_var_func(stutter_efficiency, dml_float_t, mode_lib->mp.StutterEfficiency);
10199dml_get_var_func(stutter_efficiency_no_vblank, dml_float_t, mode_lib->mp.StutterEfficiencyNotIncludingVBlank);
10200dml_get_var_func(stutter_efficiency_z8, dml_float_t, mode_lib->mp.Z8StutterEfficiency);
10201dml_get_var_func(stutter_num_bursts_z8, dml_float_t, mode_lib->mp.Z8NumberOfStutterBurstsPerFrame);
10202dml_get_var_func(stutter_period, dml_float_t, mode_lib->mp.StutterPeriod);
10203dml_get_var_func(stutter_efficiency_z8_bestcase, dml_float_t, mode_lib->mp.Z8StutterEfficiencyBestCase);
10204dml_get_var_func(stutter_num_bursts_z8_bestcase, dml_float_t, mode_lib->mp.Z8NumberOfStutterBurstsPerFrameBestCase);
10205dml_get_var_func(stutter_period_bestcase, dml_float_t, mode_lib->mp.StutterPeriodBestCase);
10206dml_get_var_func(urgent_extra_latency, dml_float_t, mode_lib->mp.UrgentExtraLatency);
10207dml_get_var_func(dispclk_calculated, dml_float_t, mode_lib->mp.Dispclk_calculated);
10208dml_get_var_func(total_data_read_bw, dml_float_t, mode_lib->mp.TotalDataReadBandwidth);
10209dml_get_var_func(return_bw, dml_float_t, mode_lib->ms.ReturnBW);
10210dml_get_var_func(tcalc, dml_float_t, mode_lib->mp.TCalc);
10211dml_get_var_func(comp_buffer_size_kbytes, dml_uint_t, mode_lib->mp.CompressedBufferSizeInkByte);
10212dml_get_var_func(pixel_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.pixel_chunk_size_kbytes);
10213dml_get_var_func(alpha_pixel_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.alpha_pixel_chunk_size_kbytes);
10214dml_get_var_func(meta_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.meta_chunk_size_kbytes);
10215dml_get_var_func(min_pixel_chunk_size_in_byte, dml_uint_t, mode_lib->ms.ip.min_pixel_chunk_size_bytes);
10216dml_get_var_func(min_meta_chunk_size_in_byte, dml_uint_t, mode_lib->ms.ip.min_meta_chunk_size_bytes);
10217dml_get_var_func(total_immediate_flip_bytes, dml_uint_t, mode_lib->mp.TotImmediateFlipBytes);
10218
10219dml_get_per_surface_var_func(dsc_delay, dml_uint_t, mode_lib->mp.DSCDelay); // this is the dsc latency
10220dml_get_per_surface_var_func(dppclk_calculated, dml_float_t, mode_lib->mp.Dppclk_calculated);
10221dml_get_per_surface_var_func(dscclk_calculated, dml_float_t, mode_lib->mp.DSCCLK_calculated);
10222dml_get_per_surface_var_func(min_ttu_vblank_in_us, dml_float_t, mode_lib->mp.MinTTUVBlank);
10223dml_get_per_surface_var_func(vratio_prefetch_l, dml_float_t, mode_lib->mp.VRatioPrefetchY);
10224dml_get_per_surface_var_func(vratio_prefetch_c, dml_float_t, mode_lib->mp.VRatioPrefetchC);
10225dml_get_per_surface_var_func(dst_x_after_scaler, dml_uint_t, mode_lib->mp.DSTXAfterScaler);
10226dml_get_per_surface_var_func(dst_y_after_scaler, dml_uint_t, mode_lib->mp.DSTYAfterScaler);
10227dml_get_per_surface_var_func(dst_y_per_vm_vblank, dml_float_t, mode_lib->mp.DestinationLinesToRequestVMInVBlank);
10228dml_get_per_surface_var_func(dst_y_per_row_vblank, dml_float_t, mode_lib->mp.DestinationLinesToRequestRowInVBlank);
10229dml_get_per_surface_var_func(dst_y_prefetch, dml_float_t, mode_lib->mp.DestinationLinesForPrefetch);
10230dml_get_per_surface_var_func(dst_y_per_vm_flip, dml_float_t, mode_lib->mp.DestinationLinesToRequestVMInImmediateFlip);
10231dml_get_per_surface_var_func(dst_y_per_row_flip, dml_float_t, mode_lib->mp.DestinationLinesToRequestRowInImmediateFlip);
10232dml_get_per_surface_var_func(dst_y_per_pte_row_nom_l, dml_float_t, mode_lib->mp.DST_Y_PER_PTE_ROW_NOM_L);
10233dml_get_per_surface_var_func(dst_y_per_pte_row_nom_c, dml_float_t, mode_lib->mp.DST_Y_PER_PTE_ROW_NOM_C);
10234dml_get_per_surface_var_func(dst_y_per_meta_row_nom_l, dml_float_t, mode_lib->mp.DST_Y_PER_META_ROW_NOM_L);
10235dml_get_per_surface_var_func(dst_y_per_meta_row_nom_c, dml_float_t, mode_lib->mp.DST_Y_PER_META_ROW_NOM_C);
10236dml_get_per_surface_var_func(refcyc_per_vm_group_vblank_in_us, dml_float_t, mode_lib->mp.TimePerVMGroupVBlank);
10237dml_get_per_surface_var_func(refcyc_per_vm_group_flip_in_us, dml_float_t, mode_lib->mp.TimePerVMGroupFlip);
10238dml_get_per_surface_var_func(refcyc_per_vm_req_vblank_in_us, dml_float_t, mode_lib->mp.TimePerVMRequestVBlank);
10239dml_get_per_surface_var_func(refcyc_per_vm_req_flip_in_us, dml_float_t, mode_lib->mp.TimePerVMRequestFlip);
10240dml_get_per_surface_var_func(refcyc_per_vm_dmdata_in_us, dml_float_t, mode_lib->mp.Tdmdl_vm);
10241dml_get_per_surface_var_func(dmdata_dl_delta_in_us, dml_float_t, mode_lib->mp.Tdmdl);
10242dml_get_per_surface_var_func(refcyc_per_line_delivery_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeLuma);
10243dml_get_per_surface_var_func(refcyc_per_line_delivery_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeChroma);
10244dml_get_per_surface_var_func(refcyc_per_line_delivery_pre_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeLumaPrefetch);
10245dml_get_per_surface_var_func(refcyc_per_line_delivery_pre_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeChromaPrefetch);
10246dml_get_per_surface_var_func(refcyc_per_req_delivery_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeLuma);
10247dml_get_per_surface_var_func(refcyc_per_req_delivery_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeChroma);
10248dml_get_per_surface_var_func(refcyc_per_req_delivery_pre_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeLumaPrefetch);
10249dml_get_per_surface_var_func(refcyc_per_req_delivery_pre_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeChromaPrefetch);
10250dml_get_per_surface_var_func(refcyc_per_cursor_req_delivery_in_us, dml_float_t, mode_lib->mp.CursorRequestDeliveryTime);
10251dml_get_per_surface_var_func(refcyc_per_cursor_req_delivery_pre_in_us, dml_float_t, mode_lib->mp.CursorRequestDeliveryTimePrefetch);
10252dml_get_per_surface_var_func(refcyc_per_meta_chunk_nom_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkNominal);
10253dml_get_per_surface_var_func(refcyc_per_meta_chunk_nom_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkNominal);
10254dml_get_per_surface_var_func(refcyc_per_meta_chunk_vblank_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkVBlank);
10255dml_get_per_surface_var_func(refcyc_per_meta_chunk_vblank_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkVBlank);
10256dml_get_per_surface_var_func(refcyc_per_meta_chunk_flip_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkFlip);
10257dml_get_per_surface_var_func(refcyc_per_meta_chunk_flip_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkFlip);
10258dml_get_per_surface_var_func(refcyc_per_pte_group_nom_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_nom_luma);
10259dml_get_per_surface_var_func(refcyc_per_pte_group_nom_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_nom_chroma);
10260dml_get_per_surface_var_func(refcyc_per_pte_group_vblank_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_vblank_luma);
10261dml_get_per_surface_var_func(refcyc_per_pte_group_vblank_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_vblank_chroma);
10262dml_get_per_surface_var_func(refcyc_per_pte_group_flip_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_flip_luma);
10263dml_get_per_surface_var_func(refcyc_per_pte_group_flip_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_flip_chroma);
10264dml_get_per_surface_var_func(dpte_group_size_in_bytes, dml_uint_t, mode_lib->mp.dpte_group_bytes);
10265dml_get_per_surface_var_func(vm_group_size_in_bytes, dml_uint_t, mode_lib->mp.vm_group_bytes);
10266dml_get_per_surface_var_func(swath_height_l, dml_uint_t, mode_lib->ms.SwathHeightY);
10267dml_get_per_surface_var_func(swath_height_c, dml_uint_t, mode_lib->ms.SwathHeightC);
10268dml_get_per_surface_var_func(dpte_row_height_l, dml_uint_t, mode_lib->mp.dpte_row_height);
10269dml_get_per_surface_var_func(dpte_row_height_c, dml_uint_t, mode_lib->mp.dpte_row_height_chroma);
10270dml_get_per_surface_var_func(dpte_row_height_linear_l, dml_uint_t, mode_lib->mp.dpte_row_height_linear);
10271dml_get_per_surface_var_func(dpte_row_height_linear_c, dml_uint_t, mode_lib->mp.dpte_row_height_linear_chroma);
10272dml_get_per_surface_var_func(meta_row_height_l, dml_uint_t, mode_lib->mp.meta_row_height);
10273dml_get_per_surface_var_func(meta_row_height_c, dml_uint_t, mode_lib->mp.meta_row_height_chroma);
10274
10275dml_get_per_surface_var_func(vstartup_calculated, dml_uint_t, mode_lib->mp.VStartup);
10276dml_get_per_surface_var_func(vupdate_offset, dml_uint_t, mode_lib->mp.VUpdateOffsetPix);
10277dml_get_per_surface_var_func(vupdate_width, dml_uint_t, mode_lib->mp.VUpdateWidthPix);
10278dml_get_per_surface_var_func(vready_offset, dml_uint_t, mode_lib->mp.VReadyOffsetPix);
10279dml_get_per_surface_var_func(vready_at_or_after_vsync, dml_uint_t, mode_lib->mp.VREADY_AT_OR_AFTER_VSYNC);
10280dml_get_per_surface_var_func(min_dst_y_next_start, dml_uint_t, mode_lib->mp.MIN_DST_Y_NEXT_START);
10281dml_get_per_surface_var_func(det_stored_buffer_size_l_bytes, dml_uint_t, mode_lib->ms.DETBufferSizeY);
10282dml_get_per_surface_var_func(det_stored_buffer_size_c_bytes, dml_uint_t, mode_lib->ms.DETBufferSizeC);
10283dml_get_per_surface_var_func(use_mall_for_static_screen, dml_uint_t, mode_lib->mp.UsesMALLForStaticScreen);
10284dml_get_per_surface_var_func(surface_size_for_mall, dml_uint_t, mode_lib->mp.SurfaceSizeInTheMALL);
10285dml_get_per_surface_var_func(dcc_max_uncompressed_block_l, dml_uint_t, mode_lib->mp.DCCYMaxUncompressedBlock);
10286dml_get_per_surface_var_func(dcc_max_compressed_block_l, dml_uint_t, mode_lib->mp.DCCYMaxCompressedBlock);
10287dml_get_per_surface_var_func(dcc_independent_block_l, dml_uint_t, mode_lib->mp.DCCYIndependentBlock);
10288dml_get_per_surface_var_func(dcc_max_uncompressed_block_c, dml_uint_t, mode_lib->mp.DCCCMaxUncompressedBlock);
10289dml_get_per_surface_var_func(dcc_max_compressed_block_c, dml_uint_t, mode_lib->mp.DCCCMaxCompressedBlock);
10290dml_get_per_surface_var_func(dcc_independent_block_c, dml_uint_t, mode_lib->mp.DCCCIndependentBlock);
10291dml_get_per_surface_var_func(max_active_dram_clock_change_latency_supported, dml_uint_t, mode_lib->mp.MaxActiveDRAMClockChangeLatencySupported);
10292dml_get_per_surface_var_func(pte_buffer_mode, dml_uint_t, mode_lib->mp.PTE_BUFFER_MODE);
10293dml_get_per_surface_var_func(bigk_fragment_size, dml_uint_t, mode_lib->mp.BIGK_FRAGMENT_SIZE);
10294dml_get_per_surface_var_func(dpte_bytes_per_row, dml_uint_t, mode_lib->mp.PixelPTEBytesPerRow);
10295dml_get_per_surface_var_func(meta_bytes_per_row, dml_uint_t, mode_lib->mp.MetaRowByte);
10296dml_get_per_surface_var_func(det_buffer_size_kbytes, dml_uint_t, mode_lib->ms.DETBufferSizeInKByte);
A mirror of Linus' kernel repository