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