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