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