drivers/gpu/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c

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