drivers/gpu/drm/amd/display/dc/dml/dcn31/display_mode_vba_31.c

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