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