drivers/gpu/drm/amd/display/dc/dml2/display_mode_core.c

   1 /* SPDX-License-Identifier: MIT */
   2 /*
   3  * Copyright 2023 Advanced Micro Devices, Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors: AMD
  24  *
  25  */
  26
  27 #include "display_mode_core.h"
  28 #include "display_mode_util.h"
  29 #include "display_mode_lib_defines.h"
  30
  31 #include "dml_assert.h"
  32
  33 #define DML2_MAX_FMT_420_BUFFER_WIDTH 4096
  34 // ---------------------------
  35 //  Declaration Begins
  36 // ---------------------------
  37 static void CalculateBytePerPixelAndBlockSizes(
  38         enum dml_source_format_class SourcePixelFormat,
  39         enum dml_swizzle_mode SurfaceTiling,
  40         // Output
  41         dml_uint_t *BytePerPixelY,
  42         dml_uint_t *BytePerPixelC,
  43         dml_float_t *BytePerPixelDETY,
  44         dml_float_t *BytePerPixelDETC,
  45         dml_uint_t *BlockHeight256BytesY,
  46         dml_uint_t *BlockHeight256BytesC,
  47         dml_uint_t *BlockWidth256BytesY,
  48         dml_uint_t *BlockWidth256BytesC,
  49         dml_uint_t *MacroTileHeightY,
  50         dml_uint_t *MacroTileHeightC,
  51         dml_uint_t *MacroTileWidthY,
  52         dml_uint_t *MacroTileWidthC);
  53
  54 static dml_float_t CalculateWriteBackDISPCLK(
  55         enum dml_source_format_class WritebackPixelFormat,
  56         dml_float_t PixelClock,
  57         dml_float_t WritebackHRatio,
  58         dml_float_t WritebackVRatio,
  59         dml_uint_t WritebackHTaps,
  60         dml_uint_t WritebackVTaps,
  61         dml_uint_t WritebackSourceWidth,
  62         dml_uint_t WritebackDestinationWidth,
  63         dml_uint_t HTotal,
  64         dml_uint_t WritebackLineBufferSize,
  65         dml_float_t DISPCLKDPPCLKVCOSpeed);
  66
  67 static void CalculateVMRowAndSwath(
  68         struct display_mode_lib_scratch_st *s,
  69         struct CalculateVMRowAndSwath_params_st *p);
  70
  71 static void CalculateOutputLink(
  72         dml_float_t PHYCLKPerState,
  73         dml_float_t PHYCLKD18PerState,
  74         dml_float_t PHYCLKD32PerState,
  75         dml_float_t Downspreading,
  76         dml_bool_t IsMainSurfaceUsingTheIndicatedTiming,
  77         enum dml_output_encoder_class Output,
  78         enum dml_output_format_class OutputFormat,
  79         dml_uint_t HTotal,
  80         dml_uint_t HActive,
  81         dml_float_t PixelClockBackEnd,
  82         dml_float_t ForcedOutputLinkBPP,
  83         dml_uint_t DSCInputBitPerComponent,
  84         dml_uint_t NumberOfDSCSlices,
  85         dml_float_t AudioSampleRate,
  86         dml_uint_t AudioSampleLayout,
  87         enum dml_odm_mode ODMModeNoDSC,
  88         enum dml_odm_mode ODMModeDSC,
  89         enum dml_dsc_enable DSCEnable,
  90         dml_uint_t OutputLinkDPLanes,
  91         enum dml_output_link_dp_rate OutputLinkDPRate,
  92
  93         // Output
  94         dml_bool_t *RequiresDSC,
  95         dml_bool_t *RequiresFEC,
  96         dml_float_t *OutBpp,
  97         enum dml_output_type_and_rate__type *OutputType,
  98         enum dml_output_type_and_rate__rate *OutputRate,
  99         dml_uint_t *RequiredSlots);
 100
 101 static void CalculateODMMode(
 102         dml_uint_t MaximumPixelsPerLinePerDSCUnit,
 103         dml_uint_t HActive,
 104         enum dml_output_encoder_class Output,
 105         enum dml_output_format_class OutputFormat,
 106         enum dml_odm_use_policy ODMUse,
 107         dml_float_t StateDispclk,
 108         dml_float_t MaxDispclk,
 109         dml_bool_t DSCEnable,
 110         dml_uint_t TotalNumberOfActiveDPP,
 111         dml_uint_t MaxNumDPP,
 112         dml_float_t PixelClock,
 113         dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
 114         dml_float_t DISPCLKRampingMargin,
 115         dml_float_t DISPCLKDPPCLKVCOSpeed,
 116
 117         // Output
 118         dml_bool_t *TotalAvailablePipesSupport,
 119         dml_uint_t *NumberOfDPP,
 120         enum dml_odm_mode *ODMMode,
 121         dml_float_t *RequiredDISPCLKPerSurface);
 122
 123 static dml_float_t CalculateRequiredDispclk(
 124         enum dml_odm_mode ODMMode,
 125         dml_float_t PixelClock,
 126         dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
 127         dml_float_t DISPCLKRampingMargin,
 128         dml_float_t DISPCLKDPPCLKVCOSpeed,
 129         dml_float_t MaxDispclkSingle);
 130
 131 static void CalculateSinglePipeDPPCLKAndSCLThroughput(
 132         dml_float_t HRatio,
 133         dml_float_t HRatioChroma,
 134         dml_float_t VRatio,
 135         dml_float_t VRatioChroma,
 136         dml_float_t MaxDCHUBToPSCLThroughput,
 137         dml_float_t MaxPSCLToLBThroughput,
 138         dml_float_t PixelClock,
 139         enum dml_source_format_class SourcePixelFormat,
 140         dml_uint_t HTaps,
 141         dml_uint_t HTapsChroma,
 142         dml_uint_t VTaps,
 143         dml_uint_t VTapsChroma,
 144
 145         // Output
 146         dml_float_t *PSCL_THROUGHPUT,
 147         dml_float_t *PSCL_THROUGHPUT_CHROMA,
 148         dml_float_t *DPPCLKUsingSingleDPP);
 149
 150 static void CalculateDPPCLK(
 151         dml_uint_t NumberOfActiveSurfaces,
 152         dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
 153         dml_float_t DISPCLKDPPCLKVCOSpeed,
 154         dml_float_t DPPCLKUsingSingleDPP[],
 155         dml_uint_t DPPPerSurface[],
 156
 157         // Output
 158         dml_float_t *GlobalDPPCLK,
 159         dml_float_t Dppclk[]);
 160
 161 static void CalculateMALLUseForStaticScreen(
 162         dml_uint_t NumberOfActiveSurfaces,
 163         dml_uint_t MALLAllocatedForDCNFinal,
 164         enum dml_use_mall_for_static_screen_mode *UseMALLForStaticScreen,
 165         dml_uint_t SurfaceSizeInMALL[],
 166         dml_bool_t one_row_per_frame_fits_in_buffer[],
 167
 168         // Output
 169         dml_bool_t UsesMALLForStaticScreen[]);
 170
 171 static dml_uint_t dscceComputeDelay(
 172         dml_uint_t bpc,
 173         dml_float_t BPP,
 174         dml_uint_t sliceWidth,
 175         dml_uint_t numSlices,
 176         enum dml_output_format_class pixelFormat,
 177         enum dml_output_encoder_class Output);
 178
 179 static dml_uint_t dscComputeDelay(enum dml_output_format_class pixelFormat,
 180         enum dml_output_encoder_class Output);
 181
 182 static dml_bool_t CalculatePrefetchSchedule(struct display_mode_lib_scratch_st *scratch,
 183         struct CalculatePrefetchSchedule_params_st *p);
 184
 185 static dml_float_t RoundToDFSGranularity(dml_float_t Clock, dml_bool_t round_up, dml_float_t VCOSpeed);
 186
 187 static void CalculateDCCConfiguration(
 188         dml_bool_t DCCEnabled,
 189         dml_bool_t DCCProgrammingAssumesScanDirectionUnknown,
 190         enum dml_source_format_class SourcePixelFormat,
 191         dml_uint_t SurfaceWidthLuma,
 192         dml_uint_t SurfaceWidthChroma,
 193         dml_uint_t SurfaceHeightLuma,
 194         dml_uint_t SurfaceHeightChroma,
 195         dml_uint_t nomDETInKByte,
 196         dml_uint_t RequestHeight256ByteLuma,
 197         dml_uint_t RequestHeight256ByteChroma,
 198         enum dml_swizzle_mode TilingFormat,
 199         dml_uint_t BytePerPixelY,
 200         dml_uint_t BytePerPixelC,
 201         dml_float_t BytePerPixelDETY,
 202         dml_float_t BytePerPixelDETC,
 203         enum dml_rotation_angle SourceScan,
 204         // Output
 205         dml_uint_t *MaxUncompressedBlockLuma,
 206         dml_uint_t *MaxUncompressedBlockChroma,
 207         dml_uint_t *MaxCompressedBlockLuma,
 208         dml_uint_t *MaxCompressedBlockChroma,
 209         dml_uint_t *IndependentBlockLuma,
 210         dml_uint_t *IndependentBlockChroma);
 211
 212 static dml_uint_t CalculatePrefetchSourceLines(
 213         dml_float_t VRatio,
 214         dml_uint_t VTaps,
 215         dml_bool_t Interlace,
 216         dml_bool_t ProgressiveToInterlaceUnitInOPP,
 217         dml_uint_t SwathHeight,
 218         enum dml_rotation_angle SourceScan,
 219         dml_bool_t ViewportStationary,
 220         dml_uint_t SwathWidth,
 221         dml_uint_t ViewportHeight,
 222         dml_uint_t ViewportXStart,
 223         dml_uint_t ViewportYStart,
 224
 225         // Output
 226         dml_uint_t *VInitPreFill,
 227         dml_uint_t *MaxNumSwath);
 228
 229 static dml_uint_t CalculateVMAndRowBytes(
 230         dml_bool_t ViewportStationary,
 231         dml_bool_t DCCEnable,
 232         dml_uint_t NumberOfDPPs,
 233         dml_uint_t BlockHeight256Bytes,
 234         dml_uint_t BlockWidth256Bytes,
 235         enum dml_source_format_class SourcePixelFormat,
 236         dml_uint_t SurfaceTiling,
 237         dml_uint_t BytePerPixel,
 238         enum dml_rotation_angle SourceScan,
 239         dml_uint_t SwathWidth,
 240         dml_uint_t ViewportHeight,
 241         dml_uint_t ViewportXStart,
 242         dml_uint_t ViewportYStart,
 243         dml_bool_t GPUVMEnable,
 244         dml_uint_t GPUVMMaxPageTableLevels,
 245         dml_uint_t GPUVMMinPageSizeKBytes,
 246         dml_uint_t PTEBufferSizeInRequests,
 247         dml_uint_t Pitch,
 248         dml_uint_t DCCMetaPitch,
 249         dml_uint_t MacroTileWidth,
 250         dml_uint_t MacroTileHeight,
 251
 252         // Output
 253         dml_uint_t *MetaRowByte,
 254         dml_uint_t *PixelPTEBytesPerRow,
 255         dml_uint_t *PixelPTEBytesPerRowStorage, // for PTE buffer size check
 256         dml_uint_t *dpte_row_width_ub,
 257         dml_uint_t *dpte_row_height,
 258         dml_uint_t *dpte_row_height_linear,
 259         dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
 260         dml_uint_t *dpte_row_width_ub_one_row_per_frame,
 261         dml_uint_t *dpte_row_height_one_row_per_frame,
 262         dml_uint_t *MetaRequestWidth,
 263         dml_uint_t *MetaRequestHeight,
 264         dml_uint_t *meta_row_width,
 265         dml_uint_t *meta_row_height,
 266         dml_uint_t *PixelPTEReqWidth,
 267         dml_uint_t *PixelPTEReqHeight,
 268         dml_uint_t *PTERequestSize,
 269         dml_uint_t *DPDE0BytesFrame,
 270         dml_uint_t *MetaPTEBytesFrame);
 271
 272 static dml_float_t CalculateTWait(
 273         dml_uint_t PrefetchMode,
 274         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
 275         dml_bool_t SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
 276         dml_bool_t DRRDisplay,
 277         dml_float_t DRAMClockChangeLatency,
 278         dml_float_t FCLKChangeLatency,
 279         dml_float_t UrgentLatency,
 280         dml_float_t SREnterPlusExitTime);
 281
 282 static void CalculatePrefetchMode(
 283         enum dml_prefetch_modes AllowForPStateChangeOrStutterInVBlank,
 284         dml_uint_t *MinPrefetchMode,
 285         dml_uint_t *MaxPrefetchMode);
 286
 287 static void CalculateRowBandwidth(
 288         dml_bool_t GPUVMEnable,
 289         enum dml_source_format_class SourcePixelFormat,
 290         dml_float_t VRatio,
 291         dml_float_t VRatioChroma,
 292         dml_bool_t DCCEnable,
 293         dml_float_t LineTime,
 294         dml_uint_t MetaRowByteLuma,
 295         dml_uint_t MetaRowByteChroma,
 296         dml_uint_t meta_row_height_luma,
 297         dml_uint_t meta_row_height_chroma,
 298         dml_uint_t PixelPTEBytesPerRowLuma,
 299         dml_uint_t PixelPTEBytesPerRowChroma,
 300         dml_uint_t dpte_row_height_luma,
 301         dml_uint_t dpte_row_height_chroma,
 302         // Output
 303         dml_float_t *meta_row_bw,
 304         dml_float_t *dpte_row_bw);
 305
 306 static void CalculateFlipSchedule(
 307         dml_float_t HostVMInefficiencyFactor,
 308         dml_float_t UrgentExtraLatency,
 309         dml_float_t UrgentLatency,
 310         dml_uint_t GPUVMMaxPageTableLevels,
 311         dml_bool_t HostVMEnable,
 312         dml_uint_t HostVMMaxNonCachedPageTableLevels,
 313         dml_bool_t GPUVMEnable,
 314         dml_uint_t HostVMMinPageSize,
 315         dml_float_t PDEAndMetaPTEBytesPerFrame,
 316         dml_float_t MetaRowBytes,
 317         dml_float_t DPTEBytesPerRow,
 318         dml_float_t BandwidthAvailableForImmediateFlip,
 319         dml_uint_t TotImmediateFlipBytes,
 320         enum dml_source_format_class SourcePixelFormat,
 321         dml_float_t LineTime,
 322         dml_float_t VRatio,
 323         dml_float_t VRatioChroma,
 324         dml_float_t Tno_bw,
 325         dml_bool_t DCCEnable,
 326         dml_uint_t dpte_row_height,
 327         dml_uint_t meta_row_height,
 328         dml_uint_t dpte_row_height_chroma,
 329         dml_uint_t meta_row_height_chroma,
 330         dml_bool_t use_one_row_for_frame_flip,
 331
 332         // Output
 333         dml_float_t *DestinationLinesToRequestVMInImmediateFlip,
 334         dml_float_t *DestinationLinesToRequestRowInImmediateFlip,
 335         dml_float_t *final_flip_bw,
 336         dml_bool_t *ImmediateFlipSupportedForPipe);
 337
 338 static dml_float_t CalculateWriteBackDelay(
 339         enum dml_source_format_class WritebackPixelFormat,
 340         dml_float_t WritebackHRatio,
 341         dml_float_t WritebackVRatio,
 342         dml_uint_t WritebackVTaps,
 343         dml_uint_t WritebackDestinationWidth,
 344         dml_uint_t WritebackDestinationHeight,
 345         dml_uint_t WritebackSourceHeight,
 346         dml_uint_t HTotal);
 347
 348 static void CalculateVUpdateAndDynamicMetadataParameters(
 349         dml_uint_t MaxInterDCNTileRepeaters,
 350         dml_float_t Dppclk,
 351         dml_float_t DISPCLK,
 352         dml_float_t DCFClkDeepSleep,
 353         dml_float_t PixelClock,
 354         dml_uint_t HTotal,
 355         dml_uint_t VBlank,
 356         dml_uint_t DynamicMetadataTransmittedBytes,
 357         dml_uint_t DynamicMetadataLinesBeforeActiveRequired,
 358         dml_uint_t InterlaceEnable,
 359         dml_bool_t ProgressiveToInterlaceUnitInOPP,
 360         dml_float_t *TSetup,
 361         dml_float_t *Tdmbf,
 362         dml_float_t *Tdmec,
 363         dml_float_t *Tdmsks,
 364         dml_uint_t *VUpdateOffsetPix,
 365         dml_uint_t *VUpdateWidthPix,
 366         dml_uint_t *VReadyOffsetPix);
 367
 368 static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct dml_display_cfg_st *display_cfg, dml_bool_t ptoi_supported);
 369
 370 static dml_float_t TruncToValidBPP(
 371         dml_float_t LinkBitRate,
 372         dml_uint_t Lanes,
 373         dml_uint_t HTotal,
 374         dml_uint_t HActive,
 375         dml_float_t PixelClock,
 376         dml_float_t DesiredBPP,
 377         dml_bool_t DSCEnable,
 378         enum dml_output_encoder_class Output,
 379         enum dml_output_format_class Format,
 380         dml_uint_t DSCInputBitPerComponent,
 381         dml_uint_t DSCSlices,
 382         dml_uint_t AudioRate,
 383         dml_uint_t AudioLayout,
 384         enum dml_odm_mode ODMModeNoDSC,
 385         enum dml_odm_mode ODMModeDSC,
 386         // Output
 387         dml_uint_t *RequiredSlotsSingle);
 388
 389 static void CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
 390         struct display_mode_lib_scratch_st *s,
 391         struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *p);
 392
 393 static void CalculateDCFCLKDeepSleep(
 394         dml_uint_t NumberOfActiveSurfaces,
 395         dml_uint_t BytePerPixelY[],
 396         dml_uint_t BytePerPixelC[],
 397         dml_float_t VRatio[],
 398         dml_float_t VRatioChroma[],
 399         dml_uint_t SwathWidthY[],
 400         dml_uint_t SwathWidthC[],
 401         dml_uint_t DPPPerSurface[],
 402         dml_float_t HRatio[],
 403         dml_float_t HRatioChroma[],
 404         dml_float_t PixelClock[],
 405         dml_float_t PSCL_THROUGHPUT[],
 406         dml_float_t PSCL_THROUGHPUT_CHROMA[],
 407         dml_float_t Dppclk[],
 408         dml_float_t ReadBandwidthLuma[],
 409         dml_float_t ReadBandwidthChroma[],
 410         dml_uint_t ReturnBusWidth,
 411
 412         // Output
 413         dml_float_t *DCFCLKDeepSleep);
 414
 415 static void CalculateUrgentBurstFactor(
 416         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
 417         dml_uint_t swath_width_luma_ub,
 418         dml_uint_t swath_width_chroma_ub,
 419         dml_uint_t SwathHeightY,
 420         dml_uint_t SwathHeightC,
 421         dml_float_t LineTime,
 422         dml_float_t UrgentLatency,
 423         dml_float_t CursorBufferSize,
 424         dml_uint_t CursorWidth,
 425         dml_uint_t CursorBPP,
 426         dml_float_t VRatio,
 427         dml_float_t VRatioC,
 428         dml_float_t BytePerPixelInDETY,
 429         dml_float_t BytePerPixelInDETC,
 430         dml_uint_t DETBufferSizeY,
 431         dml_uint_t DETBufferSizeC,
 432         // Output
 433         dml_float_t *UrgentBurstFactorCursor,
 434         dml_float_t *UrgentBurstFactorLuma,
 435         dml_float_t *UrgentBurstFactorChroma,
 436         dml_bool_t *NotEnoughUrgentLatencyHiding);
 437
 438 static dml_float_t RequiredDTBCLK(
 439         dml_bool_t DSCEnable,
 440         dml_float_t PixelClock,
 441         enum dml_output_format_class OutputFormat,
 442         dml_float_t OutputBpp,
 443         dml_uint_t DSCSlices,
 444         dml_uint_t HTotal,
 445         dml_uint_t HActive,
 446         dml_uint_t AudioRate,
 447         dml_uint_t AudioLayoutSingle);
 448
 449 static void UseMinimumDCFCLK(
 450         struct display_mode_lib_scratch_st *scratch,
 451         struct UseMinimumDCFCLK_params_st *p);
 452
 453 static void CalculatePixelDeliveryTimes(
 454         dml_uint_t NumberOfActiveSurfaces,
 455         dml_float_t VRatio[],
 456         dml_float_t VRatioChroma[],
 457         dml_float_t VRatioPrefetchY[],
 458         dml_float_t VRatioPrefetchC[],
 459         dml_uint_t swath_width_luma_ub[],
 460         dml_uint_t swath_width_chroma_ub[],
 461         dml_uint_t DPPPerSurface[],
 462         dml_float_t HRatio[],
 463         dml_float_t HRatioChroma[],
 464         dml_float_t PixelClock[],
 465         dml_float_t PSCL_THROUGHPUT[],
 466         dml_float_t PSCL_THROUGHPUT_CHROMA[],
 467         dml_float_t Dppclk[],
 468         dml_uint_t BytePerPixelC[],
 469         enum dml_rotation_angle SourceScan[],
 470         dml_uint_t NumberOfCursors[],
 471         dml_uint_t CursorWidth[],
 472         dml_uint_t CursorBPP[],
 473         dml_uint_t BlockWidth256BytesY[],
 474         dml_uint_t BlockHeight256BytesY[],
 475         dml_uint_t BlockWidth256BytesC[],
 476         dml_uint_t BlockHeight256BytesC[],
 477
 478         // Output
 479         dml_float_t DisplayPipeLineDeliveryTimeLuma[],
 480         dml_float_t DisplayPipeLineDeliveryTimeChroma[],
 481         dml_float_t DisplayPipeLineDeliveryTimeLumaPrefetch[],
 482         dml_float_t DisplayPipeLineDeliveryTimeChromaPrefetch[],
 483         dml_float_t DisplayPipeRequestDeliveryTimeLuma[],
 484         dml_float_t DisplayPipeRequestDeliveryTimeChroma[],
 485         dml_float_t DisplayPipeRequestDeliveryTimeLumaPrefetch[],
 486         dml_float_t DisplayPipeRequestDeliveryTimeChromaPrefetch[],
 487         dml_float_t CursorRequestDeliveryTime[],
 488         dml_float_t CursorRequestDeliveryTimePrefetch[]);
 489
 490 static void CalculateMetaAndPTETimes(
 491         dml_bool_t use_one_row_for_frame[],
 492         dml_uint_t NumberOfActiveSurfaces,
 493         dml_bool_t GPUVMEnable,
 494         dml_uint_t MetaChunkSize,
 495         dml_uint_t MinMetaChunkSizeBytes,
 496         dml_uint_t HTotal[],
 497         dml_float_t VRatio[],
 498         dml_float_t VRatioChroma[],
 499         dml_float_t DestinationLinesToRequestRowInVBlank[],
 500         dml_float_t DestinationLinesToRequestRowInImmediateFlip[],
 501         dml_bool_t DCCEnable[],
 502         dml_float_t PixelClock[],
 503         dml_uint_t BytePerPixelY[],
 504         dml_uint_t BytePerPixelC[],
 505         enum dml_rotation_angle SourceScan[],
 506         dml_uint_t dpte_row_height[],
 507         dml_uint_t dpte_row_height_chroma[],
 508         dml_uint_t meta_row_width[],
 509         dml_uint_t meta_row_width_chroma[],
 510         dml_uint_t meta_row_height[],
 511         dml_uint_t meta_row_height_chroma[],
 512         dml_uint_t meta_req_width[],
 513         dml_uint_t meta_req_width_chroma[],
 514         dml_uint_t meta_req_height[],
 515         dml_uint_t meta_req_height_chroma[],
 516         dml_uint_t dpte_group_bytes[],
 517         dml_uint_t PTERequestSizeY[],
 518         dml_uint_t PTERequestSizeC[],
 519         dml_uint_t PixelPTEReqWidthY[],
 520         dml_uint_t PixelPTEReqHeightY[],
 521         dml_uint_t PixelPTEReqWidthC[],
 522         dml_uint_t PixelPTEReqHeightC[],
 523         dml_uint_t dpte_row_width_luma_ub[],
 524         dml_uint_t dpte_row_width_chroma_ub[],
 525
 526         // Output
 527         dml_float_t DST_Y_PER_PTE_ROW_NOM_L[],
 528         dml_float_t DST_Y_PER_PTE_ROW_NOM_C[],
 529         dml_float_t DST_Y_PER_META_ROW_NOM_L[],
 530         dml_float_t DST_Y_PER_META_ROW_NOM_C[],
 531         dml_float_t TimePerMetaChunkNominal[],
 532         dml_float_t TimePerChromaMetaChunkNominal[],
 533         dml_float_t TimePerMetaChunkVBlank[],
 534         dml_float_t TimePerChromaMetaChunkVBlank[],
 535         dml_float_t TimePerMetaChunkFlip[],
 536         dml_float_t TimePerChromaMetaChunkFlip[],
 537         dml_float_t time_per_pte_group_nom_luma[],
 538         dml_float_t time_per_pte_group_vblank_luma[],
 539         dml_float_t time_per_pte_group_flip_luma[],
 540         dml_float_t time_per_pte_group_nom_chroma[],
 541         dml_float_t time_per_pte_group_vblank_chroma[],
 542         dml_float_t time_per_pte_group_flip_chroma[]);
 543
 544 static void CalculateVMGroupAndRequestTimes(
 545         dml_uint_t NumberOfActiveSurfaces,
 546         dml_bool_t GPUVMEnable,
 547         dml_uint_t GPUVMMaxPageTableLevels,
 548         dml_uint_t HTotal[],
 549         dml_uint_t BytePerPixelC[],
 550         dml_float_t DestinationLinesToRequestVMInVBlank[],
 551         dml_float_t DestinationLinesToRequestVMInImmediateFlip[],
 552         dml_bool_t DCCEnable[],
 553         dml_float_t PixelClock[],
 554         dml_uint_t dpte_row_width_luma_ub[],
 555         dml_uint_t dpte_row_width_chroma_ub[],
 556         dml_uint_t vm_group_bytes[],
 557         dml_uint_t dpde0_bytes_per_frame_ub_l[],
 558         dml_uint_t dpde0_bytes_per_frame_ub_c[],
 559         dml_uint_t meta_pte_bytes_per_frame_ub_l[],
 560         dml_uint_t meta_pte_bytes_per_frame_ub_c[],
 561
 562         // Output
 563         dml_float_t TimePerVMGroupVBlank[],
 564         dml_float_t TimePerVMGroupFlip[],
 565         dml_float_t TimePerVMRequestVBlank[],
 566         dml_float_t TimePerVMRequestFlip[]);
 567
 568 static void CalculateStutterEfficiency(
 569         struct display_mode_lib_scratch_st *scratch,
 570         struct CalculateStutterEfficiency_params_st *p);
 571
 572 static void CalculateSwathAndDETConfiguration(
 573         struct display_mode_lib_scratch_st *scratch,
 574         struct CalculateSwathAndDETConfiguration_params_st *p);
 575
 576 static void CalculateSwathWidth(
 577         dml_bool_t ForceSingleDPP,
 578         dml_uint_t NumberOfActiveSurfaces,
 579         enum dml_source_format_class SourcePixelFormat[],
 580         enum dml_rotation_angle SourceScan[],
 581         dml_bool_t ViewportStationary[],
 582         dml_uint_t ViewportWidth[],
 583         dml_uint_t ViewportHeight[],
 584         dml_uint_t ViewportXStart[],
 585         dml_uint_t ViewportYStart[],
 586         dml_uint_t ViewportXStartC[],
 587         dml_uint_t ViewportYStartC[],
 588         dml_uint_t SurfaceWidthY[],
 589         dml_uint_t SurfaceWidthC[],
 590         dml_uint_t SurfaceHeightY[],
 591         dml_uint_t SurfaceHeightC[],
 592         enum dml_odm_mode ODMMode[],
 593         dml_uint_t BytePerPixY[],
 594         dml_uint_t BytePerPixC[],
 595         dml_uint_t Read256BytesBlockHeightY[],
 596         dml_uint_t Read256BytesBlockHeightC[],
 597         dml_uint_t Read256BytesBlockWidthY[],
 598         dml_uint_t Read256BytesBlockWidthC[],
 599         dml_uint_t BlendingAndTiming[],
 600         dml_uint_t HActive[],
 601         dml_float_t HRatio[],
 602         dml_uint_t DPPPerSurface[],
 603
 604         // Output
 605         dml_uint_t SwathWidthSingleDPPY[],
 606         dml_uint_t SwathWidthSingleDPPC[],
 607         dml_uint_t SwathWidthY[],
 608         dml_uint_t SwathWidthC[],
 609         dml_uint_t MaximumSwathHeightY[],
 610         dml_uint_t MaximumSwathHeightC[],
 611         dml_uint_t swath_width_luma_ub[],
 612         dml_uint_t swath_width_chroma_ub[]);
 613
 614 static dml_float_t CalculateExtraLatency(
 615         dml_uint_t RoundTripPingLatencyCycles,
 616         dml_uint_t ReorderingBytes,
 617         dml_float_t DCFCLK,
 618         dml_uint_t TotalNumberOfActiveDPP,
 619         dml_uint_t PixelChunkSizeInKByte,
 620         dml_uint_t TotalNumberOfDCCActiveDPP,
 621         dml_uint_t MetaChunkSize,
 622         dml_float_t ReturnBW,
 623         dml_bool_t GPUVMEnable,
 624         dml_bool_t HostVMEnable,
 625         dml_uint_t NumberOfActiveSurfaces,
 626         dml_uint_t NumberOfDPP[],
 627         dml_uint_t dpte_group_bytes[],
 628         dml_float_t HostVMInefficiencyFactor,
 629         dml_uint_t HostVMMinPageSize,
 630         dml_uint_t HostVMMaxNonCachedPageTableLevels);
 631
 632 static dml_uint_t CalculateExtraLatencyBytes(
 633         dml_uint_t ReorderingBytes,
 634         dml_uint_t TotalNumberOfActiveDPP,
 635         dml_uint_t PixelChunkSizeInKByte,
 636         dml_uint_t TotalNumberOfDCCActiveDPP,
 637         dml_uint_t MetaChunkSize,
 638         dml_bool_t GPUVMEnable,
 639         dml_bool_t HostVMEnable,
 640         dml_uint_t NumberOfActiveSurfaces,
 641         dml_uint_t NumberOfDPP[],
 642         dml_uint_t dpte_group_bytes[],
 643         dml_float_t HostVMInefficiencyFactor,
 644         dml_uint_t HostVMMinPageSize,
 645         dml_uint_t HostVMMaxNonCachedPageTableLevels);
 646
 647 static dml_float_t CalculateUrgentLatency(
 648         dml_float_t UrgentLatencyPixelDataOnly,
 649         dml_float_t UrgentLatencyPixelMixedWithVMData,
 650         dml_float_t UrgentLatencyVMDataOnly,
 651         dml_bool_t DoUrgentLatencyAdjustment,
 652         dml_float_t UrgentLatencyAdjustmentFabricClockComponent,
 653         dml_float_t UrgentLatencyAdjustmentFabricClockReference,
 654         dml_float_t FabricClockSingle);
 655
 656 static dml_bool_t UnboundedRequest(
 657         enum dml_unbounded_requesting_policy UseUnboundedRequestingFinal,
 658         dml_uint_t TotalNumberOfActiveDPP,
 659         dml_bool_t NoChromaOrLinear,
 660         enum dml_output_encoder_class Output);
 661
 662 static void CalculateSurfaceSizeInMall(
 663         dml_uint_t NumberOfActiveSurfaces,
 664         dml_uint_t MALLAllocatedForDCN,
 665         enum dml_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
 666         dml_bool_t DCCEnable[],
 667         dml_bool_t ViewportStationary[],
 668         dml_uint_t ViewportXStartY[],
 669         dml_uint_t ViewportYStartY[],
 670         dml_uint_t ViewportXStartC[],
 671         dml_uint_t ViewportYStartC[],
 672         dml_uint_t ViewportWidthY[],
 673         dml_uint_t ViewportHeightY[],
 674         dml_uint_t BytesPerPixelY[],
 675         dml_uint_t ViewportWidthC[],
 676         dml_uint_t ViewportHeightC[],
 677         dml_uint_t BytesPerPixelC[],
 678         dml_uint_t SurfaceWidthY[],
 679         dml_uint_t SurfaceWidthC[],
 680         dml_uint_t SurfaceHeightY[],
 681         dml_uint_t SurfaceHeightC[],
 682         dml_uint_t Read256BytesBlockWidthY[],
 683         dml_uint_t Read256BytesBlockWidthC[],
 684         dml_uint_t Read256BytesBlockHeightY[],
 685         dml_uint_t Read256BytesBlockHeightC[],
 686         dml_uint_t ReadBlockWidthY[],
 687         dml_uint_t ReadBlockWidthC[],
 688         dml_uint_t ReadBlockHeightY[],
 689         dml_uint_t ReadBlockHeightC[],
 690
 691         // Output
 692         dml_uint_t SurfaceSizeInMALL[],
 693         dml_bool_t *ExceededMALLSize);
 694
 695 static void CalculateDETBufferSize(
 696         dml_uint_t DETSizeOverride[],
 697         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
 698         dml_bool_t ForceSingleDPP,
 699         dml_uint_t NumberOfActiveSurfaces,
 700         dml_bool_t UnboundedRequestEnabled,
 701         dml_uint_t nomDETInKByte,
 702         dml_uint_t MaxTotalDETInKByte,
 703         dml_uint_t ConfigReturnBufferSizeInKByte,
 704         dml_uint_t MinCompressedBufferSizeInKByte,
 705         dml_uint_t ConfigReturnBufferSegmentSizeInkByte,
 706         dml_uint_t CompressedBufferSegmentSizeInkByteFinal,
 707         enum dml_source_format_class SourcePixelFormat[],
 708         dml_float_t ReadBandwidthLuma[],
 709         dml_float_t ReadBandwidthChroma[],
 710         dml_uint_t RotesY[],
 711         dml_uint_t RoundedUpMaxSwathSizeBytesC[],
 712         dml_uint_t DPPPerSurface[],
 713         // Output
 714         dml_uint_t DETBufferSizeInKByte[],
 715         dml_uint_t *CompressedBufferSizeInkByte);
 716
 717 static void CalculateMaxDETAndMinCompressedBufferSize(
 718         dml_uint_t ConfigReturnBufferSizeInKByte,
 719         dml_uint_t ConfigReturnBufferSegmentSizeInKByte,
 720         dml_uint_t ROBBufferSizeInKByte,
 721         dml_uint_t MaxNumDPP,
 722         dml_bool_t nomDETInKByteOverrideEnable,
 723         dml_uint_t nomDETInKByteOverrideValue,
 724
 725         // Output
 726         dml_uint_t *MaxTotalDETInKByte,
 727         dml_uint_t *nomDETInKByte,
 728         dml_uint_t *MinCompressedBufferSizeInKByte);
 729
 730 static dml_uint_t DSCDelayRequirement(
 731         dml_bool_t DSCEnabled,
 732         enum dml_odm_mode ODMMode,
 733         dml_uint_t DSCInputBitPerComponent,
 734         dml_float_t OutputBpp,
 735         dml_uint_t HActive,
 736         dml_uint_t HTotal,
 737         dml_uint_t NumberOfDSCSlices,
 738         enum dml_output_format_class OutputFormat,
 739         enum dml_output_encoder_class Output,
 740         dml_float_t PixelClock,
 741         dml_float_t PixelClockBackEnd);
 742
 743 static dml_bool_t CalculateVActiveBandwithSupport(
 744         dml_uint_t NumberOfActiveSurfaces,
 745         dml_float_t ReturnBW,
 746         dml_bool_t NotUrgentLatencyHiding[],
 747         dml_float_t ReadBandwidthLuma[],
 748         dml_float_t ReadBandwidthChroma[],
 749         dml_float_t cursor_bw[],
 750         dml_float_t meta_row_bandwidth[],
 751         dml_float_t dpte_row_bandwidth[],
 752         dml_uint_t NumberOfDPP[],
 753         dml_float_t UrgentBurstFactorLuma[],
 754         dml_float_t UrgentBurstFactorChroma[],
 755         dml_float_t UrgentBurstFactorCursor[]);
 756
 757 static void CalculatePrefetchBandwithSupport(
 758         dml_uint_t NumberOfActiveSurfaces,
 759         dml_float_t ReturnBW,
 760         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
 761         dml_bool_t NotUrgentLatencyHiding[],
 762         dml_float_t ReadBandwidthLuma[],
 763         dml_float_t ReadBandwidthChroma[],
 764         dml_float_t PrefetchBandwidthLuma[],
 765         dml_float_t PrefetchBandwidthChroma[],
 766         dml_float_t cursor_bw[],
 767         dml_float_t meta_row_bandwidth[],
 768         dml_float_t dpte_row_bandwidth[],
 769         dml_float_t cursor_bw_pre[],
 770         dml_float_t prefetch_vmrow_bw[],
 771         dml_uint_t NumberOfDPP[],
 772         dml_float_t UrgentBurstFactorLuma[],
 773         dml_float_t UrgentBurstFactorChroma[],
 774         dml_float_t UrgentBurstFactorCursor[],
 775         dml_float_t UrgentBurstFactorLumaPre[],
 776         dml_float_t UrgentBurstFactorChromaPre[],
 777         dml_float_t UrgentBurstFactorCursorPre[],
 778
 779         // Output
 780         dml_float_t *PrefetchBandwidth,
 781         dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch,
 782         dml_float_t *FractionOfUrgentBandwidth,
 783         dml_bool_t *PrefetchBandwidthSupport);
 784
 785 static dml_float_t CalculateBandwidthAvailableForImmediateFlip(
 786         dml_uint_t NumberOfActiveSurfaces,
 787         dml_float_t ReturnBW,
 788         dml_float_t ReadBandwidthLuma[],
 789         dml_float_t ReadBandwidthChroma[],
 790         dml_float_t PrefetchBandwidthLuma[],
 791         dml_float_t PrefetchBandwidthChroma[],
 792         dml_float_t cursor_bw[],
 793         dml_float_t cursor_bw_pre[],
 794         dml_uint_t NumberOfDPP[],
 795         dml_float_t UrgentBurstFactorLuma[],
 796         dml_float_t UrgentBurstFactorChroma[],
 797         dml_float_t UrgentBurstFactorCursor[],
 798         dml_float_t UrgentBurstFactorLumaPre[],
 799         dml_float_t UrgentBurstFactorChromaPre[],
 800         dml_float_t UrgentBurstFactorCursorPre[]);
 801
 802 static void CalculateImmediateFlipBandwithSupport(
 803         dml_uint_t NumberOfActiveSurfaces,
 804         dml_float_t ReturnBW,
 805         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
 806         enum dml_immediate_flip_requirement ImmediateFlipRequirement[],
 807         dml_float_t final_flip_bw[],
 808         dml_float_t ReadBandwidthLuma[],
 809         dml_float_t ReadBandwidthChroma[],
 810         dml_float_t PrefetchBandwidthLuma[],
 811         dml_float_t PrefetchBandwidthChroma[],
 812         dml_float_t cursor_bw[],
 813         dml_float_t meta_row_bandwidth[],
 814         dml_float_t dpte_row_bandwidth[],
 815         dml_float_t cursor_bw_pre[],
 816         dml_float_t prefetch_vmrow_bw[],
 817         dml_uint_t NumberOfDPP[],
 818         dml_float_t UrgentBurstFactorLuma[],
 819         dml_float_t UrgentBurstFactorChroma[],
 820         dml_float_t UrgentBurstFactorCursor[],
 821         dml_float_t UrgentBurstFactorLumaPre[],
 822         dml_float_t UrgentBurstFactorChromaPre[],
 823         dml_float_t UrgentBurstFactorCursorPre[],
 824
 825         // Output
 826         dml_float_t *TotalBandwidth,
 827         dml_float_t *TotalBandwidthNotIncludingMALLPrefetch,
 828         dml_float_t *FractionOfUrgentBandwidth,
 829         dml_bool_t *ImmediateFlipBandwidthSupport);
 830
 831 // ---------------------------
 832 //  Declaration Ends
 833 // ---------------------------
 834
 835 static dml_uint_t dscceComputeDelay(
 836         dml_uint_t bpc,
 837         dml_float_t BPP,
 838         dml_uint_t sliceWidth,
 839         dml_uint_t numSlices,
 840         enum dml_output_format_class pixelFormat,
 841         enum dml_output_encoder_class Output)
 842 {
 843         // valid bpc = source bits per component in the set of {8, 10, 12}
 844         // valid bpp = increments of 1/16 of a bit
 845         // min = 6/7/8 in N420/N422/444, respectively
 846         // max = such that compression is 1:1
 847         //valid sliceWidth = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
 848         //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
 849         //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
 850
 851         // fixed value
 852         dml_uint_t rcModelSize = 8192;
 853
 854         // N422/N420 operate at 2 pixels per clock
 855         dml_uint_t pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, L,
 856                 Delay, pixels;
 857
 858         if (pixelFormat == dml_420)
 859                 pixelsPerClock = 2;
 860         // #all other modes operate at 1 pixel per clock
 861         else if (pixelFormat == dml_444)
 862                 pixelsPerClock = 1;
 863         else if (pixelFormat == dml_n422)
 864                 pixelsPerClock = 2;
 865         else
 866                 pixelsPerClock = 1;
 867
 868         //initial transmit delay as per PPS
 869         initalXmitDelay = (dml_uint_t)(dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock, 1));
 870
 871         //compute ssm delay
 872         if (bpc == 8)
 873                 D = 81;
 874         else if (bpc == 10)
 875                 D = 89;
 876         else
 877                 D = 113;
 878
 879         //divide by pixel per cycle to compute slice width as seen by DSC
 880         w = sliceWidth / pixelsPerClock;
 881
 882         //422 mode has an additional cycle of delay
 883         if (pixelFormat == dml_420 || pixelFormat == dml_444 || pixelFormat == dml_n422)
 884                 s = 0;
 885         else
 886                 s = 1;
 887
 888         //main calculation for the dscce
 889         ix = initalXmitDelay + 45;
 890         wx = (w + 2) / 3;
 891         p = 3 * wx - w;
 892         l0 = ix / w;
 893         a = ix + p * l0;
 894         ax = (a + 2) / 3 + D + 6 + 1;
 895         L = (ax + wx - 1) / wx;
 896         if ((ix % w) == 0 && p != 0)
 897                 lstall = 1;
 898         else
 899                 lstall = 0;
 900         Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22;
 901
 902         //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
 903         pixels = Delay * 3 * pixelsPerClock;
 904
 905 #ifdef __DML_VBA_DEBUG__
 906         dml_print("DML::%s: bpc: %u\n", __func__, bpc);
 907         dml_print("DML::%s: BPP: %f\n", __func__, BPP);
 908         dml_print("DML::%s: sliceWidth: %u\n", __func__, sliceWidth);
 909         dml_print("DML::%s: numSlices: %u\n", __func__, numSlices);
 910         dml_print("DML::%s: pixelFormat: %u\n", __func__, pixelFormat);
 911         dml_print("DML::%s: Output: %u\n", __func__, Output);
 912         dml_print("DML::%s: pixels: %u\n", __func__, pixels);
 913 #endif
 914         return pixels;
 915 }
 916
 917 static dml_uint_t dscComputeDelay(enum dml_output_format_class pixelFormat, enum dml_output_encoder_class Output)
 918 {
 919         dml_uint_t Delay = 0;
 920
 921         if (pixelFormat == dml_420) {
 922                 // sfr
 923                 Delay = Delay + 2;
 924                 // dsccif
 925                 Delay = Delay + 0;
 926                 // dscc - input deserializer
 927                 Delay = Delay + 3;
 928                 // dscc gets pixels every other cycle
 929                 Delay = Delay + 2;
 930                 // dscc - input cdc fifo
 931                 Delay = Delay + 12;
 932                 // dscc gets pixels every other cycle
 933                 Delay = Delay + 13;
 934                 // dscc - cdc uncertainty
 935                 Delay = Delay + 2;
 936                 // dscc - output cdc fifo
 937                 Delay = Delay + 7;
 938                 // dscc gets pixels every other cycle
 939                 Delay = Delay + 3;
 940                 // dscc - cdc uncertainty
 941                 Delay = Delay + 2;
 942                 // dscc - output serializer
 943                 Delay = Delay + 1;
 944                 // sft
 945                 Delay = Delay + 1;
 946         } else if (pixelFormat == dml_n422) {
 947         // sfr
 948         Delay = Delay + 2;
 949         // dsccif
 950         Delay = Delay + 1;
 951         // dscc - input deserializer
 952         Delay = Delay + 5;
 953         // dscc - input cdc fifo
 954         Delay = Delay + 25;
 955         // dscc - cdc uncertainty
 956         Delay = Delay + 2;
 957         // dscc - output cdc fifo
 958         Delay = Delay + 10;
 959         // dscc - cdc uncertainty
 960         Delay = Delay + 2;
 961         // dscc - output serializer
 962         Delay = Delay + 1;
 963         // sft
 964         Delay = Delay + 1;
 965         } else {
 966         // sfr
 967         Delay = Delay + 2;
 968         // dsccif
 969         Delay = Delay + 0;
 970         // dscc - input deserializer
 971         Delay = Delay + 3;
 972         // dscc - input cdc fifo
 973         Delay = Delay + 12;
 974         // dscc - cdc uncertainty
 975         Delay = Delay + 2;
 976         // dscc - output cdc fifo
 977         Delay = Delay + 7;
 978         // dscc - output serializer
 979         Delay = Delay + 1;
 980         // dscc - cdc uncertainty
 981         Delay = Delay + 2;
 982         // sft
 983         Delay = Delay + 1;
 984         }
 985 #ifdef __DML_VBA_DEBUG__
 986         dml_print("DML::%s: pixelFormat = %u\n", __func__, pixelFormat);
 987         dml_print("DML::%s: Delay = %u\n", __func__, Delay);
 988 #endif
 989
 990         return Delay;
 991 }
 992
 993 static dml_bool_t CalculatePrefetchSchedule(struct display_mode_lib_scratch_st *scratch,
 994         struct CalculatePrefetchSchedule_params_st *p)
 995 {
 996         struct CalculatePrefetchSchedule_locals_st *s = &scratch->CalculatePrefetchSchedule_locals;
 997
 998         s->MyError = false;
 999         s->DPPCycles = 0;
1000         s->DISPCLKCycles = 0;
1001         s->DSTTotalPixelsAfterScaler = 0.0;
1002         s->LineTime = 0.0;
1003         s->dst_y_prefetch_equ = 0.0;
1004         s->prefetch_bw_oto = 0.0;
1005         s->Tvm_oto = 0.0;
1006         s->Tr0_oto = 0.0;
1007         s->Tvm_oto_lines = 0.0;
1008         s->Tr0_oto_lines = 0.0;
1009         s->dst_y_prefetch_oto = 0.0;
1010         s->TimeForFetchingMetaPTE = 0.0;
1011         s->TimeForFetchingRowInVBlank = 0.0;
1012         s->LinesToRequestPrefetchPixelData = 0.0;
1013         s->HostVMDynamicLevelsTrips = 0;
1014         s->trip_to_mem = 0.0;
1015         s->Tvm_trips = 0.0;
1016         s->Tr0_trips = 0.0;
1017         s->Tvm_trips_rounded = 0.0;
1018         s->Tr0_trips_rounded = 0.0;
1019         s->max_Tsw = 0.0;
1020         s->Lsw_oto = 0.0;
1021         s->Tpre_rounded = 0.0;
1022         s->prefetch_bw_equ = 0.0;
1023         s->Tvm_equ = 0.0;
1024         s->Tr0_equ = 0.0;
1025         s->Tdmbf = 0.0;
1026         s->Tdmec = 0.0;
1027         s->Tdmsks = 0.0;
1028         s->prefetch_sw_bytes = 0.0;
1029         s->prefetch_bw_pr = 0.0;
1030         s->bytes_pp = 0.0;
1031         s->dep_bytes = 0.0;
1032         s->min_Lsw_oto = 0.0;
1033         s->Tsw_est1 = 0.0;
1034         s->Tsw_est3 = 0.0;
1035
1036         if (p->GPUVMEnable == true && p->HostVMEnable == true) {
1037                 s->HostVMDynamicLevelsTrips = p->HostVMMaxNonCachedPageTableLevels;
1038         } else {
1039                 s->HostVMDynamicLevelsTrips = 0;
1040         }
1041 #ifdef __DML_VBA_DEBUG__
1042         dml_print("DML::%s: GPUVMEnable = %u\n", __func__, p->GPUVMEnable);
1043         dml_print("DML::%s: GPUVMPageTableLevels = %u\n", __func__, p->GPUVMPageTableLevels);
1044         dml_print("DML::%s: DCCEnable = %u\n", __func__, p->myPipe->DCCEnable);
1045         dml_print("DML::%s: VStartup = %u\n", __func__, p->VStartup);
1046         dml_print("DML::%s: MaxVStartup = %u\n", __func__, p->MaxVStartup);
1047         dml_print("DML::%s: HostVMEnable = %u\n", __func__, p->HostVMEnable);
1048         dml_print("DML::%s: HostVMInefficiencyFactor= %f\n", __func__, p->HostVMInefficiencyFactor);
1049         dml_print("DML::%s: myPipe->Dppclk = %f\n", __func__, p->myPipe->Dppclk);
1050 #endif
1051         CalculateVUpdateAndDynamicMetadataParameters(
1052         p->MaxInterDCNTileRepeaters,
1053         p->myPipe->Dppclk,
1054         p->myPipe->Dispclk,
1055         p->myPipe->DCFClkDeepSleep,
1056         p->myPipe->PixelClock,
1057         p->myPipe->HTotal,
1058         p->myPipe->VBlank,
1059         p->DynamicMetadataTransmittedBytes,
1060         p->DynamicMetadataLinesBeforeActiveRequired,
1061         p->myPipe->InterlaceEnable,
1062         p->myPipe->ProgressiveToInterlaceUnitInOPP,
1063         p->TSetup,
1064
1065         // Output
1066         &s->Tdmbf,
1067         &s->Tdmec,
1068         &s->Tdmsks,
1069         p->VUpdateOffsetPix,
1070         p->VUpdateWidthPix,
1071         p->VReadyOffsetPix);
1072
1073         s->LineTime = p->myPipe->HTotal / p->myPipe->PixelClock;
1074         s->trip_to_mem = p->UrgentLatency;
1075         s->Tvm_trips = p->UrgentExtraLatency + s->trip_to_mem * (p->GPUVMPageTableLevels * (s->HostVMDynamicLevelsTrips + 1) - 1);
1076
1077         if (p->DynamicMetadataVMEnabled == true) {
1078                 *p->Tdmdl = p->TWait + s->Tvm_trips + s->trip_to_mem;
1079         } else {
1080                 *p->Tdmdl = p->TWait + p->UrgentExtraLatency;
1081         }
1082
1083 #ifdef __DML_VBA_ALLOW_DELTA__
1084         if (DynamicMetadataEnable == false) {
1085                 *Tdmdl = 0.0;
1086         }
1087 #endif
1088
1089         if (p->DynamicMetadataEnable == true) {
1090                 if (p->VStartup * s->LineTime < *p->TSetup + *p->Tdmdl + s->Tdmbf + s->Tdmec + s->Tdmsks) {
1091                         *p->NotEnoughTimeForDynamicMetadata = true;
1092                         dml_print("DML::%s: Not Enough Time for Dynamic Meta!\n", __func__);
1093                         dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, s->Tdmbf);
1094                         dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, s->Tdmec);
1095                         dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", __func__, s->Tdmsks);
1096                         dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", __func__, *p->Tdmdl);
1097                 } else {
1098                         *p->NotEnoughTimeForDynamicMetadata = false;
1099                 }
1100         } else {
1101                 *p->NotEnoughTimeForDynamicMetadata = false;
1102         }
1103
1104         *p->Tdmdl_vm = (p->DynamicMetadataEnable == true && p->DynamicMetadataVMEnabled == true && p->GPUVMEnable == true ? p->TWait + s->Tvm_trips : 0);
1105
1106         if (p->myPipe->ScalerEnabled)
1107                 s->DPPCycles = (dml_uint_t)(p->DPPCLKDelaySubtotalPlusCNVCFormater + p->DPPCLKDelaySCL);
1108         else
1109                 s->DPPCycles = (dml_uint_t)(p->DPPCLKDelaySubtotalPlusCNVCFormater + p->DPPCLKDelaySCLLBOnly);
1110
1111         s->DPPCycles = (dml_uint_t)(s->DPPCycles + p->myPipe->NumberOfCursors * p->DPPCLKDelayCNVCCursor);
1112
1113         s->DISPCLKCycles = (dml_uint_t)p->DISPCLKDelaySubtotal;
1114
1115         if (p->myPipe->Dppclk == 0.0 || p->myPipe->Dispclk == 0.0)
1116                 return true;
1117
1118         *p->DSTXAfterScaler = (dml_uint_t) dml_round(s->DPPCycles * p->myPipe->PixelClock / p->myPipe->Dppclk + s->DISPCLKCycles * p->myPipe->PixelClock / p->myPipe->Dispclk + p->DSCDelay, 1.0);
1119         *p->DSTXAfterScaler = (dml_uint_t) dml_round(*p->DSTXAfterScaler + (p->myPipe->ODMMode != dml_odm_mode_bypass ? 18 : 0) + (p->myPipe->DPPPerSurface - 1) * p->DPP_RECOUT_WIDTH +
1120                                                 ((p->myPipe->ODMMode == dml_odm_mode_split_1to2 || p->myPipe->ODMMode == dml_odm_mode_mso_1to2) ? (dml_float_t)p->myPipe->HActive / 2.0 : 0) +
1121                                                 ((p->myPipe->ODMMode == dml_odm_mode_mso_1to4) ? (dml_float_t)p->myPipe->HActive * 3.0 / 4.0 : 0), 1.0);
1122
1123 #ifdef __DML_VBA_DEBUG__
1124         dml_print("DML::%s: DPPCycles = %u\n", __func__, s->DPPCycles);
1125         dml_print("DML::%s: PixelClock = %f\n", __func__, p->myPipe->PixelClock);
1126         dml_print("DML::%s: Dppclk = %f\n", __func__, p->myPipe->Dppclk);
1127         dml_print("DML::%s: DISPCLKCycles = %u\n", __func__, s->DISPCLKCycles);
1128         dml_print("DML::%s: DISPCLK = %f\n", __func__, p->myPipe->Dispclk);
1129         dml_print("DML::%s: DSCDelay = %u\n", __func__, p->DSCDelay);
1130         dml_print("DML::%s: ODMMode = %u\n", __func__, p->myPipe->ODMMode);
1131         dml_print("DML::%s: DPP_RECOUT_WIDTH = %u\n", __func__, p->DPP_RECOUT_WIDTH);
1132         dml_print("DML::%s: DSTXAfterScaler = %u\n", __func__, *p->DSTXAfterScaler);
1133 #endif
1134
1135         if (p->OutputFormat == dml_420 || (p->myPipe->InterlaceEnable && p->myPipe->ProgressiveToInterlaceUnitInOPP))
1136                 *p->DSTYAfterScaler = 1;
1137         else
1138                 *p->DSTYAfterScaler = 0;
1139
1140         s->DSTTotalPixelsAfterScaler = *p->DSTYAfterScaler * p->myPipe->HTotal + *p->DSTXAfterScaler;
1141         *p->DSTYAfterScaler = (dml_uint_t)(dml_floor(s->DSTTotalPixelsAfterScaler / p->myPipe->HTotal, 1));
1142         *p->DSTXAfterScaler = (dml_uint_t)(s->DSTTotalPixelsAfterScaler - ((dml_float_t) (*p->DSTYAfterScaler * p->myPipe->HTotal)));
1143 #ifdef __DML_VBA_DEBUG__
1144         dml_print("DML::%s: DSTXAfterScaler = %u (final)\n", __func__,  *p->DSTXAfterScaler);
1145         dml_print("DML::%s: DSTYAfterScaler = %u (final)\n", __func__, *p->DSTYAfterScaler);
1146 #endif
1147
1148         s->MyError = false;
1149
1150         s->Tr0_trips = s->trip_to_mem * (s->HostVMDynamicLevelsTrips + 1);
1151
1152         if (p->GPUVMEnable == true) {
1153                 s->Tvm_trips_rounded = dml_ceil(4.0 * s->Tvm_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1154                 s->Tr0_trips_rounded = dml_ceil(4.0 * s->Tr0_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1155                 if (p->GPUVMPageTableLevels >= 3) {
1156                         *p->Tno_bw = p->UrgentExtraLatency + s->trip_to_mem * (dml_float_t) ((p->GPUVMPageTableLevels - 2) * (s->HostVMDynamicLevelsTrips + 1) - 1);
1157         } else if (p->GPUVMPageTableLevels == 1 && p->myPipe->DCCEnable != true) {
1158                         s->Tr0_trips_rounded = dml_ceil(4.0 * p->UrgentExtraLatency / s->LineTime, 1.0) / 4.0 * s->LineTime;
1159                         *p->Tno_bw = p->UrgentExtraLatency;
1160                 } else {
1161                         *p->Tno_bw = 0;
1162                 }
1163         } else if (p->myPipe->DCCEnable == true) {
1164                 s->Tvm_trips_rounded = s->LineTime / 4.0;
1165                 s->Tr0_trips_rounded = dml_ceil(4.0 * s->Tr0_trips / s->LineTime, 1.0) / 4.0 * s->LineTime;
1166                 *p->Tno_bw = 0;
1167         } else {
1168                 s->Tvm_trips_rounded = s->LineTime / 4.0;
1169                 s->Tr0_trips_rounded = s->LineTime / 2.0;
1170                 *p->Tno_bw = 0;
1171         }
1172         s->Tvm_trips_rounded = dml_max(s->Tvm_trips_rounded, s->LineTime / 4.0);
1173         s->Tr0_trips_rounded = dml_max(s->Tr0_trips_rounded, s->LineTime / 4.0);
1174
1175         if (p->myPipe->SourcePixelFormat == dml_420_8 || p->myPipe->SourcePixelFormat == dml_420_10 || p->myPipe->SourcePixelFormat == dml_420_12) {
1176                 s->bytes_pp = p->myPipe->BytePerPixelY + p->myPipe->BytePerPixelC / 4;
1177         } else {
1178                 s->bytes_pp = p->myPipe->BytePerPixelY + p->myPipe->BytePerPixelC;
1179         }
1180
1181         s->prefetch_bw_pr = s->bytes_pp * p->myPipe->PixelClock / (dml_float_t)p->myPipe->DPPPerSurface;
1182         if (p->myPipe->VRatio < 1.0)
1183                 s->prefetch_bw_pr = p->myPipe->VRatio * s->prefetch_bw_pr;
1184
1185         s->max_Tsw = (dml_max(p->PrefetchSourceLinesY, p->PrefetchSourceLinesC) * s->LineTime);
1186
1187         s->prefetch_sw_bytes = p->PrefetchSourceLinesY * p->swath_width_luma_ub * p->myPipe->BytePerPixelY + p->PrefetchSourceLinesC * p->swath_width_chroma_ub * p->myPipe->BytePerPixelC;
1188         s->prefetch_bw_oto = dml_max(s->prefetch_bw_pr, s->prefetch_sw_bytes / s->max_Tsw);
1189
1190         s->min_Lsw_oto = dml_max(p->PrefetchSourceLinesY, p->PrefetchSourceLinesC) / __DML_MAX_VRATIO_PRE_OTO__;
1191         s->min_Lsw_oto = dml_max(s->min_Lsw_oto, 1.0);
1192         s->Lsw_oto = dml_ceil(4.0 * dml_max(s->prefetch_sw_bytes / s->prefetch_bw_oto / s->LineTime, s->min_Lsw_oto), 1.0) / 4.0;
1193
1194         if (p->GPUVMEnable == true) {
1195                 s->Tvm_oto = dml_max3(
1196                         s->Tvm_trips,
1197                         *p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->prefetch_bw_oto,
1198                         s->LineTime / 4.0);
1199         } else
1200                 s->Tvm_oto = s->LineTime / 4.0;
1201
1202         if ((p->GPUVMEnable == true || p->myPipe->DCCEnable == true)) {
1203                 s->Tr0_oto = dml_max4(
1204                         s->Tr0_trips,
1205                         (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_oto,
1206                         (s->LineTime - s->Tvm_oto)/2.0,
1207                         s->LineTime / 4.0);
1208 #ifdef __DML_VBA_DEBUG__
1209         dml_print("DML::%s: Tr0_oto max0 = %f\n", __func__, (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_oto);
1210         dml_print("DML::%s: Tr0_oto max1 = %f\n", __func__, s->Tr0_trips);
1211         dml_print("DML::%s: Tr0_oto max2 = %f\n", __func__, s->LineTime - s->Tvm_oto);
1212         dml_print("DML::%s: Tr0_oto max3 = %f\n", __func__, s->LineTime / 4);
1213 #endif
1214         } else
1215                 s->Tr0_oto = (s->LineTime - s->Tvm_oto) / 2.0;
1216
1217         s->Tvm_oto_lines = dml_ceil(4.0 * s->Tvm_oto / s->LineTime, 1) / 4.0;
1218         s->Tr0_oto_lines = dml_ceil(4.0 * s->Tr0_oto / s->LineTime, 1) / 4.0;
1219         s->dst_y_prefetch_oto = s->Tvm_oto_lines + 2 * s->Tr0_oto_lines + s->Lsw_oto;
1220
1221         s->dst_y_prefetch_equ = p->VStartup - (*p->TSetup + dml_max(p->TWait + p->TCalc, *p->Tdmdl)) / s->LineTime - (*p->DSTYAfterScaler + (dml_float_t) *p->DSTXAfterScaler / (dml_float_t)p->myPipe->HTotal);
1222
1223 #ifdef __DML_VBA_DEBUG__
1224         dml_print("DML::%s: HTotal = %u\n", __func__, p->myPipe->HTotal);
1225         dml_print("DML::%s: min_Lsw_oto = %f\n", __func__, s->min_Lsw_oto);
1226         dml_print("DML::%s: *Tno_bw = %f\n", __func__, *p->Tno_bw);
1227         dml_print("DML::%s: UrgentExtraLatency = %f\n", __func__, p->UrgentExtraLatency);
1228         dml_print("DML::%s: trip_to_mem = %f\n", __func__, s->trip_to_mem);
1229         dml_print("DML::%s: BytePerPixelY = %u\n", __func__, p->myPipe->BytePerPixelY);
1230         dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1231         dml_print("DML::%s: swath_width_luma_ub = %u\n", __func__, p->swath_width_luma_ub);
1232         dml_print("DML::%s: BytePerPixelC = %u\n", __func__, p->myPipe->BytePerPixelC);
1233         dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, p->PrefetchSourceLinesC);
1234         dml_print("DML::%s: swath_width_chroma_ub = %u\n", __func__, p->swath_width_chroma_ub);
1235         dml_print("DML::%s: prefetch_sw_bytes = %f\n", __func__, s->prefetch_sw_bytes);
1236         dml_print("DML::%s: bytes_pp = %f\n", __func__, s->bytes_pp);
1237         dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, p->PDEAndMetaPTEBytesFrame);
1238         dml_print("DML::%s: MetaRowByte = %u\n", __func__, p->MetaRowByte);
1239         dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, p->PixelPTEBytesPerRow);
1240         dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, p->HostVMInefficiencyFactor);
1241         dml_print("DML::%s: Tvm_trips = %f\n", __func__, s->Tvm_trips);
1242         dml_print("DML::%s: Tr0_trips = %f\n", __func__, s->Tr0_trips);
1243         dml_print("DML::%s: prefetch_bw_oto = %f\n", __func__, s->prefetch_bw_oto);
1244         dml_print("DML::%s: Tr0_oto = %f\n", __func__, s->Tr0_oto);
1245         dml_print("DML::%s: Tvm_oto = %f\n", __func__, s->Tvm_oto);
1246         dml_print("DML::%s: Tvm_oto_lines = %f\n", __func__, s->Tvm_oto_lines);
1247         dml_print("DML::%s: Tr0_oto_lines = %f\n", __func__, s->Tr0_oto_lines);
1248         dml_print("DML::%s: Lsw_oto = %f\n", __func__, s->Lsw_oto);
1249         dml_print("DML::%s: dst_y_prefetch_oto = %f\n", __func__, s->dst_y_prefetch_oto);
1250         dml_print("DML::%s: dst_y_prefetch_equ = %f\n", __func__, s->dst_y_prefetch_equ);
1251 #endif
1252
1253         s->dst_y_prefetch_equ = dml_floor(4.0 * (s->dst_y_prefetch_equ + 0.125), 1) / 4.0;
1254         s->Tpre_rounded = s->dst_y_prefetch_equ * s->LineTime;
1255
1256         dml_print("DML::%s: dst_y_prefetch_equ: %f (after round)\n", __func__, s->dst_y_prefetch_equ);
1257
1258         dml_print("DML::%s: LineTime: %f\n", __func__, s->LineTime);
1259         dml_print("DML::%s: VStartup: %u\n", __func__, p->VStartup);
1260         dml_print("DML::%s: Tvstartup: %fus - time between vstartup and first pixel of active\n", __func__, p->VStartup * s->LineTime);
1261         dml_print("DML::%s: TSetup: %fus - time from vstartup to vready\n", __func__, *p->TSetup);
1262         dml_print("DML::%s: TCalc: %fus - time for calculations in dchub starting at vready\n", __func__, p->TCalc);
1263         dml_print("DML::%s: TWait: %fus - time for fabric to become ready max(pstate exit,cstate enter/exit, urgent latency) after TCalc\n", __func__, p->TWait);
1264         dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, s->Tdmbf);
1265         dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, s->Tdmec);
1266         dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", __func__, s->Tdmsks);
1267         dml_print("DML::%s: Tdmdl_vm: %fus - time for vm stages of dmd \n", __func__, *p->Tdmdl_vm);
1268         dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd \n", __func__, *p->Tdmdl);
1269         dml_print("DML::%s: DSTXAfterScaler: %u pixels - number of pixel clocks pipeline and buffer delay after scaler \n", __func__, *p->DSTXAfterScaler);
1270         dml_print("DML::%s: DSTYAfterScaler: %u lines - number of lines of pipeline and buffer delay after scaler \n", __func__, *p->DSTYAfterScaler);
1271
1272         s->dep_bytes = dml_max(p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor, p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor);
1273
1274         if (s->prefetch_sw_bytes < s->dep_bytes) {
1275                 s->prefetch_sw_bytes = 2 * s->dep_bytes;
1276         }
1277
1278         *p->DestinationLinesToRequestVMInVBlank = 0;
1279         *p->DestinationLinesToRequestRowInVBlank = 0;
1280         *p->VRatioPrefetchY = 0;
1281         *p->VRatioPrefetchC = 0;
1282         *p->RequiredPrefetchPixDataBWLuma = 0;
1283         if (s->dst_y_prefetch_equ > 1) {
1284
1285                 if (s->Tpre_rounded - *p->Tno_bw > 0) {
1286                 s->PrefetchBandwidth1 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + 2 * p->MetaRowByte
1287                                         + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor
1288                                         + s->prefetch_sw_bytes)
1289                                         / (s->Tpre_rounded - *p->Tno_bw);
1290                         s->Tsw_est1 = s->prefetch_sw_bytes / s->PrefetchBandwidth1;
1291                 } else
1292                         s->PrefetchBandwidth1 = 0;
1293
1294                 if (p->VStartup == p->MaxVStartup && (s->Tsw_est1 / s->LineTime < s->min_Lsw_oto) && s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.75 * s->LineTime - *p->Tno_bw > 0) {
1295                         s->PrefetchBandwidth1 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + 2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) /
1296                                                                 (s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.75 * s->LineTime - *p->Tno_bw);
1297                 }
1298
1299                 if (s->Tpre_rounded - *p->Tno_bw - 2 * s->Tr0_trips_rounded > 0)
1300                         s->PrefetchBandwidth2 = (p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor + s->prefetch_sw_bytes) /
1301                                                                         (s->Tpre_rounded - *p->Tno_bw - 2 * s->Tr0_trips_rounded);
1302                 else
1303                         s->PrefetchBandwidth2 = 0;
1304
1305                 if (s->Tpre_rounded - s->Tvm_trips_rounded > 0) {
1306                         s->PrefetchBandwidth3 = (2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor + s->prefetch_sw_bytes) /
1307                                                                         (s->Tpre_rounded - s->Tvm_trips_rounded);
1308                         s->Tsw_est3 = s->prefetch_sw_bytes / s->PrefetchBandwidth3;
1309         }
1310                 else
1311                         s->PrefetchBandwidth3 = 0;
1312
1313
1314                 if (p->VStartup == p->MaxVStartup && (s->Tsw_est3 / s->LineTime < s->min_Lsw_oto) && s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.5 * s->LineTime - s->Tvm_trips_rounded > 0) {
1315                         s->PrefetchBandwidth3 = (2 * p->MetaRowByte + 2 * p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / (s->Tpre_rounded - s->min_Lsw_oto * s->LineTime - 0.5 * s->LineTime - s->Tvm_trips_rounded);
1316                 }
1317
1318                 if (s->Tpre_rounded - s->Tvm_trips_rounded - 2 * s->Tr0_trips_rounded > 0)
1319                         s->PrefetchBandwidth4 = s->prefetch_sw_bytes / (s->Tpre_rounded - s->Tvm_trips_rounded - 2 * s->Tr0_trips_rounded);
1320                 else
1321                         s->PrefetchBandwidth4 = 0;
1322
1323 #ifdef __DML_VBA_DEBUG__
1324                 dml_print("DML::%s: Tpre_rounded: %f\n", __func__, s->Tpre_rounded);
1325                 dml_print("DML::%s: Tno_bw: %f\n", __func__, *p->Tno_bw);
1326                 dml_print("DML::%s: Tvm_trips_rounded: %f\n", __func__, s->Tvm_trips_rounded);
1327                 dml_print("DML::%s: Tsw_est1: %f\n", __func__, s->Tsw_est1);
1328                 dml_print("DML::%s: Tsw_est3: %f\n", __func__, s->Tsw_est3);
1329                 dml_print("DML::%s: PrefetchBandwidth1: %f\n", __func__, s->PrefetchBandwidth1);
1330                 dml_print("DML::%s: PrefetchBandwidth2: %f\n", __func__, s->PrefetchBandwidth2);
1331                 dml_print("DML::%s: PrefetchBandwidth3: %f\n", __func__, s->PrefetchBandwidth3);
1332                 dml_print("DML::%s: PrefetchBandwidth4: %f\n", __func__, s->PrefetchBandwidth4);
1333 #endif
1334                 {
1335                         dml_bool_t Case1OK;
1336                         dml_bool_t Case2OK;
1337                         dml_bool_t Case3OK;
1338
1339                         if (s->PrefetchBandwidth1 > 0) {
1340                                 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth1 >= s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth1 >= s->Tr0_trips_rounded) {
1341                                         Case1OK = true;
1342                                 } else {
1343                                         Case1OK = false;
1344                                 }
1345                         } else {
1346                                 Case1OK = false;
1347                         }
1348
1349                         if (s->PrefetchBandwidth2 > 0) {
1350                                 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth2 >= s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth2 < s->Tr0_trips_rounded) {
1351                                         Case2OK = true;
1352                                 } else {
1353                                         Case2OK = false;
1354                                 }
1355                         } else {
1356                                 Case2OK = false;
1357                         }
1358
1359                         if (s->PrefetchBandwidth3 > 0) {
1360                                 if (*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->PrefetchBandwidth3 < s->Tvm_trips_rounded && (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->PrefetchBandwidth3 >= s->Tr0_trips_rounded) {
1361                                         Case3OK = true;
1362                                 } else {
1363                                         Case3OK = false;
1364                                 }
1365                         } else {
1366                                 Case3OK = false;
1367                         }
1368
1369                         if (Case1OK) {
1370                                 s->prefetch_bw_equ = s->PrefetchBandwidth1;
1371                         } else if (Case2OK) {
1372                                 s->prefetch_bw_equ = s->PrefetchBandwidth2;
1373                         } else if (Case3OK) {
1374                                 s->prefetch_bw_equ = s->PrefetchBandwidth3;
1375                         } else {
1376                                 s->prefetch_bw_equ = s->PrefetchBandwidth4;
1377                         }
1378
1379 #ifdef __DML_VBA_DEBUG__
1380                         dml_print("DML::%s: Case1OK: %u\n", __func__, Case1OK);
1381                         dml_print("DML::%s: Case2OK: %u\n", __func__, Case2OK);
1382                         dml_print("DML::%s: Case3OK: %u\n", __func__, Case3OK);
1383                         dml_print("DML::%s: prefetch_bw_equ: %f\n", __func__, s->prefetch_bw_equ);
1384 #endif
1385
1386                         if (s->prefetch_bw_equ > 0) {
1387                                 if (p->GPUVMEnable == true) {
1388                                         s->Tvm_equ = dml_max3(*p->Tno_bw + p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / s->prefetch_bw_equ, s->Tvm_trips, s->LineTime / 4);
1389                                 } else {
1390                                         s->Tvm_equ = s->LineTime / 4;
1391                                 }
1392
1393                                 if ((p->GPUVMEnable == true || p->myPipe->DCCEnable == true)) {
1394                                         s->Tr0_equ = dml_max4((p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / s->prefetch_bw_equ, s->Tr0_trips, (s->LineTime - s->Tvm_equ) / 2, s->LineTime / 4);
1395                                 } else {
1396                                         s->Tr0_equ = (s->LineTime - s->Tvm_equ) / 2;
1397                                 }
1398                         } else {
1399                                 s->Tvm_equ = 0;
1400                                 s->Tr0_equ = 0;
1401                                 dml_print("DML::%s: prefetch_bw_equ equals 0!\n", __func__);
1402                         }
1403                 }
1404
1405
1406                 if (s->dst_y_prefetch_oto < s->dst_y_prefetch_equ) {
1407                         *p->DestinationLinesForPrefetch = s->dst_y_prefetch_oto;
1408                         s->TimeForFetchingMetaPTE = s->Tvm_oto;
1409                         s->TimeForFetchingRowInVBlank = s->Tr0_oto;
1410
1411                         *p->DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1412                         *p->DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1413                 } else {
1414                         *p->DestinationLinesForPrefetch = s->dst_y_prefetch_equ;
1415                         s->TimeForFetchingMetaPTE = s->Tvm_equ;
1416                         s->TimeForFetchingRowInVBlank = s->Tr0_equ;
1417
1418                         if (p->VStartup == p->MaxVStartup && p->EnhancedPrefetchScheduleAccelerationFinal != 0) {
1419                                 *p->DestinationLinesToRequestVMInVBlank = dml_floor(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1420                                 *p->DestinationLinesToRequestRowInVBlank = dml_floor(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1421                         } else {
1422                                 *p->DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * s->TimeForFetchingMetaPTE / s->LineTime, 1.0) / 4.0;
1423                                 *p->DestinationLinesToRequestRowInVBlank = dml_ceil(4.0 * s->TimeForFetchingRowInVBlank / s->LineTime, 1.0) / 4.0;
1424                         }
1425                 }
1426
1427                 s->LinesToRequestPrefetchPixelData = *p->DestinationLinesForPrefetch - *p->DestinationLinesToRequestVMInVBlank - 2 * *p->DestinationLinesToRequestRowInVBlank;
1428
1429 #ifdef __DML_VBA_DEBUG__
1430                 dml_print("DML::%s: DestinationLinesForPrefetch = %f\n", __func__, *p->DestinationLinesForPrefetch);
1431                 dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1432                 dml_print("DML::%s: TimeForFetchingRowInVBlank = %f\n", __func__, s->TimeForFetchingRowInVBlank);
1433                 dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1434                 dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1435                 dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1436                 dml_print("DML::%s: LinesToRequestPrefetchPixelData = %f\n", __func__, s->LinesToRequestPrefetchPixelData);
1437 #endif
1438
1439                 if (s->LinesToRequestPrefetchPixelData >= 1 && s->prefetch_bw_equ > 0) {
1440                         *p->VRatioPrefetchY = (dml_float_t)p->PrefetchSourceLinesY / s->LinesToRequestPrefetchPixelData;
1441                         *p->VRatioPrefetchY = dml_max(*p->VRatioPrefetchY, 1.0);
1442 #ifdef __DML_VBA_DEBUG__
1443                         dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *p->VRatioPrefetchY);
1444                         dml_print("DML::%s: SwathHeightY = %u\n", __func__, p->SwathHeightY);
1445                         dml_print("DML::%s: VInitPreFillY = %u\n", __func__, p->VInitPreFillY);
1446 #endif
1447                         if ((p->SwathHeightY > 4) && (p->VInitPreFillY > 3)) {
1448                                 if (s->LinesToRequestPrefetchPixelData > (p->VInitPreFillY - 3.0) / 2.0) {
1449                                         *p->VRatioPrefetchY = dml_max(*p->VRatioPrefetchY,
1450                                                                                 (dml_float_t)p->MaxNumSwathY * p->SwathHeightY / (s->LinesToRequestPrefetchPixelData - (p->VInitPreFillY - 3.0) / 2.0));
1451                         } else {
1452                                 s->MyError = true;
1453                                 dml_print("DML::%s: MyErr set. LinesToRequestPrefetchPixelData=%f VinitPreFillY=%u\n", __func__, s->LinesToRequestPrefetchPixelData, p->VInitPreFillY);
1454                                 *p->VRatioPrefetchY = 0;
1455                         }
1456 #ifdef __DML_VBA_DEBUG__
1457                         dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *p->VRatioPrefetchY);
1458                         dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, p->PrefetchSourceLinesY);
1459                         dml_print("DML::%s: MaxNumSwathY = %u\n", __func__, p->MaxNumSwathY);
1460 #endif
1461                         }
1462
1463                         *p->VRatioPrefetchC = (dml_float_t)p->PrefetchSourceLinesC / s->LinesToRequestPrefetchPixelData;
1464                         *p->VRatioPrefetchC = dml_max(*p->VRatioPrefetchC, 1.0);
1465
1466 #ifdef __DML_VBA_DEBUG__
1467                         dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *p->VRatioPrefetchC);
1468                         dml_print("DML::%s: SwathHeightC = %u\n", __func__, p->SwathHeightC);
1469                         dml_print("DML::%s: VInitPreFillC = %u\n", __func__, p->VInitPreFillC);
1470 #endif
1471                         if ((p->SwathHeightC > 4) && (p->VInitPreFillC > 3)) {
1472                                 if (s->LinesToRequestPrefetchPixelData > (p->VInitPreFillC - 3.0) / 2.0) {
1473                                         *p->VRatioPrefetchC = dml_max(*p->VRatioPrefetchC, (dml_float_t)p->MaxNumSwathC * p->SwathHeightC / (s->LinesToRequestPrefetchPixelData - (p->VInitPreFillC - 3.0) / 2.0));
1474                                 } else {
1475                                         s->MyError = true;
1476                                         dml_print("DML::%s: MyErr set. LinesToRequestPrefetchPixelData=%f VInitPreFillC=%u\n", __func__, s->LinesToRequestPrefetchPixelData, p->VInitPreFillC);
1477                                         *p->VRatioPrefetchC = 0;
1478                                 }
1479 #ifdef __DML_VBA_DEBUG__
1480                                 dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *p->VRatioPrefetchC);
1481                                 dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, p->PrefetchSourceLinesC);
1482                                 dml_print("DML::%s: MaxNumSwathC = %u\n", __func__, p->MaxNumSwathC);
1483 #endif
1484                         }
1485
1486                         *p->RequiredPrefetchPixDataBWLuma = (dml_float_t)p->PrefetchSourceLinesY / s->LinesToRequestPrefetchPixelData
1487                                 * p->myPipe->BytePerPixelY
1488                                 * p->swath_width_luma_ub / s->LineTime;
1489
1490 #ifdef __DML_VBA_DEBUG__
1491                         dml_print("DML::%s: BytePerPixelY = %u\n", __func__, p->myPipe->BytePerPixelY);
1492                         dml_print("DML::%s: swath_width_luma_ub = %u\n", __func__, p->swath_width_luma_ub);
1493                         dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1494                         dml_print("DML::%s: RequiredPrefetchPixDataBWLuma = %f\n", __func__, *p->RequiredPrefetchPixDataBWLuma);
1495 #endif
1496                         *p->RequiredPrefetchPixDataBWChroma = (dml_float_t)p->PrefetchSourceLinesC / s->LinesToRequestPrefetchPixelData
1497                                 *p->myPipe->BytePerPixelC
1498                                 *p->swath_width_chroma_ub / s->LineTime;
1499                 } else {
1500                         s->MyError = true;
1501                         dml_print("DML:%s: MyErr set. LinesToRequestPrefetchPixelData: %f, should be > 0\n", __func__, s->LinesToRequestPrefetchPixelData);
1502                         *p->VRatioPrefetchY = 0;
1503                         *p->VRatioPrefetchC = 0;
1504                         *p->RequiredPrefetchPixDataBWLuma = 0;
1505                         *p->RequiredPrefetchPixDataBWChroma = 0;
1506                 }
1507
1508                 dml_print("DML: Tpre: %fus - sum of time to request meta pte, 2 x data pte + meta data, swaths\n", (dml_float_t)s->LinesToRequestPrefetchPixelData * s->LineTime + 2.0 * s->TimeForFetchingRowInVBlank + s->TimeForFetchingMetaPTE);
1509                 dml_print("DML: Tvm: %fus - time to fetch page tables for meta surface\n", s->TimeForFetchingMetaPTE);
1510                 dml_print("DML: Tr0: %fus - time to fetch first row of data pagetables and first row of meta data (done in parallel)\n", s->TimeForFetchingRowInVBlank);
1511                 dml_print("DML: Tsw: %fus = time to fetch enough pixel data and cursor data to feed the scalers init position and detile\n", (dml_float_t)s->LinesToRequestPrefetchPixelData * s->LineTime);
1512                 dml_print("DML: To: %fus - time for propagation from scaler to optc\n", (*p->DSTYAfterScaler + ((dml_float_t) (*p->DSTXAfterScaler) / (dml_float_t)p->myPipe->HTotal)) * s->LineTime);
1513                 dml_print("DML: Tvstartup - TSetup - Tcalc - Twait - Tpre - To > 0\n");
1514                 dml_print("DML: Tslack(pre): %fus - time left over in schedule\n", p->VStartup * s->LineTime - s->TimeForFetchingMetaPTE - 2 * s->TimeForFetchingRowInVBlank - (*p->DSTYAfterScaler + ((dml_float_t) (*p->DSTXAfterScaler) / (dml_float_t)p->myPipe->HTotal)) * s->LineTime - p->TWait - p->TCalc - *p->TSetup);
1515                 dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %u\n", p->PixelPTEBytesPerRow);
1516
1517         } else {
1518                 s->MyError = true;
1519                 dml_print("DML::%s: MyErr set, dst_y_prefetch_equ = %f (should be > 1)\n", __func__, s->dst_y_prefetch_equ);
1520                 s->TimeForFetchingMetaPTE = 0;
1521                 s->TimeForFetchingRowInVBlank = 0;
1522                 *p->DestinationLinesToRequestVMInVBlank = 0;
1523                 *p->DestinationLinesToRequestRowInVBlank = 0;
1524                 s->LinesToRequestPrefetchPixelData = 0;
1525                 *p->VRatioPrefetchY = 0;
1526                 *p->VRatioPrefetchC = 0;
1527                 *p->RequiredPrefetchPixDataBWLuma = 0;
1528                 *p->RequiredPrefetchPixDataBWChroma = 0;
1529         }
1530
1531         {
1532                 dml_float_t prefetch_vm_bw;
1533                 dml_float_t prefetch_row_bw;
1534
1535                 if (p->PDEAndMetaPTEBytesFrame == 0) {
1536                         prefetch_vm_bw = 0;
1537                 } else if (*p->DestinationLinesToRequestVMInVBlank > 0) {
1538 #ifdef __DML_VBA_DEBUG__
1539                         dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, p->PDEAndMetaPTEBytesFrame);
1540                         dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, p->HostVMInefficiencyFactor);
1541                         dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1542                         dml_print("DML::%s: LineTime = %f\n", __func__, s->LineTime);
1543 #endif
1544                 prefetch_vm_bw = p->PDEAndMetaPTEBytesFrame * p->HostVMInefficiencyFactor / (*p->DestinationLinesToRequestVMInVBlank * s->LineTime);
1545 #ifdef __DML_VBA_DEBUG__
1546                         dml_print("DML::%s: prefetch_vm_bw = %f\n", __func__, prefetch_vm_bw);
1547 #endif
1548                 } else {
1549                         prefetch_vm_bw = 0;
1550                         s->MyError = true;
1551                         dml_print("DML::%s: MyErr set. DestinationLinesToRequestVMInVBlank=%f (should be > 0)\n", __func__, *p->DestinationLinesToRequestVMInVBlank);
1552                 }
1553
1554                 if (p->MetaRowByte + p->PixelPTEBytesPerRow == 0) {
1555                         prefetch_row_bw = 0;
1556                 } else if (*p->DestinationLinesToRequestRowInVBlank > 0) {
1557                         prefetch_row_bw = (p->MetaRowByte + p->PixelPTEBytesPerRow * p->HostVMInefficiencyFactor) / (*p->DestinationLinesToRequestRowInVBlank * s->LineTime);
1558
1559 #ifdef __DML_VBA_DEBUG__
1560                 dml_print("DML::%s: MetaRowByte = %u\n", __func__, p->MetaRowByte);
1561                 dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, p->PixelPTEBytesPerRow);
1562                 dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1563                 dml_print("DML::%s: prefetch_row_bw = %f\n", __func__, prefetch_row_bw);
1564 #endif
1565                 } else {
1566                         prefetch_row_bw = 0;
1567                         s->MyError = true;
1568                         dml_print("DML::%s: MyErr set. DestinationLinesToRequestRowInVBlank=%f (should be > 0)\n", __func__, *p->DestinationLinesToRequestRowInVBlank);
1569                 }
1570
1571                 *p->prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw);
1572         }
1573
1574         if (s->MyError) {
1575                 s->TimeForFetchingMetaPTE = 0;
1576                 s->TimeForFetchingRowInVBlank = 0;
1577                 *p->DestinationLinesToRequestVMInVBlank = 0;
1578                 *p->DestinationLinesToRequestRowInVBlank = 0;
1579                 *p->DestinationLinesForPrefetch = 0;
1580                 s->LinesToRequestPrefetchPixelData = 0;
1581                 *p->VRatioPrefetchY = 0;
1582                 *p->VRatioPrefetchC = 0;
1583                 *p->RequiredPrefetchPixDataBWLuma = 0;
1584                 *p->RequiredPrefetchPixDataBWChroma = 0;
1585         }
1586
1587         return s->MyError;
1588 } // CalculatePrefetchSchedule
1589
1590 static void CalculateBytePerPixelAndBlockSizes(
1591         enum dml_source_format_class SourcePixelFormat,
1592         enum dml_swizzle_mode SurfaceTiling,
1593
1594         // Output
1595         dml_uint_t *BytePerPixelY,
1596         dml_uint_t *BytePerPixelC,
1597         dml_float_t *BytePerPixelDETY,
1598         dml_float_t *BytePerPixelDETC,
1599         dml_uint_t *BlockHeight256BytesY,
1600         dml_uint_t *BlockHeight256BytesC,
1601         dml_uint_t *BlockWidth256BytesY,
1602         dml_uint_t *BlockWidth256BytesC,
1603         dml_uint_t *MacroTileHeightY,
1604         dml_uint_t *MacroTileHeightC,
1605         dml_uint_t *MacroTileWidthY,
1606         dml_uint_t *MacroTileWidthC)
1607 {
1608         if (SourcePixelFormat == dml_444_64) {
1609                 *BytePerPixelDETY = 8;
1610                 *BytePerPixelDETC = 0;
1611                 *BytePerPixelY = 8;
1612                 *BytePerPixelC = 0;
1613         } else if (SourcePixelFormat == dml_444_32 || SourcePixelFormat == dml_rgbe) {
1614                 *BytePerPixelDETY = 4;
1615                 *BytePerPixelDETC = 0;
1616                 *BytePerPixelY = 4;
1617                 *BytePerPixelC = 0;
1618         } else if (SourcePixelFormat == dml_444_16 || SourcePixelFormat == dml_mono_16) {
1619                 *BytePerPixelDETY = 2;
1620                 *BytePerPixelDETC = 0;
1621                 *BytePerPixelY = 2;
1622                 *BytePerPixelC = 0;
1623         } else if (SourcePixelFormat == dml_444_8 || SourcePixelFormat == dml_mono_8) {
1624                 *BytePerPixelDETY = 1;
1625                 *BytePerPixelDETC = 0;
1626                 *BytePerPixelY = 1;
1627                 *BytePerPixelC = 0;
1628         } else if (SourcePixelFormat == dml_rgbe_alpha) {
1629                 *BytePerPixelDETY = 4;
1630                 *BytePerPixelDETC = 1;
1631                 *BytePerPixelY = 4;
1632                 *BytePerPixelC = 1;
1633         } else if (SourcePixelFormat == dml_420_8) {
1634                 *BytePerPixelDETY = 1;
1635                 *BytePerPixelDETC = 2;
1636                 *BytePerPixelY = 1;
1637                 *BytePerPixelC = 2;
1638         } else if (SourcePixelFormat == dml_420_12) {
1639                 *BytePerPixelDETY = 2;
1640                 *BytePerPixelDETC = 4;
1641                 *BytePerPixelY = 2;
1642                 *BytePerPixelC = 4;
1643         } else {
1644                 *BytePerPixelDETY = (dml_float_t) (4.0 / 3);
1645                 *BytePerPixelDETC = (dml_float_t) (8.0 / 3);
1646                 *BytePerPixelY = 2;
1647                 *BytePerPixelC = 4;
1648         }
1649 #ifdef __DML_VBA_DEBUG__
1650         dml_print("DML::%s: SourcePixelFormat = %u\n", __func__, SourcePixelFormat);
1651         dml_print("DML::%s: BytePerPixelDETY = %f\n", __func__, *BytePerPixelDETY);
1652         dml_print("DML::%s: BytePerPixelDETC = %f\n", __func__, *BytePerPixelDETC);
1653         dml_print("DML::%s: BytePerPixelY = %u\n", __func__, *BytePerPixelY);
1654         dml_print("DML::%s: BytePerPixelC = %u\n", __func__, *BytePerPixelC);
1655 #endif
1656         if ((SourcePixelFormat == dml_444_64 || SourcePixelFormat == dml_444_32
1657                 || SourcePixelFormat == dml_444_16
1658                 || SourcePixelFormat == dml_444_8
1659                 || SourcePixelFormat == dml_mono_16
1660                 || SourcePixelFormat == dml_mono_8
1661                 || SourcePixelFormat == dml_rgbe)) {
1662                 if (SurfaceTiling == dml_sw_linear) {
1663                         *BlockHeight256BytesY = 1;
1664                 } else if (SourcePixelFormat == dml_444_64) {
1665                         *BlockHeight256BytesY = 4;
1666                 } else if (SourcePixelFormat == dml_444_8) {
1667                         *BlockHeight256BytesY = 16;
1668                 } else {
1669                         *BlockHeight256BytesY = 8;
1670                 }
1671                 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
1672                 *BlockHeight256BytesC = 0;
1673                 *BlockWidth256BytesC = 0;
1674         } else {
1675                 if (SurfaceTiling == dml_sw_linear) {
1676                         *BlockHeight256BytesY = 1;
1677                         *BlockHeight256BytesC = 1;
1678                 } else if (SourcePixelFormat == dml_rgbe_alpha) {
1679                         *BlockHeight256BytesY = 8;
1680                         *BlockHeight256BytesC = 16;
1681                 } else if (SourcePixelFormat == dml_420_8) {
1682                         *BlockHeight256BytesY = 16;
1683                         *BlockHeight256BytesC = 8;
1684                 } else {
1685                         *BlockHeight256BytesY = 8;
1686                         *BlockHeight256BytesC = 8;
1687                 }
1688                 *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
1689                 *BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC;
1690         }
1691 #ifdef __DML_VBA_DEBUG__
1692         dml_print("DML::%s: BlockWidth256BytesY = %u\n", __func__, *BlockWidth256BytesY);
1693         dml_print("DML::%s: BlockHeight256BytesY = %u\n", __func__, *BlockHeight256BytesY);
1694         dml_print("DML::%s: BlockWidth256BytesC = %u\n", __func__, *BlockWidth256BytesC);
1695         dml_print("DML::%s: BlockHeight256BytesC = %u\n", __func__, *BlockHeight256BytesC);
1696 #endif
1697
1698         if (SurfaceTiling == dml_sw_linear) {
1699                 *MacroTileHeightY = *BlockHeight256BytesY;
1700                 *MacroTileWidthY = 256 / *BytePerPixelY / *MacroTileHeightY;
1701                 *MacroTileHeightC = *BlockHeight256BytesC;
1702                 if (*MacroTileHeightC == 0) {
1703                         *MacroTileWidthC = 0;
1704                 } else {
1705                         *MacroTileWidthC = 256 / *BytePerPixelC / *MacroTileHeightC;
1706         }
1707         } else if (SurfaceTiling == dml_sw_64kb_d || SurfaceTiling == dml_sw_64kb_d_t || SurfaceTiling == dml_sw_64kb_d_x || SurfaceTiling == dml_sw_64kb_r_x) {
1708                 *MacroTileHeightY = 16 * *BlockHeight256BytesY;
1709                 *MacroTileWidthY = 65536 / *BytePerPixelY / *MacroTileHeightY;
1710                 *MacroTileHeightC = 16 * *BlockHeight256BytesC;
1711                 if (*MacroTileHeightC == 0) {
1712                         *MacroTileWidthC = 0;
1713                 } else {
1714                         *MacroTileWidthC = 65536 / *BytePerPixelC / *MacroTileHeightC;
1715                 }
1716         } else {
1717                 *MacroTileHeightY = 32 * *BlockHeight256BytesY;
1718                 *MacroTileWidthY = 65536 * 4 / *BytePerPixelY / *MacroTileHeightY;
1719                 *MacroTileHeightC = 32 * *BlockHeight256BytesC;
1720                 if (*MacroTileHeightC == 0) {
1721                         *MacroTileWidthC = 0;
1722                 } else {
1723                         *MacroTileWidthC = 65536 * 4 / *BytePerPixelC / *MacroTileHeightC;
1724                 }
1725         }
1726
1727 #ifdef __DML_VBA_DEBUG__
1728         dml_print("DML::%s: MacroTileWidthY = %u\n", __func__, *MacroTileWidthY);
1729         dml_print("DML::%s: MacroTileHeightY = %u\n", __func__, *MacroTileHeightY);
1730         dml_print("DML::%s: MacroTileWidthC = %u\n", __func__, *MacroTileWidthC);
1731         dml_print("DML::%s: MacroTileHeightC = %u\n", __func__, *MacroTileHeightC);
1732 #endif
1733 } // CalculateBytePerPixelAndBlockSizes
1734
1735 static dml_float_t CalculateTWait(
1736                 dml_uint_t PrefetchMode,
1737                 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
1738                 dml_bool_t SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
1739                 dml_bool_t DRRDisplay,
1740                 dml_float_t DRAMClockChangeLatency,
1741                 dml_float_t FCLKChangeLatency,
1742                 dml_float_t UrgentLatency,
1743                 dml_float_t SREnterPlusExitTime)
1744 {
1745         dml_float_t TWait = 0.0;
1746
1747         if (PrefetchMode == 0 &&
1748                         !(UseMALLForPStateChange == dml_use_mall_pstate_change_full_frame) && !(UseMALLForPStateChange == dml_use_mall_pstate_change_sub_viewport) &&
1749                         !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe) && !(SynchronizeDRRDisplaysForUCLKPStateChangeFinal && DRRDisplay)) {
1750                 TWait = dml_max3(DRAMClockChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
1751         } else if (PrefetchMode <= 1 && !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe)) {
1752                 TWait = dml_max3(FCLKChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
1753         } else if (PrefetchMode <= 2 && !(UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe)) {
1754                 TWait = dml_max(SREnterPlusExitTime, UrgentLatency);
1755         } else {
1756                 TWait = UrgentLatency;
1757         }
1758
1759 #ifdef __DML_VBA_DEBUG__
1760         dml_print("DML::%s: PrefetchMode = %u\n", __func__, PrefetchMode);
1761         dml_print("DML::%s: TWait = %f\n", __func__, TWait);
1762 #endif
1763         return TWait;
1764 } // CalculateTWait
1765
1766
1767 /// @brief Calculate the "starting point" for prefetch calculation
1768 ///  if AllowForPStateChangeOrStutterInVBlank is set as a particular requirement, then the mode evalulation
1769 ///  will only be done at the given mode. If no specific requirement (i.e. *_if_possible), then will just go from
1770 ///  try all the prefetch mode in decreasing order of "difficulty" (start from 0 which means all power saving
1771 ///  features).
1772 static void CalculatePrefetchMode(
1773                 enum dml_prefetch_modes AllowForPStateChangeOrStutterInVBlank,
1774                 dml_uint_t *MinPrefetchMode,
1775                 dml_uint_t *MaxPrefetchMode)
1776 {
1777         if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_uclk_fclk_and_stutter_if_possible) {
1778                 *MinPrefetchMode = 0;   // consider all pwr saving features
1779                 *MaxPrefetchMode = 3;   // consider just urgent latency
1780         } else {
1781                 if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_none) {
1782                         *MinPrefetchMode = 3;
1783                 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_stutter) {
1784                         *MinPrefetchMode = 2;
1785                 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_fclk_and_stutter) {
1786                         *MinPrefetchMode = 1;
1787                 } else if (AllowForPStateChangeOrStutterInVBlank == dml_prefetch_support_uclk_fclk_and_stutter) {
1788                         *MinPrefetchMode = 0;
1789                 } else {
1790                         dml_print("ERROR: Invalid AllowForPStateChangeOrStutterInVBlank setting! val=%u\n", AllowForPStateChangeOrStutterInVBlank);
1791                         ASSERT(0);
1792                 }
1793                 *MaxPrefetchMode = *MinPrefetchMode;
1794         }
1795 } // CalculatePrefetchMode
1796
1797 static dml_float_t CalculateWriteBackDISPCLK(
1798                 enum dml_source_format_class WritebackPixelFormat,
1799                 dml_float_t PixelClock,
1800                 dml_float_t WritebackHRatio,
1801                 dml_float_t WritebackVRatio,
1802                 dml_uint_t WritebackHTaps,
1803                 dml_uint_t WritebackVTaps,
1804                 dml_uint_t WritebackSourceWidth,
1805                 dml_uint_t WritebackDestinationWidth,
1806                 dml_uint_t HTotal,
1807                 dml_uint_t WritebackLineBufferSize,
1808                 dml_float_t DISPCLKDPPCLKVCOSpeed)
1809 {
1810         dml_float_t DISPCLK_H, DISPCLK_V, DISPCLK_HB;
1811
1812         DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio;
1813         DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / (dml_float_t) HTotal;
1814         DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / (dml_float_t) WritebackSourceWidth;
1815         return RoundToDFSGranularity(dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB), 1, DISPCLKDPPCLKVCOSpeed);
1816 }
1817
1818 static dml_float_t CalculateWriteBackDelay(
1819                 enum dml_source_format_class WritebackPixelFormat,
1820                 dml_float_t WritebackHRatio,
1821                 dml_float_t WritebackVRatio,
1822                 dml_uint_t WritebackVTaps,
1823                 dml_uint_t WritebackDestinationWidth,
1824                 dml_uint_t WritebackDestinationHeight,
1825                 dml_uint_t WritebackSourceHeight,
1826                 dml_uint_t HTotal)
1827 {
1828         dml_float_t CalculateWriteBackDelay;
1829         dml_float_t Line_length;
1830         dml_float_t Output_lines_last_notclamped;
1831         dml_float_t WritebackVInit;
1832
1833         WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2;
1834         Line_length = dml_max((dml_float_t) WritebackDestinationWidth, dml_ceil((dml_float_t)WritebackDestinationWidth / 6.0, 1.0) * WritebackVTaps);
1835         Output_lines_last_notclamped = WritebackDestinationHeight - 1 - dml_ceil(((dml_float_t)WritebackSourceHeight - (dml_float_t) WritebackVInit) / (dml_float_t)WritebackVRatio, 1.0);
1836         if (Output_lines_last_notclamped < 0) {
1837                 CalculateWriteBackDelay = 0;
1838         } else {
1839                 CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length + (HTotal - WritebackDestinationWidth) + 80;
1840         }
1841         return CalculateWriteBackDelay;
1842 }
1843
1844 static void CalculateVUpdateAndDynamicMetadataParameters(
1845                 dml_uint_t MaxInterDCNTileRepeaters,
1846                 dml_float_t Dppclk,
1847                 dml_float_t Dispclk,
1848                 dml_float_t DCFClkDeepSleep,
1849                 dml_float_t PixelClock,
1850                 dml_uint_t HTotal,
1851                 dml_uint_t VBlank,
1852                 dml_uint_t DynamicMetadataTransmittedBytes,
1853                 dml_uint_t DynamicMetadataLinesBeforeActiveRequired,
1854                 dml_uint_t InterlaceEnable,
1855                 dml_bool_t ProgressiveToInterlaceUnitInOPP,
1856
1857                 // Output
1858                 dml_float_t *TSetup,
1859                 dml_float_t *Tdmbf,
1860                 dml_float_t *Tdmec,
1861                 dml_float_t *Tdmsks,
1862                 dml_uint_t *VUpdateOffsetPix,
1863                 dml_uint_t *VUpdateWidthPix,
1864                 dml_uint_t *VReadyOffsetPix)
1865 {
1866         dml_float_t TotalRepeaterDelayTime;
1867         TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / Dppclk + 3 / Dispclk);
1868         *VUpdateWidthPix = (dml_uint_t)(dml_ceil((14.0 / DCFClkDeepSleep + 12.0 / Dppclk + TotalRepeaterDelayTime) * PixelClock, 1.0));
1869         *VReadyOffsetPix = (dml_uint_t)(dml_ceil(dml_max(150.0 / Dppclk, TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / Dppclk) * PixelClock, 1.0));
1870         *VUpdateOffsetPix = (dml_uint_t)(dml_ceil(HTotal / 4.0, 1.0));
1871         *TSetup = (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock;
1872         *Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / Dispclk;
1873         *Tdmec = HTotal / PixelClock;
1874
1875         if (DynamicMetadataLinesBeforeActiveRequired == 0) {
1876                 *Tdmsks = VBlank * HTotal / PixelClock / 2.0;
1877         } else {
1878                 *Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock;
1879         }
1880         if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false) {
1881                 *Tdmsks = *Tdmsks / 2;
1882         }
1883 #ifdef __DML_VBA_DEBUG__
1884         dml_print("DML::%s: DynamicMetadataLinesBeforeActiveRequired = %u\n", __func__, DynamicMetadataLinesBeforeActiveRequired);
1885         dml_print("DML::%s: VBlank = %u\n", __func__, VBlank);
1886         dml_print("DML::%s: HTotal = %u\n", __func__, HTotal);
1887         dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock);
1888         dml_print("DML::%s: Dppclk = %f\n", __func__, Dppclk);
1889         dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, DCFClkDeepSleep);
1890         dml_print("DML::%s: MaxInterDCNTileRepeaters = %u\n", __func__, MaxInterDCNTileRepeaters);
1891         dml_print("DML::%s: TotalRepeaterDelayTime = %f\n", __func__, TotalRepeaterDelayTime);
1892
1893         dml_print("DML::%s: VUpdateWidthPix = %u\n", __func__, *VUpdateWidthPix);
1894         dml_print("DML::%s: VReadyOffsetPix = %u\n", __func__, *VReadyOffsetPix);
1895         dml_print("DML::%s: VUpdateOffsetPix = %u\n", __func__, *VUpdateOffsetPix);
1896
1897         dml_print("DML::%s: Tdmsks = %f\n", __func__, *Tdmsks);
1898 #endif
1899 }
1900
1901 static void CalculateRowBandwidth(
1902                 dml_bool_t GPUVMEnable,
1903                 enum dml_source_format_class SourcePixelFormat,
1904                 dml_float_t VRatio,
1905                 dml_float_t VRatioChroma,
1906                 dml_bool_t DCCEnable,
1907                 dml_float_t LineTime,
1908                 dml_uint_t MetaRowByteLuma,
1909                 dml_uint_t MetaRowByteChroma,
1910                 dml_uint_t meta_row_height_luma,
1911                 dml_uint_t meta_row_height_chroma,
1912                 dml_uint_t PixelPTEBytesPerRowLuma,
1913                 dml_uint_t PixelPTEBytesPerRowChroma,
1914                 dml_uint_t dpte_row_height_luma,
1915                 dml_uint_t dpte_row_height_chroma,
1916                 // Output
1917                 dml_float_t *meta_row_bw,
1918                 dml_float_t *dpte_row_bw)
1919 {
1920         if (DCCEnable != true) {
1921                 *meta_row_bw = 0;
1922         } else if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12 || SourcePixelFormat == dml_rgbe_alpha) {
1923                 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
1924                                 + VRatioChroma * MetaRowByteChroma
1925                                         / (meta_row_height_chroma * LineTime);
1926         } else {
1927                 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
1928         }
1929
1930         if (GPUVMEnable != true) {
1931                 *dpte_row_bw = 0;
1932         } else if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12 || SourcePixelFormat == dml_rgbe_alpha) {
1933                 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
1934                                 + VRatioChroma * PixelPTEBytesPerRowChroma
1935                                         / (dpte_row_height_chroma * LineTime);
1936         } else {
1937                 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
1938         }
1939 }
1940
1941 /// @brief Determine immediate flip schedule given bw remaining after considering the prefetch schedule
1942 /// @param BandwidthAvailableForImmediateFlip Bandwidth available for iflip for all planes
1943 static void CalculateFlipSchedule(
1944                 dml_float_t HostVMInefficiencyFactor,
1945                 dml_float_t UrgentExtraLatency,
1946                 dml_float_t UrgentLatency,
1947                 dml_uint_t GPUVMMaxPageTableLevels,
1948                 dml_bool_t HostVMEnable,
1949                 dml_uint_t HostVMMaxNonCachedPageTableLevels,
1950                 dml_bool_t GPUVMEnable,
1951                 dml_uint_t HostVMMinPageSize,
1952                 dml_float_t PDEAndMetaPTEBytesPerFrame,
1953                 dml_float_t MetaRowBytes,
1954                 dml_float_t DPTEBytesPerRow,
1955                 dml_float_t BandwidthAvailableForImmediateFlip,
1956                 dml_uint_t TotImmediateFlipBytes,
1957                 enum dml_source_format_class SourcePixelFormat,
1958                 dml_float_t LineTime,
1959                 dml_float_t VRatio,
1960                 dml_float_t VRatioChroma,
1961                 dml_float_t Tno_bw,
1962                 dml_bool_t DCCEnable,
1963                 dml_uint_t dpte_row_height,
1964                 dml_uint_t meta_row_height,
1965                 dml_uint_t dpte_row_height_chroma,
1966                 dml_uint_t meta_row_height_chroma,
1967                 dml_bool_t use_one_row_for_frame_flip,
1968
1969                 // Output
1970                 dml_float_t *DestinationLinesToRequestVMInImmediateFlip,
1971                 dml_float_t *DestinationLinesToRequestRowInImmediateFlip,
1972                 dml_float_t *final_flip_bw,
1973                 dml_bool_t *ImmediateFlipSupportedForPipe)
1974 {
1975         dml_float_t min_row_time = 0.0;
1976         dml_uint_t HostVMDynamicLevelsTrips = 0;
1977         dml_float_t TimeForFetchingMetaPTEImmediateFlip = 0;
1978         dml_float_t TimeForFetchingRowInVBlankImmediateFlip = 0;
1979         dml_float_t ImmediateFlipBW = 0; // @brief The immediate flip bandwidth for this pipe
1980
1981         if (GPUVMEnable == true && HostVMEnable == true) {
1982                 HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
1983         } else {
1984                 HostVMDynamicLevelsTrips = 0;
1985         }
1986
1987 #ifdef __DML_VBA_DEBUG__
1988         dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, TotImmediateFlipBytes);
1989         dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
1990         dml_print("DML::%s: UrgentLatency = %f\n", __func__, UrgentLatency);
1991         dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip);
1992 #endif
1993
1994         if (TotImmediateFlipBytes > 0) {
1995                 if (use_one_row_for_frame_flip) {
1996                         ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + 2.0 * DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / (dml_float_t) TotImmediateFlipBytes;
1997                 } else {
1998                         ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) * BandwidthAvailableForImmediateFlip / (dml_float_t) TotImmediateFlipBytes;
1999                 }
2000                 if (GPUVMEnable == true) {
2001                         TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / ImmediateFlipBW,
2002                                                                                                                 UrgentExtraLatency + UrgentLatency * (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1),
2003                                                                                                                 LineTime / 4.0);
2004                 } else {
2005                         TimeForFetchingMetaPTEImmediateFlip = 0;
2006                 }
2007                 if ((GPUVMEnable == true || DCCEnable == true)) {
2008                         TimeForFetchingRowInVBlankImmediateFlip = dml_max3((MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW, UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4.0);
2009                 } else {
2010                         TimeForFetchingRowInVBlankImmediateFlip = 0;
2011                 }
2012
2013                 *DestinationLinesToRequestVMInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1.0) / 4.0;
2014                 *DestinationLinesToRequestRowInImmediateFlip = dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1.0) / 4.0;
2015
2016                 if (GPUVMEnable == true) {
2017                         *final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
2018                                                                 (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime));
2019                 } else if ((GPUVMEnable == true || DCCEnable == true)) {
2020                         *final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / (*DestinationLinesToRequestRowInImmediateFlip * LineTime);
2021                 } else {
2022                         *final_flip_bw = 0;
2023                 }
2024         } else {
2025                 TimeForFetchingMetaPTEImmediateFlip = 0;
2026                 TimeForFetchingRowInVBlankImmediateFlip = 0;
2027                 *DestinationLinesToRequestVMInImmediateFlip = 0;
2028                 *DestinationLinesToRequestRowInImmediateFlip = 0;
2029                 *final_flip_bw = 0;
2030         }
2031
2032         if (SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_rgbe_alpha) {
2033                 if (GPUVMEnable == true && DCCEnable != true) {
2034                         min_row_time = dml_min(dpte_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma);
2035                 } else if (GPUVMEnable != true && DCCEnable == true) {
2036                         min_row_time = dml_min(meta_row_height * LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma);
2037                 } else {
2038                         min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma);
2039                 }
2040         } else {
2041                 if (GPUVMEnable == true && DCCEnable != true) {
2042                         min_row_time = dpte_row_height * LineTime / VRatio;
2043                 } else if (GPUVMEnable != true && DCCEnable == true) {
2044                         min_row_time = meta_row_height * LineTime / VRatio;
2045                 } else {
2046                         min_row_time = dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio);
2047                 }
2048         }
2049
2050         if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16 || TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip > min_row_time) {
2051                 *ImmediateFlipSupportedForPipe = false;
2052         } else {
2053                 *ImmediateFlipSupportedForPipe = true;
2054         }
2055
2056 #ifdef __DML_VBA_DEBUG__
2057         dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2058         dml_print("DML::%s: DCCEnable = %u\n", __func__, DCCEnable);
2059
2060         dml_print("DML::%s: MetaRowBytes = %f\n", __func__, MetaRowBytes);
2061         dml_print("DML::%s: DPTEBytesPerRow = %f\n", __func__, DPTEBytesPerRow);
2062         dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip);
2063         dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, TotImmediateFlipBytes);
2064         dml_print("DML::%s: ImmediateFlipBW = %f\n", __func__, ImmediateFlipBW);
2065         dml_print("DML::%s: PDEAndMetaPTEBytesPerFrame = %f\n", __func__, PDEAndMetaPTEBytesPerFrame);
2066         dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
2067         dml_print("DML::%s: LineTime = %f\n", __func__, LineTime);
2068         dml_print("DML::%s: final_flip_bw = %f\n", __func__, *final_flip_bw);
2069
2070         dml_print("DML::%s: DestinationLinesToRequestVMInImmediateFlip = %f\n", __func__, *DestinationLinesToRequestVMInImmediateFlip);
2071         dml_print("DML::%s: DestinationLinesToRequestRowInImmediateFlip = %f\n", __func__, *DestinationLinesToRequestRowInImmediateFlip);
2072         dml_print("DML::%s: TimeForFetchingMetaPTEImmediateFlip = %f\n", __func__, TimeForFetchingMetaPTEImmediateFlip);
2073         dml_print("DML::%s: TimeForFetchingRowInVBlankImmediateFlip = %f\n", __func__, TimeForFetchingRowInVBlankImmediateFlip);
2074         dml_print("DML::%s: min_row_time = %f\n", __func__, min_row_time);
2075         dml_print("DML::%s: ImmediateFlipSupportedForPipe = %u\n", __func__, *ImmediateFlipSupportedForPipe);
2076 #endif
2077 } // CalculateFlipSchedule
2078
2079 static dml_float_t RoundToDFSGranularity(dml_float_t Clock, dml_bool_t round_up, dml_float_t VCOSpeed)
2080 {
2081         if (Clock <= 0.0)
2082                 return 0.0;
2083         else {
2084                 if (round_up)
2085                         return VCOSpeed * 4.0 / dml_floor(VCOSpeed * 4.0 / Clock, 1.0);
2086                 else
2087                         return VCOSpeed * 4.0 / dml_ceil(VCOSpeed * 4.0 / Clock, 1.0);
2088         }
2089 }
2090
2091 static void CalculateDCCConfiguration(
2092                 dml_bool_t DCCEnabled,
2093                 dml_bool_t DCCProgrammingAssumesScanDirectionUnknown,
2094                 enum dml_source_format_class SourcePixelFormat,
2095                 dml_uint_t SurfaceWidthLuma,
2096                 dml_uint_t SurfaceWidthChroma,
2097                 dml_uint_t SurfaceHeightLuma,
2098                 dml_uint_t SurfaceHeightChroma,
2099                 dml_uint_t nomDETInKByte,
2100                 dml_uint_t RequestHeight256ByteLuma,
2101                 dml_uint_t RequestHeight256ByteChroma,
2102                 enum dml_swizzle_mode TilingFormat,
2103                 dml_uint_t BytePerPixelY,
2104                 dml_uint_t BytePerPixelC,
2105                 dml_float_t BytePerPixelDETY,
2106                 dml_float_t BytePerPixelDETC,
2107                 enum dml_rotation_angle SourceScan,
2108                 // Output
2109                 dml_uint_t *MaxUncompressedBlockLuma,
2110                 dml_uint_t *MaxUncompressedBlockChroma,
2111                 dml_uint_t *MaxCompressedBlockLuma,
2112                 dml_uint_t *MaxCompressedBlockChroma,
2113                 dml_uint_t *IndependentBlockLuma,
2114                 dml_uint_t *IndependentBlockChroma)
2115 {
2116         dml_uint_t DETBufferSizeForDCC = nomDETInKByte * 1024;
2117
2118         dml_uint_t yuv420;
2119         dml_uint_t horz_div_l;
2120         dml_uint_t horz_div_c;
2121         dml_uint_t vert_div_l;
2122         dml_uint_t vert_div_c;
2123
2124         dml_uint_t swath_buf_size;
2125         dml_float_t detile_buf_vp_horz_limit;
2126         dml_float_t detile_buf_vp_vert_limit;
2127
2128         dml_uint_t MAS_vp_horz_limit;
2129         dml_uint_t MAS_vp_vert_limit;
2130         dml_uint_t max_vp_horz_width;
2131         dml_uint_t max_vp_vert_height;
2132         dml_uint_t eff_surf_width_l;
2133         dml_uint_t eff_surf_width_c;
2134         dml_uint_t eff_surf_height_l;
2135         dml_uint_t eff_surf_height_c;
2136
2137         dml_uint_t full_swath_bytes_horz_wc_l;
2138         dml_uint_t full_swath_bytes_horz_wc_c;
2139         dml_uint_t full_swath_bytes_vert_wc_l;
2140         dml_uint_t full_swath_bytes_vert_wc_c;
2141
2142         dml_uint_t req128_horz_wc_l;
2143         dml_uint_t req128_horz_wc_c;
2144         dml_uint_t req128_vert_wc_l;
2145         dml_uint_t req128_vert_wc_c;
2146
2147         dml_uint_t   segment_order_horz_contiguous_luma;
2148         dml_uint_t   segment_order_horz_contiguous_chroma;
2149         dml_uint_t   segment_order_vert_contiguous_luma;
2150         dml_uint_t   segment_order_vert_contiguous_chroma;
2151
2152         typedef enum{
2153                 REQ_256Bytes,
2154                 REQ_128BytesNonContiguous,
2155                 REQ_128BytesContiguous,
2156                 REQ_NA
2157         } RequestType;
2158
2159         RequestType   RequestLuma;
2160         RequestType   RequestChroma;
2161
2162         yuv420 = ((SourcePixelFormat == dml_420_8 || SourcePixelFormat == dml_420_10 || SourcePixelFormat == dml_420_12) ? 1 : 0);
2163         horz_div_l = 1;
2164         horz_div_c = 1;
2165         vert_div_l = 1;
2166         vert_div_c = 1;
2167
2168         if (BytePerPixelY == 1)
2169                 vert_div_l = 0;
2170         if (BytePerPixelC == 1)
2171                 vert_div_c = 0;
2172
2173         if (BytePerPixelC == 0) {
2174                 swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 256;
2175                 detile_buf_vp_horz_limit = (dml_float_t) swath_buf_size / ((dml_float_t) RequestHeight256ByteLuma * BytePerPixelY / (1 + horz_div_l));
2176                 detile_buf_vp_vert_limit = (dml_float_t) swath_buf_size / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l));
2177         } else {
2178                 swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 2 * 256;
2179                 detile_buf_vp_horz_limit = (dml_float_t) swath_buf_size / ((dml_float_t) RequestHeight256ByteLuma * BytePerPixelY / (1 + horz_div_l) + (dml_float_t) RequestHeight256ByteChroma * BytePerPixelC / (1 + horz_div_c) / (1 + yuv420));
2180                 detile_buf_vp_vert_limit = (dml_float_t) swath_buf_size / (256.0 / RequestHeight256ByteLuma / (1 + vert_div_l) + 256.0 / RequestHeight256ByteChroma / (1 + vert_div_c) / (1 + yuv420));
2181         }
2182
2183         if (SourcePixelFormat == dml_420_10) {
2184                 detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit;
2185                 detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit;
2186         }
2187
2188         detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16);
2189         detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16);
2190
2191         MAS_vp_horz_limit = SourcePixelFormat == dml_rgbe_alpha ? 3840 : 6144;
2192         MAS_vp_vert_limit = SourcePixelFormat == dml_rgbe_alpha ? 3840 : (BytePerPixelY == 8 ? 3072 : 6144);
2193         max_vp_horz_width = (dml_uint_t)(dml_min((dml_float_t) MAS_vp_horz_limit, detile_buf_vp_horz_limit));
2194         max_vp_vert_height = (dml_uint_t)(dml_min((dml_float_t) MAS_vp_vert_limit, detile_buf_vp_vert_limit));
2195         eff_surf_width_l = (SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma);
2196         eff_surf_width_c = eff_surf_width_l / (1 + yuv420);
2197         eff_surf_height_l = (SurfaceHeightLuma > max_vp_vert_height ? max_vp_vert_height : SurfaceHeightLuma);
2198         eff_surf_height_c = eff_surf_height_l / (1 + yuv420);
2199
2200         full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY;
2201         full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma;
2202         if (BytePerPixelC > 0) {
2203                 full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma * BytePerPixelC;
2204                 full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma;
2205         } else {
2206                 full_swath_bytes_horz_wc_c = 0;
2207                 full_swath_bytes_vert_wc_c = 0;
2208         }
2209
2210         if (SourcePixelFormat == dml_420_10) {
2211                 full_swath_bytes_horz_wc_l = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_horz_wc_l * 2.0 / 3.0, 256.0));
2212                 full_swath_bytes_horz_wc_c = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_horz_wc_c * 2.0 / 3.0, 256.0));
2213                 full_swath_bytes_vert_wc_l = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_vert_wc_l * 2.0 / 3.0, 256.0));
2214                 full_swath_bytes_vert_wc_c = (dml_uint_t)(dml_ceil((dml_float_t) full_swath_bytes_vert_wc_c * 2.0 / 3.0, 256.0));
2215         }
2216
2217         if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2218                 req128_horz_wc_l = 0;
2219                 req128_horz_wc_c = 0;
2220         } else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c && 2 * full_swath_bytes_horz_wc_l + full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2221                 req128_horz_wc_l = 0;
2222                 req128_horz_wc_c = 1;
2223         } else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c && full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
2224                 req128_horz_wc_l = 1;
2225                 req128_horz_wc_c = 0;
2226         } else {
2227                 req128_horz_wc_l = 1;
2228                 req128_horz_wc_c = 1;
2229         }
2230
2231         if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2232                 req128_vert_wc_l = 0;
2233                 req128_vert_wc_c = 0;
2234         } else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c && 2 * full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2235                 req128_vert_wc_l = 0;
2236                 req128_vert_wc_c = 1;
2237         } else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c && full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
2238                 req128_vert_wc_l = 1;
2239                 req128_vert_wc_c = 0;
2240         } else {
2241                 req128_vert_wc_l = 1;
2242                 req128_vert_wc_c = 1;
2243         }
2244
2245         if (BytePerPixelY == 2) {
2246                 segment_order_horz_contiguous_luma = 0;
2247                 segment_order_vert_contiguous_luma = 1;
2248         } else {
2249                 segment_order_horz_contiguous_luma = 1;
2250                 segment_order_vert_contiguous_luma = 0;
2251         }
2252
2253         if (BytePerPixelC == 2) {
2254                 segment_order_horz_contiguous_chroma = 0;
2255                 segment_order_vert_contiguous_chroma = 1;
2256         } else {
2257                 segment_order_horz_contiguous_chroma = 1;
2258                 segment_order_vert_contiguous_chroma = 0;
2259         }
2260 #ifdef __DML_VBA_DEBUG__
2261         dml_print("DML::%s: DCCEnabled = %u\n", __func__, DCCEnabled);
2262         dml_print("DML::%s: nomDETInKByte = %u\n", __func__, nomDETInKByte);
2263         dml_print("DML::%s: DETBufferSizeForDCC = %u\n", __func__, DETBufferSizeForDCC);
2264         dml_print("DML::%s: req128_horz_wc_l = %u\n", __func__, req128_horz_wc_l);
2265         dml_print("DML::%s: req128_horz_wc_c = %u\n", __func__, req128_horz_wc_c);
2266         dml_print("DML::%s: full_swath_bytes_horz_wc_l = %u\n", __func__, full_swath_bytes_horz_wc_l);
2267         dml_print("DML::%s: full_swath_bytes_vert_wc_c = %u\n", __func__, full_swath_bytes_vert_wc_c);
2268         dml_print("DML::%s: segment_order_horz_contiguous_luma = %u\n", __func__, segment_order_horz_contiguous_luma);
2269         dml_print("DML::%s: segment_order_horz_contiguous_chroma = %u\n", __func__, segment_order_horz_contiguous_chroma);
2270 #endif
2271
2272         if (DCCProgrammingAssumesScanDirectionUnknown == true) {
2273                 if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0) {
2274                         RequestLuma = REQ_256Bytes;
2275                 } else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0) || (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0)) {
2276                         RequestLuma = REQ_128BytesNonContiguous;
2277                 } else {
2278                         RequestLuma = REQ_128BytesContiguous;
2279                 }
2280                 if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0) {
2281                         RequestChroma = REQ_256Bytes;
2282                 } else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0) || (req128_vert_wc_c == 1 && segment_order_vert_contiguous_chroma == 0)) {
2283                         RequestChroma = REQ_128BytesNonContiguous;
2284                 } else {
2285                         RequestChroma = REQ_128BytesContiguous;
2286                 }
2287         } else if (!dml_is_vertical_rotation(SourceScan)) {
2288                 if (req128_horz_wc_l == 0) {
2289                         RequestLuma = REQ_256Bytes;
2290                 } else if (segment_order_horz_contiguous_luma == 0) {
2291                         RequestLuma = REQ_128BytesNonContiguous;
2292                 } else {
2293                         RequestLuma = REQ_128BytesContiguous;
2294                 }
2295                 if (req128_horz_wc_c == 0) {
2296                         RequestChroma = REQ_256Bytes;
2297                 } else if (segment_order_horz_contiguous_chroma == 0) {
2298                         RequestChroma = REQ_128BytesNonContiguous;
2299                 } else {
2300                         RequestChroma = REQ_128BytesContiguous;
2301                 }
2302         } else {
2303                 if (req128_vert_wc_l == 0) {
2304                         RequestLuma = REQ_256Bytes;
2305                 } else if (segment_order_vert_contiguous_luma == 0) {
2306                         RequestLuma = REQ_128BytesNonContiguous;
2307                 } else {
2308                         RequestLuma = REQ_128BytesContiguous;
2309                 }
2310                 if (req128_vert_wc_c == 0) {
2311                         RequestChroma = REQ_256Bytes;
2312                 } else if (segment_order_vert_contiguous_chroma == 0) {
2313                         RequestChroma = REQ_128BytesNonContiguous;
2314                 } else {
2315                         RequestChroma = REQ_128BytesContiguous;
2316                 }
2317         }
2318
2319         if (RequestLuma == REQ_256Bytes) {
2320                 *MaxUncompressedBlockLuma = 256;
2321                 *MaxCompressedBlockLuma = 256;
2322                 *IndependentBlockLuma = 0;
2323         } else if (RequestLuma == REQ_128BytesContiguous) {
2324                 *MaxUncompressedBlockLuma = 256;
2325                 *MaxCompressedBlockLuma = 128;
2326                 *IndependentBlockLuma = 128;
2327         } else {
2328                 *MaxUncompressedBlockLuma = 256;
2329                 *MaxCompressedBlockLuma = 64;
2330                 *IndependentBlockLuma = 64;
2331         }
2332
2333         if (RequestChroma == REQ_256Bytes) {
2334                 *MaxUncompressedBlockChroma = 256;
2335                 *MaxCompressedBlockChroma = 256;
2336                 *IndependentBlockChroma = 0;
2337         } else if (RequestChroma == REQ_128BytesContiguous) {
2338                 *MaxUncompressedBlockChroma = 256;
2339                 *MaxCompressedBlockChroma = 128;
2340                 *IndependentBlockChroma = 128;
2341         } else {
2342                 *MaxUncompressedBlockChroma = 256;
2343                 *MaxCompressedBlockChroma = 64;
2344                 *IndependentBlockChroma = 64;
2345         }
2346
2347         if (DCCEnabled != true || BytePerPixelC == 0) {
2348                 *MaxUncompressedBlockChroma = 0;
2349                 *MaxCompressedBlockChroma = 0;
2350                 *IndependentBlockChroma = 0;
2351         }
2352
2353         if (DCCEnabled != true) {
2354                 *MaxUncompressedBlockLuma = 0;
2355                 *MaxCompressedBlockLuma = 0;
2356                 *IndependentBlockLuma = 0;
2357         }
2358
2359 #ifdef __DML_VBA_DEBUG__
2360         dml_print("DML::%s: MaxUncompressedBlockLuma = %u\n", __func__, *MaxUncompressedBlockLuma);
2361         dml_print("DML::%s: MaxCompressedBlockLuma = %u\n", __func__, *MaxCompressedBlockLuma);
2362         dml_print("DML::%s: IndependentBlockLuma = %u\n", __func__, *IndependentBlockLuma);
2363         dml_print("DML::%s: MaxUncompressedBlockChroma = %u\n", __func__, *MaxUncompressedBlockChroma);
2364         dml_print("DML::%s: MaxCompressedBlockChroma = %u\n", __func__, *MaxCompressedBlockChroma);
2365         dml_print("DML::%s: IndependentBlockChroma = %u\n", __func__, *IndependentBlockChroma);
2366 #endif
2367
2368 } // CalculateDCCConfiguration
2369
2370 static dml_uint_t CalculatePrefetchSourceLines(
2371                 dml_float_t VRatio,
2372                 dml_uint_t VTaps,
2373                 dml_bool_t Interlace,
2374                 dml_bool_t ProgressiveToInterlaceUnitInOPP,
2375                 dml_uint_t SwathHeight,
2376                 enum dml_rotation_angle SourceScan,
2377                 dml_bool_t ViewportStationary,
2378                 dml_uint_t SwathWidth,
2379                 dml_uint_t ViewportHeight,
2380                 dml_uint_t ViewportXStart,
2381                 dml_uint_t ViewportYStart,
2382
2383                 // Output
2384                 dml_uint_t *VInitPreFill,
2385                 dml_uint_t *MaxNumSwath)
2386 {
2387
2388         dml_uint_t vp_start_rot = 0;
2389         dml_uint_t sw0_tmp = 0;
2390         dml_uint_t MaxPartialSwath = 0;
2391         dml_float_t numLines = 0;
2392
2393 #ifdef __DML_VBA_DEBUG__
2394         dml_print("DML::%s: VRatio = %f\n", __func__, VRatio);
2395         dml_print("DML::%s: VTaps = %u\n", __func__, VTaps);
2396         dml_print("DML::%s: ViewportXStart = %u\n", __func__, ViewportXStart);
2397         dml_print("DML::%s: ViewportYStart = %u\n", __func__, ViewportYStart);
2398         dml_print("DML::%s: ViewportStationary = %u\n", __func__, ViewportStationary);
2399         dml_print("DML::%s: SwathHeight = %u\n", __func__, SwathHeight);
2400 #endif
2401         if (ProgressiveToInterlaceUnitInOPP)
2402                 *VInitPreFill = (dml_uint_t)(dml_floor((VRatio + (dml_float_t) VTaps + 1) / 2.0, 1));
2403         else
2404                 *VInitPreFill = (dml_uint_t)(dml_floor((VRatio + (dml_float_t) VTaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1));
2405
2406         if (ViewportStationary) {
2407                 if (SourceScan == dml_rotation_180 || SourceScan == dml_rotation_180m) {
2408                         vp_start_rot = SwathHeight - (((dml_uint_t) (ViewportYStart + ViewportHeight - 1) % SwathHeight) + 1);
2409                 } else if (SourceScan == dml_rotation_270 || SourceScan == dml_rotation_90m) {
2410                         vp_start_rot = ViewportXStart;
2411                 } else if (SourceScan == dml_rotation_90 || SourceScan == dml_rotation_270m) {
2412                         vp_start_rot = SwathHeight - (((dml_uint_t)(ViewportYStart + SwathWidth - 1) % SwathHeight) + 1);
2413                 } else {
2414                         vp_start_rot = ViewportYStart;
2415                 }
2416                 sw0_tmp = SwathHeight - (vp_start_rot % SwathHeight);
2417                 if (sw0_tmp < *VInitPreFill) {
2418                         *MaxNumSwath = (dml_uint_t)(dml_ceil((*VInitPreFill - sw0_tmp) / (dml_float_t) SwathHeight, 1) + 1);
2419                 } else {
2420                         *MaxNumSwath = 1;
2421                 }
2422                 MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (vp_start_rot + *VInitPreFill - 1) % SwathHeight));
2423         } else {
2424                 *MaxNumSwath = (dml_uint_t)(dml_ceil((*VInitPreFill - 1.0) / (dml_float_t) SwathHeight, 1) + 1);
2425                 if (*VInitPreFill > 1) {
2426                         MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (*VInitPreFill - 2) % SwathHeight));
2427                 } else {
2428                         MaxPartialSwath = (dml_uint_t)(dml_max(1, (dml_uint_t) (*VInitPreFill + SwathHeight - 2) % SwathHeight));
2429                 }
2430         }
2431         numLines = *MaxNumSwath * SwathHeight + MaxPartialSwath;
2432
2433 #ifdef __DML_VBA_DEBUG__
2434         dml_print("DML::%s: vp_start_rot = %u\n", __func__, vp_start_rot);
2435         dml_print("DML::%s: VInitPreFill = %u\n", __func__, *VInitPreFill);
2436         dml_print("DML::%s: MaxPartialSwath = %u\n", __func__, MaxPartialSwath);
2437         dml_print("DML::%s: MaxNumSwath = %u\n", __func__, *MaxNumSwath);
2438         dml_print("DML::%s: Prefetch source lines = %3.2f\n", __func__, numLines);
2439 #endif
2440         return (dml_uint_t)(numLines);
2441
2442 } // CalculatePrefetchSourceLines
2443
2444 static dml_uint_t CalculateVMAndRowBytes(
2445                 dml_bool_t ViewportStationary,
2446                 dml_bool_t DCCEnable,
2447                 dml_uint_t NumberOfDPPs,
2448                 dml_uint_t BlockHeight256Bytes,
2449                 dml_uint_t BlockWidth256Bytes,
2450                 enum dml_source_format_class SourcePixelFormat,
2451                 dml_uint_t SurfaceTiling,
2452                 dml_uint_t BytePerPixel,
2453                 enum dml_rotation_angle SourceScan,
2454                 dml_uint_t SwathWidth,
2455                 dml_uint_t ViewportHeight,
2456                 dml_uint_t ViewportXStart,
2457                 dml_uint_t ViewportYStart,
2458                 dml_bool_t GPUVMEnable,
2459                 dml_uint_t GPUVMMaxPageTableLevels,
2460                 dml_uint_t GPUVMMinPageSizeKBytes,
2461                 dml_uint_t PTEBufferSizeInRequests,
2462                 dml_uint_t Pitch,
2463                 dml_uint_t DCCMetaPitch,
2464                 dml_uint_t MacroTileWidth,
2465                 dml_uint_t MacroTileHeight,
2466
2467                 // Output
2468                 dml_uint_t *MetaRowByte,
2469                 dml_uint_t *PixelPTEBytesPerRow, // for bandwidth calculation
2470                 dml_uint_t *PixelPTEBytesPerRowStorage, // for PTE buffer size check
2471                 dml_uint_t *dpte_row_width_ub,
2472                 dml_uint_t *dpte_row_height,
2473                 dml_uint_t *dpte_row_height_linear,
2474                 dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
2475                 dml_uint_t *dpte_row_width_ub_one_row_per_frame,
2476                 dml_uint_t *dpte_row_height_one_row_per_frame,
2477                 dml_uint_t *MetaRequestWidth,
2478                 dml_uint_t *MetaRequestHeight,
2479                 dml_uint_t *meta_row_width,
2480                 dml_uint_t *meta_row_height,
2481                 dml_uint_t *PixelPTEReqWidth,
2482                 dml_uint_t *PixelPTEReqHeight,
2483                 dml_uint_t *PTERequestSize,
2484                 dml_uint_t *DPDE0BytesFrame,
2485                 dml_uint_t *MetaPTEBytesFrame)
2486 {
2487         dml_uint_t MPDEBytesFrame;
2488         dml_uint_t DCCMetaSurfaceBytes;
2489         dml_uint_t ExtraDPDEBytesFrame;
2490         dml_uint_t PDEAndMetaPTEBytesFrame;
2491         dml_uint_t MacroTileSizeBytes;
2492         dml_uint_t vp_height_meta_ub;
2493         dml_uint_t vp_height_dpte_ub;
2494
2495         dml_uint_t PixelPTEReqWidth_linear = 0; // VBA_DELTA. VBA doesn't calculate this
2496
2497         *MetaRequestHeight = 8 * BlockHeight256Bytes;
2498         *MetaRequestWidth = 8 * BlockWidth256Bytes;
2499         if (SurfaceTiling == dml_sw_linear) {
2500                 *meta_row_height = 32;
2501                 *meta_row_width = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth));
2502         } else if (!dml_is_vertical_rotation(SourceScan)) {
2503                 *meta_row_height = *MetaRequestHeight;
2504                 if (ViewportStationary && NumberOfDPPs == 1) {
2505                         *meta_row_width = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth));
2506                 } else {
2507                         *meta_row_width = (dml_uint_t)(dml_ceil(SwathWidth - 1, *MetaRequestWidth) + *MetaRequestWidth);
2508                 }
2509                 *MetaRowByte = (dml_uint_t)(*meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0);
2510         } else {
2511                 *meta_row_height = *MetaRequestWidth;
2512                 if (ViewportStationary && NumberOfDPPs == 1) {
2513                         *meta_row_width = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + *MetaRequestHeight - 1, *MetaRequestHeight) - dml_floor(ViewportYStart, *MetaRequestHeight));
2514                 } else {
2515                         *meta_row_width = (dml_uint_t)(dml_ceil(SwathWidth - 1, *MetaRequestHeight) + *MetaRequestHeight);
2516                 }
2517                 *MetaRowByte = (dml_uint_t)(*meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0);
2518         }
2519
2520         if (ViewportStationary && (NumberOfDPPs == 1 || !dml_is_vertical_rotation(SourceScan))) {
2521                 vp_height_meta_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + 64 * BlockHeight256Bytes - 1, 64 * BlockHeight256Bytes) - dml_floor(ViewportYStart, 64 * BlockHeight256Bytes));
2522         } else if (!dml_is_vertical_rotation(SourceScan)) {
2523                 vp_height_meta_ub = (dml_uint_t)(dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes);
2524         } else {
2525                 vp_height_meta_ub = (dml_uint_t)(dml_ceil(SwathWidth - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes);
2526         }
2527
2528         DCCMetaSurfaceBytes = (dml_uint_t)(DCCMetaPitch * vp_height_meta_ub * BytePerPixel / 256.0);
2529
2530         if (GPUVMEnable == true) {
2531                 *MetaPTEBytesFrame = (dml_uint_t)((dml_ceil((dml_float_t) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / (8 * 4.0 * 1024), 1) + 1) * 64);
2532                 MPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 1);
2533         } else {
2534                 *MetaPTEBytesFrame = 0;
2535                 MPDEBytesFrame = 0;
2536         }
2537
2538         if (DCCEnable != true) {
2539                 *MetaPTEBytesFrame = 0;
2540                 MPDEBytesFrame = 0;
2541                 *MetaRowByte = 0;
2542         }
2543
2544         MacroTileSizeBytes = MacroTileWidth * BytePerPixel * MacroTileHeight;
2545
2546         if (ViewportStationary && (NumberOfDPPs == 1 || !dml_is_vertical_rotation(SourceScan))) {
2547                 vp_height_dpte_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + MacroTileHeight - 1, MacroTileHeight) - dml_floor(ViewportYStart, MacroTileHeight));
2548         } else if (!dml_is_vertical_rotation(SourceScan)) {
2549                 vp_height_dpte_ub = (dml_uint_t)(dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight);
2550         } else {
2551                 vp_height_dpte_ub = (dml_uint_t)(dml_ceil(SwathWidth - 1, MacroTileHeight) + MacroTileHeight);
2552         }
2553
2554         if (GPUVMEnable == true && GPUVMMaxPageTableLevels > 1) {
2555                 *DPDE0BytesFrame = (dml_uint_t)(64 * (dml_ceil((dml_float_t) (Pitch * vp_height_dpte_ub * BytePerPixel - MacroTileSizeBytes) / (dml_float_t) (8 * 2097152), 1) + 1));
2556                 ExtraDPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 2);
2557         } else {
2558                 *DPDE0BytesFrame = 0;
2559                 ExtraDPDEBytesFrame = 0;
2560         }
2561
2562         PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame + ExtraDPDEBytesFrame;
2563
2564 #ifdef __DML_VBA_DEBUG__
2565         dml_print("DML::%s: DCCEnable = %u\n", __func__, DCCEnable);
2566         dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2567         dml_print("DML::%s: SwModeLinear = %u\n", __func__, SurfaceTiling == dml_sw_linear);
2568         dml_print("DML::%s: BytePerPixel = %u\n", __func__, BytePerPixel);
2569         dml_print("DML::%s: GPUVMMaxPageTableLevels = %u\n", __func__, GPUVMMaxPageTableLevels);
2570         dml_print("DML::%s: BlockHeight256Bytes = %u\n", __func__, BlockHeight256Bytes);
2571         dml_print("DML::%s: BlockWidth256Bytes = %u\n", __func__, BlockWidth256Bytes);
2572         dml_print("DML::%s: MacroTileHeight = %u\n", __func__, MacroTileHeight);
2573         dml_print("DML::%s: MacroTileWidth = %u\n", __func__, MacroTileWidth);
2574         dml_print("DML::%s: MetaPTEBytesFrame = %u\n", __func__, *MetaPTEBytesFrame);
2575         dml_print("DML::%s: MPDEBytesFrame = %u\n", __func__, MPDEBytesFrame);
2576         dml_print("DML::%s: DPDE0BytesFrame = %u\n", __func__, *DPDE0BytesFrame);
2577         dml_print("DML::%s: ExtraDPDEBytesFrame= %u\n", __func__, ExtraDPDEBytesFrame);
2578         dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, PDEAndMetaPTEBytesFrame);
2579         dml_print("DML::%s: ViewportHeight = %u\n", __func__, ViewportHeight);
2580         dml_print("DML::%s: SwathWidth = %u\n", __func__, SwathWidth);
2581         dml_print("DML::%s: vp_height_dpte_ub = %u\n", __func__, vp_height_dpte_ub);
2582 #endif
2583
2584         if (SurfaceTiling == dml_sw_linear) {
2585                 *PixelPTEReqHeight = 1;
2586                 *PixelPTEReqWidth = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2587                 PixelPTEReqWidth_linear = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2588                 *PTERequestSize = 64;
2589         } else if (GPUVMMinPageSizeKBytes == 4) {
2590                 *PixelPTEReqHeight = 16 * BlockHeight256Bytes;
2591                 *PixelPTEReqWidth = 16 * BlockWidth256Bytes;
2592                 *PTERequestSize = 128;
2593         } else {
2594                 *PixelPTEReqHeight = MacroTileHeight;
2595                 *PixelPTEReqWidth = 8 *  1024 * GPUVMMinPageSizeKBytes / (MacroTileHeight * BytePerPixel);
2596                 *PTERequestSize = 64;
2597         }
2598 #ifdef __DML_VBA_DEBUG__
2599         dml_print("DML::%s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
2600         dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u (after HostVM factor)\n", __func__, PDEAndMetaPTEBytesFrame);
2601         dml_print("DML::%s: PixelPTEReqHeight = %u\n", __func__, *PixelPTEReqHeight);
2602         dml_print("DML::%s: PixelPTEReqWidth = %u\n", __func__, *PixelPTEReqWidth);
2603         dml_print("DML::%s: PixelPTEReqWidth_linear = %u\n", __func__, PixelPTEReqWidth_linear);
2604         dml_print("DML::%s: PTERequestSize = %u\n", __func__, *PTERequestSize);
2605         dml_print("DML::%s: Pitch = %u\n", __func__, Pitch);
2606 #endif
2607
2608         *dpte_row_height_one_row_per_frame = vp_height_dpte_ub;
2609         *dpte_row_width_ub_one_row_per_frame = (dml_uint_t)((dml_ceil(((dml_float_t)Pitch * (dml_float_t) *dpte_row_height_one_row_per_frame / (dml_float_t) *PixelPTEReqHeight - 1) / (dml_float_t) *PixelPTEReqWidth, 1) + 1) * (dml_float_t) *PixelPTEReqWidth);
2610         *PixelPTEBytesPerRow_one_row_per_frame = (dml_uint_t)((dml_float_t) *dpte_row_width_ub_one_row_per_frame / (dml_float_t) *PixelPTEReqWidth * *PTERequestSize);
2611
2612         if (SurfaceTiling == dml_sw_linear) {
2613                 *dpte_row_height = (dml_uint_t)(dml_min(128, 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1)));
2614                 dml_print("DML::%s: dpte_row_height term 1 = %u\n", __func__, PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch);
2615                 dml_print("DML::%s: dpte_row_height term 2 = %f\n", __func__, dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch));
2616                 dml_print("DML::%s: dpte_row_height term 3 = %f\n", __func__, dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
2617                 dml_print("DML::%s: dpte_row_height term 4 = %u\n", __func__, 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
2618                 dml_print("DML::%s: dpte_row_height = %u\n", __func__, *dpte_row_height);
2619
2620                 *dpte_row_width_ub = (dml_uint_t)(dml_ceil(((dml_float_t) Pitch * (dml_float_t) *dpte_row_height - 1), (dml_float_t) *PixelPTEReqWidth) + *PixelPTEReqWidth);
2621                 *PixelPTEBytesPerRow = (dml_uint_t)((dml_float_t) *dpte_row_width_ub / (dml_float_t) *PixelPTEReqWidth * *PTERequestSize);
2622
2623                 // VBA_DELTA, VBA doesn't have programming value for pte row height linear.
2624                 *dpte_row_height_linear = 1 << (dml_uint_t) dml_floor(dml_log2(PTEBufferSizeInRequests * PixelPTEReqWidth_linear / Pitch), 1);
2625                 if (*dpte_row_height_linear > 128)
2626                         *dpte_row_height_linear = 128;
2627
2628 #ifdef __DML_VBA_DEBUG__
2629                 dml_print("DML::%s: dpte_row_width_ub = %u (linear)\n", __func__, *dpte_row_width_ub);
2630 #endif
2631
2632         } else if (!dml_is_vertical_rotation(SourceScan)) {
2633                 *dpte_row_height = *PixelPTEReqHeight;
2634
2635                 if (GPUVMMinPageSizeKBytes > 64) {
2636                         *dpte_row_width_ub = (dml_uint_t)((dml_ceil(((dml_float_t) Pitch * (dml_float_t) *dpte_row_height / (dml_float_t) *PixelPTEReqHeight - 1) / (dml_float_t) *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth);
2637                 } else if (ViewportStationary && (NumberOfDPPs == 1)) {
2638                         *dpte_row_width_ub = (dml_uint_t)(dml_floor(ViewportXStart + SwathWidth + *PixelPTEReqWidth - 1, *PixelPTEReqWidth) - dml_floor(ViewportXStart, *PixelPTEReqWidth));
2639                 } else {
2640                         *dpte_row_width_ub = (dml_uint_t)((dml_ceil((dml_float_t) (SwathWidth - 1) / (dml_float_t)*PixelPTEReqWidth, 1) + 1.0) * *PixelPTEReqWidth);
2641                 }
2642 #ifdef __DML_VBA_DEBUG__
2643                 dml_print("DML::%s: dpte_row_width_ub = %u (tiled horz)\n", __func__, *dpte_row_width_ub);
2644 #endif
2645
2646                 ASSERT(*PixelPTEReqWidth);
2647                 if (*PixelPTEReqWidth != 0)
2648                         *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
2649         } else {
2650                 *dpte_row_height = (dml_uint_t)(dml_min(*PixelPTEReqWidth, MacroTileWidth));
2651
2652                 if (ViewportStationary && (NumberOfDPPs == 1)) {
2653                         *dpte_row_width_ub = (dml_uint_t)(dml_floor(ViewportYStart + ViewportHeight + *PixelPTEReqHeight - 1, *PixelPTEReqHeight) - dml_floor(ViewportYStart, *PixelPTEReqHeight));
2654                 } else {
2655                         *dpte_row_width_ub = (dml_uint_t)((dml_ceil((dml_float_t) (SwathWidth - 1) / (dml_float_t) *PixelPTEReqHeight, 1) + 1) * *PixelPTEReqHeight);
2656                 }
2657
2658                 *PixelPTEBytesPerRow = (dml_uint_t)((dml_float_t) *dpte_row_width_ub / (dml_float_t) *PixelPTEReqHeight * *PTERequestSize);
2659 #ifdef __DML_VBA_DEBUG__
2660                 dml_print("DML::%s: dpte_row_width_ub = %u (tiled vert)\n", __func__, *dpte_row_width_ub);
2661 #endif
2662         }
2663
2664         if (GPUVMEnable != true)
2665                 *PixelPTEBytesPerRow = 0;
2666
2667         *PixelPTEBytesPerRowStorage = *PixelPTEBytesPerRow;
2668
2669 #ifdef __DML_VBA_DEBUG__
2670         dml_print("DML::%s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
2671         dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
2672         dml_print("DML::%s: dpte_row_height = %u\n", __func__, *dpte_row_height);
2673         dml_print("DML::%s: dpte_row_height_linear = %u\n", __func__, *dpte_row_height_linear);
2674         dml_print("DML::%s: dpte_row_width_ub = %u\n", __func__, *dpte_row_width_ub);
2675         dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, *PixelPTEBytesPerRow);
2676         dml_print("DML::%s: PixelPTEBytesPerRowStorage = %u\n", __func__, *PixelPTEBytesPerRowStorage);
2677         dml_print("DML::%s: PTEBufferSizeInRequests = %u\n", __func__, PTEBufferSizeInRequests);
2678         dml_print("DML::%s: dpte_row_height_one_row_per_frame = %u\n", __func__, *dpte_row_height_one_row_per_frame);
2679         dml_print("DML::%s: dpte_row_width_ub_one_row_per_frame = %u\n", __func__, *dpte_row_width_ub_one_row_per_frame);
2680         dml_print("DML::%s: PixelPTEBytesPerRow_one_row_per_frame = %u\n", __func__, *PixelPTEBytesPerRow_one_row_per_frame);
2681 #endif
2682
2683         dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n", *MetaPTEBytesFrame);
2684
2685         return PDEAndMetaPTEBytesFrame;
2686 } // CalculateVMAndRowBytes
2687
2688 static void PixelClockAdjustmentForProgressiveToInterlaceUnit(struct dml_display_cfg_st *display_cfg, dml_bool_t ptoi_supported)
2689 {
2690         dml_uint_t num_active_planes = dml_get_num_active_planes(display_cfg);
2691
2692         //Progressive To Interlace Unit Effect
2693         for (dml_uint_t k = 0; k < num_active_planes; ++k) {
2694                 display_cfg->output.PixelClockBackEnd[k] = display_cfg->timing.PixelClock[k];
2695                 if (display_cfg->timing.Interlace[k] == 1 && ptoi_supported == true) {
2696                         display_cfg->timing.PixelClock[k] = 2 * display_cfg->timing.PixelClock[k];
2697                 }
2698         }
2699 }
2700
2701 static dml_float_t TruncToValidBPP(
2702                 dml_float_t LinkBitRate,
2703                 dml_uint_t Lanes,
2704                 dml_uint_t HTotal,
2705                 dml_uint_t HActive,
2706                 dml_float_t PixelClock,
2707                 dml_float_t DesiredBPP,
2708                 dml_bool_t DSCEnable,
2709                 enum dml_output_encoder_class Output,
2710                 enum dml_output_format_class Format,
2711                 dml_uint_t DSCInputBitPerComponent,
2712                 dml_uint_t DSCSlices,
2713                 dml_uint_t AudioRate,
2714                 dml_uint_t AudioLayout,
2715                 enum dml_odm_mode ODMModeNoDSC,
2716                 enum dml_odm_mode ODMModeDSC,
2717
2718                 // Output
2719                 dml_uint_t *RequiredSlots)
2720 {
2721         dml_float_t MaxLinkBPP;
2722         dml_uint_t MinDSCBPP;
2723         dml_float_t MaxDSCBPP;
2724         dml_uint_t NonDSCBPP0;
2725         dml_uint_t NonDSCBPP1;
2726         dml_uint_t NonDSCBPP2;
2727
2728         if (Format == dml_420) {
2729                 NonDSCBPP0 = 12;
2730                 NonDSCBPP1 = 15;
2731                 NonDSCBPP2 = 18;
2732                 MinDSCBPP = 6;
2733                 MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1 / 16;
2734         } else if (Format == dml_444) {
2735                 NonDSCBPP0 = 24;
2736                 NonDSCBPP1 = 30;
2737                 NonDSCBPP2 = 36;
2738                 MinDSCBPP = 8;
2739                 MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16;
2740         } else {
2741                 if (Output == dml_hdmi) {
2742                         NonDSCBPP0 = 24;
2743                         NonDSCBPP1 = 24;
2744                         NonDSCBPP2 = 24;
2745                 } else {
2746                         NonDSCBPP0 = 16;
2747                         NonDSCBPP1 = 20;
2748                         NonDSCBPP2 = 24;
2749         }
2750         if (Format == dml_n422) {
2751                 MinDSCBPP = 7;
2752                         MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0;
2753                 } else {
2754                         MinDSCBPP = 8;
2755                         MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0;
2756                 }
2757         }
2758
2759         if (Output == dml_dp2p0) {
2760                 MaxLinkBPP = LinkBitRate * Lanes / PixelClock * 128.0 / 132.0 * 383.0 / 384.0 * 65536.0 / 65540.0;
2761         } else if (DSCEnable && Output == dml_dp) {
2762                 MaxLinkBPP = LinkBitRate / 10.0 * 8.0 * Lanes / PixelClock * (1 - 2.4 / 100);
2763         } else {
2764                 MaxLinkBPP = LinkBitRate / 10.0 * 8.0 * Lanes / PixelClock;
2765         }
2766
2767         if (DSCEnable) {
2768                 if (ODMModeDSC == dml_odm_mode_combine_4to1) {
2769                         MaxLinkBPP = dml_min(MaxLinkBPP, 16);
2770                 } else if (ODMModeDSC == dml_odm_mode_combine_2to1) {
2771                         MaxLinkBPP = dml_min(MaxLinkBPP, 32);
2772                 } else if (ODMModeDSC == dml_odm_mode_split_1to2) {
2773                         MaxLinkBPP = 2 * MaxLinkBPP;
2774                 }
2775         } else {
2776                 if (ODMModeNoDSC == dml_odm_mode_combine_4to1) {
2777                         MaxLinkBPP = dml_min(MaxLinkBPP, 16);
2778                 } else if (ODMModeNoDSC == dml_odm_mode_combine_2to1) {
2779                         MaxLinkBPP = dml_min(MaxLinkBPP, 32);
2780                 } else if (ODMModeNoDSC == dml_odm_mode_split_1to2) {
2781                         MaxLinkBPP = 2 * MaxLinkBPP;
2782                 }
2783         }
2784
2785         if (DesiredBPP == 0) {
2786                 if (DSCEnable) {
2787                         if (MaxLinkBPP < MinDSCBPP) {
2788                                 return __DML_DPP_INVALID__;
2789                         } else if (MaxLinkBPP >= MaxDSCBPP) {
2790                                 return MaxDSCBPP;
2791                         } else {
2792                                 return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0;
2793                         }
2794                 } else {
2795                         if (MaxLinkBPP >= NonDSCBPP2) {
2796                                 return NonDSCBPP2;
2797                         } else if (MaxLinkBPP >= NonDSCBPP1) {
2798                                 return NonDSCBPP1;
2799                         } else if (MaxLinkBPP >= NonDSCBPP0) {
2800                                 return NonDSCBPP0;
2801                         } else {
2802                                 return __DML_DPP_INVALID__;
2803                         }
2804                 }
2805         } else {
2806                 if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 || DesiredBPP == NonDSCBPP0)) ||
2807                                 (DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP))) {
2808                         return __DML_DPP_INVALID__;
2809                 } else {
2810                         return DesiredBPP;
2811                 }
2812         }
2813
2814         *RequiredSlots = (dml_uint_t)(dml_ceil(DesiredBPP / MaxLinkBPP * 64, 1));
2815
2816         return __DML_DPP_INVALID__;
2817 } // TruncToValidBPP
2818
2819 static void CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
2820                 struct display_mode_lib_scratch_st *scratch,
2821                 struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *p)
2822 {
2823         struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_locals_st *s = &scratch->CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_locals;
2824
2825         s->TotalActiveWriteback = 0;
2826         p->Watermark->UrgentWatermark = p->mmSOCParameters.UrgentLatency + p->mmSOCParameters.ExtraLatency;
2827         p->Watermark->USRRetrainingWatermark = p->mmSOCParameters.UrgentLatency + p->mmSOCParameters.ExtraLatency + p->mmSOCParameters.USRRetrainingLatency + p->mmSOCParameters.SMNLatency;
2828         p->Watermark->DRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->Watermark->UrgentWatermark;
2829         p->Watermark->FCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->Watermark->UrgentWatermark;
2830         p->Watermark->StutterExitWatermark = p->mmSOCParameters.SRExitTime + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2831         p->Watermark->StutterEnterPlusExitWatermark = p->mmSOCParameters.SREnterPlusExitTime + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2832         p->Watermark->Z8StutterExitWatermark = p->mmSOCParameters.SRExitZ8Time + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2833         p->Watermark->Z8StutterEnterPlusExitWatermark = p->mmSOCParameters.SREnterPlusExitZ8Time + p->mmSOCParameters.ExtraLatency + 10 / p->DCFClkDeepSleep;
2834
2835 #ifdef __DML_VBA_DEBUG__
2836         dml_print("DML::%s: UrgentLatency = %f\n", __func__, p->mmSOCParameters.UrgentLatency);
2837         dml_print("DML::%s: ExtraLatency = %f\n", __func__, p->mmSOCParameters.ExtraLatency);
2838         dml_print("DML::%s: DRAMClockChangeLatency = %f\n", __func__, p->mmSOCParameters.DRAMClockChangeLatency);
2839         dml_print("DML::%s: UrgentWatermark = %f\n", __func__, p->Watermark->UrgentWatermark);
2840         dml_print("DML::%s: USRRetrainingWatermark = %f\n", __func__, p->Watermark->USRRetrainingWatermark);
2841         dml_print("DML::%s: DRAMClockChangeWatermark = %f\n", __func__, p->Watermark->DRAMClockChangeWatermark);
2842         dml_print("DML::%s: FCLKChangeWatermark = %f\n", __func__, p->Watermark->FCLKChangeWatermark);
2843         dml_print("DML::%s: StutterExitWatermark = %f\n", __func__, p->Watermark->StutterExitWatermark);
2844         dml_print("DML::%s: StutterEnterPlusExitWatermark = %f\n", __func__, p->Watermark->StutterEnterPlusExitWatermark);
2845         dml_print("DML::%s: Z8StutterExitWatermark = %f\n", __func__, p->Watermark->Z8StutterExitWatermark);
2846         dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, p->Watermark->Z8StutterEnterPlusExitWatermark);
2847 #endif
2848
2849         s->TotalActiveWriteback = 0;
2850         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2851                 if (p->WritebackEnable[k] == true) {
2852                         s->TotalActiveWriteback = s->TotalActiveWriteback + 1;
2853                 }
2854         }
2855
2856         if (s->TotalActiveWriteback <= 1) {
2857                 p->Watermark->WritebackUrgentWatermark = p->mmSOCParameters.WritebackLatency;
2858         } else {
2859                 p->Watermark->WritebackUrgentWatermark = p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024.0 / 32.0 / p->SOCCLK;
2860         }
2861         if (p->USRRetrainingRequiredFinal)
2862                 p->Watermark->WritebackUrgentWatermark = p->Watermark->WritebackUrgentWatermark + p->mmSOCParameters.USRRetrainingLatency;
2863
2864         if (s->TotalActiveWriteback <= 1) {
2865                 p->Watermark->WritebackDRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.WritebackLatency;
2866                 p->Watermark->WritebackFCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->mmSOCParameters.WritebackLatency;
2867         } else {
2868                 p->Watermark->WritebackDRAMClockChangeWatermark = p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024.0 / 32.0 / p->SOCCLK;
2869                 p->Watermark->WritebackFCLKChangeWatermark = p->mmSOCParameters.FCLKChangeLatency + p->mmSOCParameters.WritebackLatency + p->WritebackChunkSize * 1024 / 32 / p->SOCCLK;
2870         }
2871
2872         if (p->USRRetrainingRequiredFinal)
2873                 p->Watermark->WritebackDRAMClockChangeWatermark = p->Watermark->WritebackDRAMClockChangeWatermark + p->mmSOCParameters.USRRetrainingLatency;
2874
2875         if (p->USRRetrainingRequiredFinal)
2876                 p->Watermark->WritebackFCLKChangeWatermark = p->Watermark->WritebackFCLKChangeWatermark + p->mmSOCParameters.USRRetrainingLatency;
2877
2878 #ifdef __DML_VBA_DEBUG__
2879         dml_print("DML::%s: WritebackDRAMClockChangeWatermark = %f\n", __func__, p->Watermark->WritebackDRAMClockChangeWatermark);
2880         dml_print("DML::%s: WritebackFCLKChangeWatermark = %f\n", __func__, p->Watermark->WritebackFCLKChangeWatermark);
2881         dml_print("DML::%s: WritebackUrgentWatermark = %f\n", __func__, p->Watermark->WritebackUrgentWatermark);
2882         dml_print("DML::%s: USRRetrainingRequiredFinal = %u\n", __func__, p->USRRetrainingRequiredFinal);
2883         dml_print("DML::%s: USRRetrainingLatency = %f\n", __func__, p->mmSOCParameters.USRRetrainingLatency);
2884 #endif
2885
2886         s->TotalPixelBW = 0.0;
2887         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2888                 s->TotalPixelBW = s->TotalPixelBW + p->DPPPerSurface[k]
2889                                         * (p->SwathWidthY[k] * p->BytePerPixelDETY[k] * p->VRatio[k] + p->SwathWidthC[k] * p->BytePerPixelDETC[k] * p->VRatioChroma[k]) / (p->HTotal[k] / p->PixelClock[k]);
2890         }
2891
2892         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2893
2894                 s->LBLatencyHidingSourceLinesY[k] = (dml_uint_t)(dml_min((dml_float_t)p->MaxLineBufferLines, dml_floor((dml_float_t)p->LineBufferSize / (dml_float_t)p->LBBitPerPixel[k] / ((dml_float_t)p->SwathWidthY[k] / dml_max(p->HRatio[k], 1.0)), 1)) - (p->VTaps[k] - 1));
2895                 s->LBLatencyHidingSourceLinesC[k] = (dml_uint_t)(dml_min((dml_float_t)p->MaxLineBufferLines, dml_floor((dml_float_t)p->LineBufferSize / (dml_float_t)p->LBBitPerPixel[k] / ((dml_float_t)p->SwathWidthC[k] / dml_max(p->HRatioChroma[k], 1.0)), 1)) - (p->VTapsChroma[k] - 1));
2896
2897
2898 #ifdef __DML_VBA_DEBUG__
2899                 dml_print("DML::%s: k=%u, MaxLineBufferLines = %u\n", __func__, k, p->MaxLineBufferLines);
2900                 dml_print("DML::%s: k=%u, LineBufferSize = %u\n", __func__, k, p->LineBufferSize);
2901                 dml_print("DML::%s: k=%u, LBBitPerPixel = %u\n", __func__, k, p->LBBitPerPixel[k]);
2902                 dml_print("DML::%s: k=%u, HRatio = %f\n", __func__, k, p->HRatio[k]);
2903                 dml_print("DML::%s: k=%u, VTaps              = %u\n", __func__, k, p->VTaps[k]);
2904 #endif
2905
2906                 s->EffectiveLBLatencyHidingY = s->LBLatencyHidingSourceLinesY[k] / p->VRatio[k] * (p->HTotal[k] / p->PixelClock[k]);
2907                 s->EffectiveLBLatencyHidingC = s->LBLatencyHidingSourceLinesC[k] / p->VRatioChroma[k] * (p->HTotal[k] / p->PixelClock[k]);
2908
2909                 s->EffectiveDETBufferSizeY = p->DETBufferSizeY[k];
2910                 if (p->UnboundedRequestEnabled) {
2911                         s->EffectiveDETBufferSizeY = s->EffectiveDETBufferSizeY + p->CompressedBufferSizeInkByte * 1024 * (p->SwathWidthY[k] * p->BytePerPixelDETY[k] * p->VRatio[k]) / (p->HTotal[k] / p->PixelClock[k]) / s->TotalPixelBW;
2912                 }
2913
2914                 s->LinesInDETY[k] = (dml_float_t)s->EffectiveDETBufferSizeY / p->BytePerPixelDETY[k] / p->SwathWidthY[k];
2915                 s->LinesInDETYRoundedDownToSwath[k] = (dml_uint_t)(dml_floor(s->LinesInDETY[k], p->SwathHeightY[k]));
2916                 s->FullDETBufferingTimeY = s->LinesInDETYRoundedDownToSwath[k] * (p->HTotal[k] / p->PixelClock[k]) / p->VRatio[k];
2917
2918                 s->ActiveClockChangeLatencyHidingY = s->EffectiveLBLatencyHidingY + s->FullDETBufferingTimeY - ((dml_float_t)p->DSTXAfterScaler[k] / (dml_float_t)p->HTotal[k] + (dml_float_t)p->DSTYAfterScaler[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
2919
2920                 if (p->NumberOfActiveSurfaces > 1) {
2921                         s->ActiveClockChangeLatencyHidingY = s->ActiveClockChangeLatencyHidingY - (1.0 - 1.0 / (dml_float_t)p->NumberOfActiveSurfaces) * (dml_float_t)p->SwathHeightY[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k] / p->VRatio[k];
2922         }
2923
2924                 if (p->BytePerPixelDETC[k] > 0) {
2925                         s->LinesInDETC[k] = p->DETBufferSizeC[k] / p->BytePerPixelDETC[k] / p->SwathWidthC[k];
2926                         s->LinesInDETCRoundedDownToSwath[k] = (dml_uint_t)(dml_floor(s->LinesInDETC[k], p->SwathHeightC[k]));
2927                         s->FullDETBufferingTimeC = s->LinesInDETCRoundedDownToSwath[k] * (p->HTotal[k] / p->PixelClock[k]) / p->VRatioChroma[k];
2928                         s->ActiveClockChangeLatencyHidingC = s->EffectiveLBLatencyHidingC + s->FullDETBufferingTimeC - ((dml_float_t)p->DSTXAfterScaler[k] / (dml_float_t)p->HTotal[k] + (dml_float_t)p->DSTYAfterScaler[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
2929                         if (p->NumberOfActiveSurfaces > 1) {
2930                         s->ActiveClockChangeLatencyHidingC = s->ActiveClockChangeLatencyHidingC - (1.0 - 1.0 / (dml_float_t)p->NumberOfActiveSurfaces) * (dml_float_t)p->SwathHeightC[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k] / p->VRatioChroma[k];
2931                         }
2932                         s->ActiveClockChangeLatencyHiding = dml_min(s->ActiveClockChangeLatencyHidingY, s->ActiveClockChangeLatencyHidingC);
2933                 } else {
2934                         s->ActiveClockChangeLatencyHiding = s->ActiveClockChangeLatencyHidingY;
2935                 }
2936
2937                 s->ActiveDRAMClockChangeLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->UrgentWatermark - p->Watermark->DRAMClockChangeWatermark;
2938                 s->ActiveFCLKChangeLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->UrgentWatermark - p->Watermark->FCLKChangeWatermark;
2939                 s->USRRetrainingLatencyMargin[k] = s->ActiveClockChangeLatencyHiding - p->Watermark->USRRetrainingWatermark;
2940
2941                 if (p->WritebackEnable[k]) {
2942                         s->WritebackLatencyHiding = (dml_float_t)p->WritebackInterfaceBufferSize * 1024.0 / ((dml_float_t)p->WritebackDestinationWidth[k] * (dml_float_t)p->WritebackDestinationHeight[k] / ((dml_float_t)p->WritebackSourceHeight[k] * (dml_float_t)p->HTotal[k] / p->PixelClock[k]) * 4.0);
2943                         if (p->WritebackPixelFormat[k] == dml_444_64) {
2944                                 s->WritebackLatencyHiding = s->WritebackLatencyHiding / 2;
2945                         }
2946                         s->WritebackDRAMClockChangeLatencyMargin = s->WritebackLatencyHiding - p->Watermark->WritebackDRAMClockChangeWatermark;
2947
2948                         s->WritebackFCLKChangeLatencyMargin = s->WritebackLatencyHiding - p->Watermark->WritebackFCLKChangeWatermark;
2949
2950                         s->ActiveDRAMClockChangeLatencyMargin[k] = dml_min(s->ActiveDRAMClockChangeLatencyMargin[k], s->WritebackFCLKChangeLatencyMargin);
2951                         s->ActiveFCLKChangeLatencyMargin[k] = dml_min(s->ActiveFCLKChangeLatencyMargin[k], s->WritebackDRAMClockChangeLatencyMargin);
2952                 }
2953                 p->MaxActiveDRAMClockChangeLatencySupported[k] =  (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) ? 0 : (s->ActiveDRAMClockChangeLatencyMargin[k] + p->mmSOCParameters.DRAMClockChangeLatency);
2954                 p->ActiveDRAMClockChangeLatencyMargin[k] = s->ActiveDRAMClockChangeLatencyMargin[k];
2955         }
2956
2957         *p->USRRetrainingSupport = true;
2958         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2959                 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) && (s->USRRetrainingLatencyMargin[k] < 0)) {
2960                         *p->USRRetrainingSupport = false;
2961                 }
2962         }
2963
2964         s->FoundCriticalSurface = false;
2965         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2966                 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) && ((!s->FoundCriticalSurface)
2967                         || ((s->ActiveFCLKChangeLatencyMargin[k] + p->mmSOCParameters.FCLKChangeLatency) < *p->MaxActiveFCLKChangeLatencySupported))) {
2968                         s->FoundCriticalSurface = true;
2969                         *p->MaxActiveFCLKChangeLatencySupported = s->ActiveFCLKChangeLatencyMargin[k] + p->mmSOCParameters.FCLKChangeLatency;
2970                 }
2971         }
2972
2973         for (dml_uint_t i = 0; i < p->NumberOfActiveSurfaces; ++i) {
2974                 for (dml_uint_t j = 0; j < p->NumberOfActiveSurfaces; ++j) {
2975                         if (i == j ||
2976                                 (p->BlendingAndTiming[i] == i && p->BlendingAndTiming[j] == i) ||
2977                                 (p->BlendingAndTiming[j] == j && p->BlendingAndTiming[i] == j) ||
2978                                 (p->BlendingAndTiming[i] == p->BlendingAndTiming[j] && p->BlendingAndTiming[i] != i) ||
2979                                 (p->SynchronizeTimingsFinal && p->PixelClock[i] == p->PixelClock[j] && p->HTotal[i] == p->HTotal[j] && p->VTotal[i] == p->VTotal[j] && p->VActive[i] == p->VActive[j]) ||
2980                                 (p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && (p->DRRDisplay[i] || p->DRRDisplay[j]))) {
2981                                 s->SynchronizedSurfaces[i][j] = true;
2982                         } else {
2983                                 s->SynchronizedSurfaces[i][j] = false;
2984                         }
2985                 }
2986         }
2987
2988         s->FCLKChangeSupportNumber = 0;
2989         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
2990                 if ((p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) &&  (s->ActiveFCLKChangeLatencyMargin[k] < 0)) {
2991                         if (!(p->PrefetchMode[k] <= 1)) {
2992                                 s->FCLKChangeSupportNumber = 3;
2993                         } else if (s->FCLKChangeSupportNumber == 0) {
2994                                 s->FCLKChangeSupportNumber = ((p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && p->DRRDisplay[k]) ? 2 : 1);
2995                                 s->LastSurfaceWithoutMargin = k;
2996                         } else if (((s->FCLKChangeSupportNumber == 1) && (p->DRRDisplay[k] || (!s->SynchronizedSurfaces[s->LastSurfaceWithoutMargin][k]))) || (s->FCLKChangeSupportNumber == 2))
2997                                 s->FCLKChangeSupportNumber = 3;
2998                 }
2999         }
3000
3001         if (s->FCLKChangeSupportNumber == 0) {
3002                 *p->FCLKChangeSupport = dml_fclock_change_vactive;
3003         } else if ((s->FCLKChangeSupportNumber == 1) || (s->FCLKChangeSupportNumber == 2)) {
3004                 *p->FCLKChangeSupport = dml_fclock_change_vblank;
3005         } else {
3006                 *p->FCLKChangeSupport = dml_fclock_change_unsupported;
3007         }
3008
3009         s->DRAMClockChangeMethod = 0;
3010         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3011                 if (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame)
3012                         s->DRAMClockChangeMethod = 1;
3013                 else if (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport)
3014                         s->DRAMClockChangeMethod = 2;
3015         }
3016
3017         s->DRAMClockChangeSupportNumber = 0;
3018         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3019                 if (((s->DRAMClockChangeMethod == 0) && (s->ActiveDRAMClockChangeLatencyMargin[k] < 0)) ||
3020                         ((s->DRAMClockChangeMethod == 1) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_full_frame)) ||
3021                         ((s->DRAMClockChangeMethod == 2) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_sub_viewport) && (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe))) {
3022                         if (p->PrefetchMode[k] != 0) { // Don't need to support DRAM clock change, PrefetchMode 0 means needs DRAM clock change support
3023                                 s->DRAMClockChangeSupportNumber = 3;
3024                         } else if (s->DRAMClockChangeSupportNumber == 0) {
3025                                 s->DRAMClockChangeSupportNumber =  (p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal && p->DRRDisplay[k]) ? 2 : 1;
3026                                 s->LastSurfaceWithoutMargin = k;
3027                         } else if (((s->DRAMClockChangeSupportNumber == 1) && (p->DRRDisplay[k] || !s->SynchronizedSurfaces[s->LastSurfaceWithoutMargin][k])) || (s->DRAMClockChangeSupportNumber == 2)) {
3028                                 s->DRAMClockChangeSupportNumber = 3;
3029                         }
3030                 }
3031         }
3032
3033         if (s->DRAMClockChangeMethod == 0) { // No MALL usage
3034                 if (s->DRAMClockChangeSupportNumber == 0) {
3035                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive;
3036                 } else if (s->DRAMClockChangeSupportNumber == 1) {
3037                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank;
3038                 } else if (s->DRAMClockChangeSupportNumber == 2) {
3039                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr;
3040                 } else {
3041                         *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3042                 }
3043         } else if (s->DRAMClockChangeMethod == 1) { // Any pipe using MALL full frame
3044                 if (s->DRAMClockChangeSupportNumber == 0) {
3045                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive_w_mall_full_frame;
3046                 } else if (s->DRAMClockChangeSupportNumber == 1) {
3047                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_w_mall_full_frame;
3048                 } else if (s->DRAMClockChangeSupportNumber == 2) {
3049                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr_w_mall_full_frame;
3050                 } else {
3051                         *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3052                 }
3053         } else { // Any pipe using MALL subviewport
3054                 if (s->DRAMClockChangeSupportNumber == 0) {
3055                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vactive_w_mall_sub_vp;
3056                 } else if (s->DRAMClockChangeSupportNumber == 1) {
3057                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_w_mall_sub_vp;
3058                 } else if (s->DRAMClockChangeSupportNumber == 2) {
3059                         *p->DRAMClockChangeSupport = dml_dram_clock_change_vblank_drr_w_mall_sub_vp;
3060                 } else {
3061                         *p->DRAMClockChangeSupport = dml_dram_clock_change_unsupported;
3062                 }
3063         }
3064
3065         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3066                 s->dst_y_pstate = (dml_uint_t)(dml_ceil((p->mmSOCParameters.DRAMClockChangeLatency + p->mmSOCParameters.UrgentLatency) / (p->HTotal[k] / p->PixelClock[k]), 1));
3067                 s->src_y_pstate_l = (dml_uint_t)(dml_ceil(s->dst_y_pstate * p->VRatio[k], p->SwathHeightY[k]));
3068                 s->src_y_ahead_l = (dml_uint_t)(dml_floor(p->DETBufferSizeY[k] / p->BytePerPixelDETY[k] / p->SwathWidthY[k], p->SwathHeightY[k]) + s->LBLatencyHidingSourceLinesY[k]);
3069                 s->sub_vp_lines_l = s->src_y_pstate_l + s->src_y_ahead_l + p->meta_row_height[k];
3070
3071 #ifdef __DML_VBA_DEBUG__
3072                 dml_print("DML::%s: k=%u, DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
3073                 dml_print("DML::%s: k=%u, BytePerPixelDETY = %f\n", __func__, k, p->BytePerPixelDETY[k]);
3074                 dml_print("DML::%s: k=%u, SwathWidthY = %u\n", __func__, k, p->SwathWidthY[k]);
3075                 dml_print("DML::%s: k=%u, SwathHeightY = %u\n", __func__, k, p->SwathHeightY[k]);
3076                 dml_print("DML::%s: k=%u, LBLatencyHidingSourceLinesY = %u\n", __func__, k, s->LBLatencyHidingSourceLinesY[k]);
3077                 dml_print("DML::%s: k=%u, dst_y_pstate = %u\n", __func__, k, s->dst_y_pstate);
3078                 dml_print("DML::%s: k=%u, src_y_pstate_l = %u\n", __func__, k, s->src_y_pstate_l);
3079                 dml_print("DML::%s: k=%u, src_y_ahead_l = %u\n", __func__, k, s->src_y_ahead_l);
3080                 dml_print("DML::%s: k=%u, meta_row_height = %u\n", __func__, k, p->meta_row_height[k]);
3081                 dml_print("DML::%s: k=%u, sub_vp_lines_l  = %u\n", __func__, k, s->sub_vp_lines_l);
3082 #endif
3083                 p->SubViewportLinesNeededInMALL[k] = s->sub_vp_lines_l;
3084
3085                 if (p->BytePerPixelDETC[k] > 0) {
3086                 s->src_y_pstate_c = (dml_uint_t)(dml_ceil(s->dst_y_pstate * p->VRatioChroma[k], p->SwathHeightC[k]));
3087                 s->src_y_ahead_c = (dml_uint_t)(dml_floor(p->DETBufferSizeC[k] / p->BytePerPixelDETC[k] / p->SwathWidthC[k], p->SwathHeightC[k]) + s->LBLatencyHidingSourceLinesC[k]);
3088                 s->sub_vp_lines_c = s->src_y_pstate_c + s->src_y_ahead_c + p->meta_row_height_chroma[k];
3089                 p->SubViewportLinesNeededInMALL[k] = (dml_uint_t)(dml_max(s->sub_vp_lines_l, s->sub_vp_lines_c));
3090
3091 #ifdef __DML_VBA_DEBUG__
3092                 dml_print("DML::%s: k=%u, src_y_pstate_c = %u\n", __func__, k, s->src_y_pstate_c);
3093                 dml_print("DML::%s: k=%u, src_y_ahead_c = %u\n", __func__, k, s->src_y_ahead_c);
3094                 dml_print("DML::%s: k=%u, meta_row_height_chroma = %u\n", __func__, k, p->meta_row_height_chroma[k]);
3095                 dml_print("DML::%s: k=%u, sub_vp_lines_c            = %u\n", __func__, k, s->sub_vp_lines_c);
3096 #endif
3097                 }
3098         }
3099
3100 #ifdef __DML_VBA_DEBUG__
3101         dml_print("DML::%s: DRAMClockChangeSupport = %u\n", __func__, *p->DRAMClockChangeSupport);
3102         dml_print("DML::%s: FCLKChangeSupport = %u\n", __func__, *p->FCLKChangeSupport);
3103         dml_print("DML::%s: MaxActiveFCLKChangeLatencySupported = %f\n", __func__, *p->MaxActiveFCLKChangeLatencySupported);
3104         dml_print("DML::%s: USRRetrainingSupport                        = %u\n", __func__, *p->USRRetrainingSupport);
3105 #endif
3106 } // CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport
3107
3108 static void CalculateDCFCLKDeepSleep(
3109                 dml_uint_t NumberOfActiveSurfaces,
3110                 dml_uint_t BytePerPixelY[],
3111                 dml_uint_t BytePerPixelC[],
3112                 dml_float_t VRatio[],
3113                 dml_float_t VRatioChroma[],
3114                 dml_uint_t SwathWidthY[],
3115                 dml_uint_t SwathWidthC[],
3116                 dml_uint_t DPPPerSurface[],
3117                 dml_float_t HRatio[],
3118                 dml_float_t HRatioChroma[],
3119                 dml_float_t PixelClock[],
3120                 dml_float_t PSCL_THROUGHPUT[],
3121                 dml_float_t PSCL_THROUGHPUT_CHROMA[],
3122                 dml_float_t Dppclk[],
3123                 dml_float_t ReadBandwidthLuma[],
3124                 dml_float_t ReadBandwidthChroma[],
3125                 dml_uint_t ReturnBusWidth,
3126
3127                 // Output
3128                 dml_float_t *DCFClkDeepSleep)
3129 {
3130         dml_float_t DisplayPipeLineDeliveryTimeLuma;
3131         dml_float_t DisplayPipeLineDeliveryTimeChroma;
3132         dml_float_t DCFClkDeepSleepPerSurface[__DML_NUM_PLANES__];
3133         dml_float_t ReadBandwidth = 0.0;
3134
3135         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3136
3137                 if (VRatio[k] <= 1) {
3138                         DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3139                 } else {
3140                         DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3141                 }
3142                 if (BytePerPixelC[k] == 0) {
3143                         DisplayPipeLineDeliveryTimeChroma = 0;
3144                 } else {
3145                         if (VRatioChroma[k] <= 1) {
3146                                 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3147                         } else {
3148                                 DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3149                         }
3150                 }
3151
3152                 if (BytePerPixelC[k] > 0) {
3153                         DCFClkDeepSleepPerSurface[k] = dml_max(__DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma,
3154                                                                                                                 __DML_MIN_DCFCLK_FACTOR__ * SwathWidthC[k] * BytePerPixelC[k] / 32.0 / DisplayPipeLineDeliveryTimeChroma);
3155                 } else {
3156                         DCFClkDeepSleepPerSurface[k] = __DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] / 64.0 / DisplayPipeLineDeliveryTimeLuma;
3157                 }
3158                 DCFClkDeepSleepPerSurface[k] = dml_max(DCFClkDeepSleepPerSurface[k], PixelClock[k] / 16);
3159
3160 #ifdef __DML_VBA_DEBUG__
3161                 dml_print("DML::%s: k=%u, PixelClock = %f\n", __func__, k, PixelClock[k]);
3162                 dml_print("DML::%s: k=%u, DCFClkDeepSleepPerSurface = %f\n", __func__, k, DCFClkDeepSleepPerSurface[k]);
3163 #endif
3164         }
3165
3166         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3167                 ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
3168         }
3169
3170         *DCFClkDeepSleep = dml_max(8.0, __DML_MIN_DCFCLK_FACTOR__ * ReadBandwidth / (dml_float_t) ReturnBusWidth);
3171
3172 #ifdef __DML_VBA_DEBUG__
3173                 dml_print("DML::%s: __DML_MIN_DCFCLK_FACTOR__ = %f\n", __func__, __DML_MIN_DCFCLK_FACTOR__);
3174                 dml_print("DML::%s: ReadBandwidth = %f\n", __func__, ReadBandwidth);
3175                 dml_print("DML::%s: ReturnBusWidth = %u\n", __func__, ReturnBusWidth);
3176                 dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, *DCFClkDeepSleep);
3177 #endif
3178
3179         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3180                 *DCFClkDeepSleep = dml_max(*DCFClkDeepSleep, DCFClkDeepSleepPerSurface[k]);
3181         }
3182         dml_print("DML::%s: DCFClkDeepSleep = %f (final)\n", __func__, *DCFClkDeepSleep);
3183 } // CalculateDCFCLKDeepSleep
3184
3185 static void CalculateUrgentBurstFactor(
3186                 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange,
3187                 dml_uint_t swath_width_luma_ub,
3188                 dml_uint_t swath_width_chroma_ub,
3189                 dml_uint_t SwathHeightY,
3190                 dml_uint_t SwathHeightC,
3191                 dml_float_t LineTime,
3192                 dml_float_t UrgentLatency,
3193                 dml_float_t CursorBufferSize,
3194                 dml_uint_t CursorWidth,
3195                 dml_uint_t CursorBPP,
3196                 dml_float_t VRatio,
3197                 dml_float_t VRatioC,
3198                 dml_float_t BytePerPixelInDETY,
3199                 dml_float_t BytePerPixelInDETC,
3200                 dml_uint_t DETBufferSizeY,
3201                 dml_uint_t DETBufferSizeC,
3202                 // Output
3203                 dml_float_t *UrgentBurstFactorCursor,
3204                 dml_float_t *UrgentBurstFactorLuma,
3205                 dml_float_t *UrgentBurstFactorChroma,
3206                 dml_bool_t *NotEnoughUrgentLatencyHiding)
3207 {
3208         dml_float_t LinesInDETLuma;
3209         dml_float_t LinesInDETChroma;
3210         dml_uint_t LinesInCursorBuffer;
3211         dml_float_t CursorBufferSizeInTime;
3212         dml_float_t DETBufferSizeInTimeLuma;
3213         dml_float_t DETBufferSizeInTimeChroma;
3214
3215         *NotEnoughUrgentLatencyHiding = 0;
3216
3217         if (CursorWidth > 0) {
3218                 LinesInCursorBuffer = 1 << (dml_uint_t) dml_floor(dml_log2(CursorBufferSize * 1024.0 / (CursorWidth * CursorBPP / 8.0)), 1.0);
3219                 if (VRatio > 0) {
3220                         CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio;
3221                         if (CursorBufferSizeInTime - UrgentLatency <= 0) {
3222                                 *NotEnoughUrgentLatencyHiding = 1;
3223                                 *UrgentBurstFactorCursor = 0;
3224                         } else {
3225                                 *UrgentBurstFactorCursor = CursorBufferSizeInTime / (CursorBufferSizeInTime - UrgentLatency);
3226                         }
3227                 } else {
3228                         *UrgentBurstFactorCursor = 1;
3229                 }
3230         }
3231
3232         LinesInDETLuma = (UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe ? 1024*1024 : DETBufferSizeY) / BytePerPixelInDETY / swath_width_luma_ub;
3233
3234         if (VRatio > 0) {
3235                 DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio;
3236                 if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) {
3237                         *NotEnoughUrgentLatencyHiding = 1;
3238                         *UrgentBurstFactorLuma = 0;
3239                 } else {
3240                         *UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency);
3241                 }
3242         } else {
3243                 *UrgentBurstFactorLuma = 1;
3244         }
3245
3246         if (BytePerPixelInDETC > 0) {
3247                 LinesInDETChroma = (UseMALLForPStateChange == dml_use_mall_pstate_change_phantom_pipe ? 1024*1024 : DETBufferSizeC) / BytePerPixelInDETC / swath_width_chroma_ub;
3248
3249                 if (VRatioC > 0) {
3250                         DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatioC;
3251                         if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) {
3252                                 *NotEnoughUrgentLatencyHiding = 1;
3253                                 *UrgentBurstFactorChroma = 0;
3254                         } else {
3255                                 *UrgentBurstFactorChroma = DETBufferSizeInTimeChroma / (DETBufferSizeInTimeChroma - UrgentLatency);
3256                         }
3257                 } else {
3258                         *UrgentBurstFactorChroma = 1;
3259                 }
3260         }
3261 } // CalculateUrgentBurstFactor
3262
3263 static void CalculatePixelDeliveryTimes(
3264                 dml_uint_t NumberOfActiveSurfaces,
3265                 dml_float_t VRatio[],
3266                 dml_float_t VRatioChroma[],
3267                 dml_float_t VRatioPrefetchY[],
3268                 dml_float_t VRatioPrefetchC[],
3269                 dml_uint_t swath_width_luma_ub[],
3270                 dml_uint_t swath_width_chroma_ub[],
3271                 dml_uint_t DPPPerSurface[],
3272                 dml_float_t HRatio[],
3273                 dml_float_t HRatioChroma[],
3274                 dml_float_t PixelClock[],
3275                 dml_float_t PSCL_THROUGHPUT[],
3276                 dml_float_t PSCL_THROUGHPUT_CHROMA[],
3277                 dml_float_t Dppclk[],
3278                 dml_uint_t BytePerPixelC[],
3279                 enum dml_rotation_angle SourceScan[],
3280                 dml_uint_t NumberOfCursors[],
3281                 dml_uint_t CursorWidth[],
3282                 dml_uint_t CursorBPP[],
3283                 dml_uint_t BlockWidth256BytesY[],
3284                 dml_uint_t BlockHeight256BytesY[],
3285                 dml_uint_t BlockWidth256BytesC[],
3286                 dml_uint_t BlockHeight256BytesC[],
3287
3288                 // Output
3289                 dml_float_t DisplayPipeLineDeliveryTimeLuma[],
3290                 dml_float_t DisplayPipeLineDeliveryTimeChroma[],
3291                 dml_float_t DisplayPipeLineDeliveryTimeLumaPrefetch[],
3292                 dml_float_t DisplayPipeLineDeliveryTimeChromaPrefetch[],
3293                 dml_float_t DisplayPipeRequestDeliveryTimeLuma[],
3294                 dml_float_t DisplayPipeRequestDeliveryTimeChroma[],
3295                 dml_float_t DisplayPipeRequestDeliveryTimeLumaPrefetch[],
3296                 dml_float_t DisplayPipeRequestDeliveryTimeChromaPrefetch[],
3297                 dml_float_t CursorRequestDeliveryTime[],
3298                 dml_float_t CursorRequestDeliveryTimePrefetch[])
3299 {
3300                 dml_float_t req_per_swath_ub;
3301
3302                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3303
3304 #ifdef __DML_VBA_DEBUG__
3305                 dml_print("DML::%s: k=%u : HRatio = %f\n", __func__, k, HRatio[k]);
3306                 dml_print("DML::%s: k=%u : VRatio = %f\n", __func__, k, VRatio[k]);
3307                 dml_print("DML::%s: k=%u : HRatioChroma = %f\n", __func__, k, HRatioChroma[k]);
3308                 dml_print("DML::%s: k=%u : VRatioChroma = %f\n", __func__, k, VRatioChroma[k]);
3309                 dml_print("DML::%s: k=%u : swath_width_luma_ub = %u\n", __func__, k, swath_width_luma_ub[k]);
3310                 dml_print("DML::%s: k=%u : swath_width_chroma_ub = %u\n", __func__, k, swath_width_chroma_ub[k]);
3311                 dml_print("DML::%s: k=%u : PSCL_THROUGHPUT = %f\n", __func__, k, PSCL_THROUGHPUT[k]);
3312                 dml_print("DML::%s: k=%u : PSCL_THROUGHPUT_CHROMA = %f\n", __func__, k, PSCL_THROUGHPUT_CHROMA[k]);
3313                 dml_print("DML::%s: k=%u : DPPPerSurface = %u\n", __func__, k, DPPPerSurface[k]);
3314                 dml_print("DML::%s: k=%u : PixelClock = %f\n", __func__, k, PixelClock[k]);
3315                 dml_print("DML::%s: k=%u : Dppclk = %f\n", __func__, k, Dppclk[k]);
3316 #endif
3317
3318                 if (VRatio[k] <= 1) {
3319                         DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3320                 } else {
3321                         DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3322                 }
3323
3324                 if (BytePerPixelC[k] == 0) {
3325                         DisplayPipeLineDeliveryTimeChroma[k] = 0;
3326                 } else {
3327                         if (VRatioChroma[k] <= 1) {
3328                                 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3329                         } else {
3330                                 DisplayPipeLineDeliveryTimeChroma[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3331                         }
3332                 }
3333
3334                 if (VRatioPrefetchY[k] <= 1) {
3335                         DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
3336                 } else {
3337                         DisplayPipeLineDeliveryTimeLumaPrefetch[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
3338                 }
3339
3340                 if (BytePerPixelC[k] == 0) {
3341                         DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
3342                 } else {
3343                         if (VRatioPrefetchC[k] <= 1) {
3344                                 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
3345                         } else {
3346                                 DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
3347                         }
3348                 }
3349 #ifdef __DML_VBA_DEBUG__
3350                 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeLuma = %f\n", __func__, k, DisplayPipeLineDeliveryTimeLuma[k]);
3351                 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeLumaPrefetch = %f\n", __func__, k, DisplayPipeLineDeliveryTimeLumaPrefetch[k]);
3352                 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeChroma = %f\n", __func__, k, DisplayPipeLineDeliveryTimeChroma[k]);
3353                 dml_print("DML::%s: k=%u : DisplayPipeLineDeliveryTimeChromaPrefetch = %f\n", __func__, k, DisplayPipeLineDeliveryTimeChromaPrefetch[k]);
3354 #endif
3355         }
3356
3357         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3358                 if (!dml_is_vertical_rotation(SourceScan[k])) {
3359                         req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k];
3360                 } else {
3361                         req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k];
3362                 }
3363 #ifdef __DML_VBA_DEBUG__
3364                 dml_print("DML::%s: k=%u : req_per_swath_ub = %f (Luma)\n", __func__, k, req_per_swath_ub);
3365 #endif
3366
3367                 DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub;
3368                 DisplayPipeRequestDeliveryTimeLumaPrefetch[k] = DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub;
3369                 if (BytePerPixelC[k] == 0) {
3370                         DisplayPipeRequestDeliveryTimeChroma[k] = 0;
3371                         DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0;
3372                 } else {
3373                         if (!dml_is_vertical_rotation(SourceScan[k])) {
3374                                 req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k];
3375                         } else {
3376                                 req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k];
3377                         }
3378 #ifdef __DML_VBA_DEBUG__
3379                         dml_print("DML::%s: k=%u : req_per_swath_ub = %f (Chroma)\n", __func__, k, req_per_swath_ub);
3380 #endif
3381                         DisplayPipeRequestDeliveryTimeChroma[k] = DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub;
3382                         DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub;
3383                 }
3384 #ifdef __DML_VBA_DEBUG__
3385                 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeLuma = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeLuma[k]);
3386                 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeLumaPrefetch = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeLumaPrefetch[k]);
3387                 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeChroma = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeChroma[k]);
3388                 dml_print("DML::%s: k=%u : DisplayPipeRequestDeliveryTimeChromaPrefetch = %f\n", __func__, k, DisplayPipeRequestDeliveryTimeChromaPrefetch[k]);
3389 #endif
3390         }
3391
3392         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3393                 dml_uint_t cursor_req_per_width;
3394                 cursor_req_per_width = (dml_uint_t)(dml_ceil((dml_float_t) CursorWidth[k] * (dml_float_t) CursorBPP[k] / 256.0 / 8.0, 1.0));
3395                 if (NumberOfCursors[k] > 0) {
3396                         if (VRatio[k] <= 1) {
3397                                 CursorRequestDeliveryTime[k] = (dml_float_t) CursorWidth[k] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
3398                         } else {
3399                                 CursorRequestDeliveryTime[k] = (dml_float_t) CursorWidth[k] / PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
3400                         }
3401                         if (VRatioPrefetchY[k] <= 1) {
3402                                 CursorRequestDeliveryTimePrefetch[k] = (dml_float_t) CursorWidth[k] / HRatio[k] / PixelClock[k] / cursor_req_per_width;
3403                 } else {
3404                         CursorRequestDeliveryTimePrefetch[k] = (dml_float_t) CursorWidth[k] / PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
3405                         }
3406                 } else {
3407                         CursorRequestDeliveryTime[k] = 0;
3408                         CursorRequestDeliveryTimePrefetch[k] = 0;
3409                 }
3410 #ifdef __DML_VBA_DEBUG__
3411                 dml_print("DML::%s: k=%u : NumberOfCursors = %u\n", __func__, k, NumberOfCursors[k]);
3412                 dml_print("DML::%s: k=%u : CursorRequestDeliveryTime = %f\n", __func__, k, CursorRequestDeliveryTime[k]);
3413                 dml_print("DML::%s: k=%u : CursorRequestDeliveryTimePrefetch = %f\n", __func__, k, CursorRequestDeliveryTimePrefetch[k]);
3414 #endif
3415         }
3416 } // CalculatePixelDeliveryTimes
3417
3418 static void CalculateMetaAndPTETimes(
3419                 dml_bool_t use_one_row_for_frame[],
3420                 dml_uint_t NumberOfActiveSurfaces,
3421                 dml_bool_t GPUVMEnable,
3422                 dml_uint_t MetaChunkSize,
3423                 dml_uint_t MinMetaChunkSizeBytes,
3424                 dml_uint_t HTotal[],
3425                 dml_float_t VRatio[],
3426                 dml_float_t VRatioChroma[],
3427                 dml_float_t DestinationLinesToRequestRowInVBlank[],
3428                 dml_float_t DestinationLinesToRequestRowInImmediateFlip[],
3429                 dml_bool_t DCCEnable[],
3430                 dml_float_t PixelClock[],
3431                 dml_uint_t BytePerPixelY[],
3432                 dml_uint_t BytePerPixelC[],
3433                 enum dml_rotation_angle SourceScan[],
3434                 dml_uint_t dpte_row_height[],
3435                 dml_uint_t dpte_row_height_chroma[],
3436                 dml_uint_t meta_row_width[],
3437                 dml_uint_t meta_row_width_chroma[],
3438                 dml_uint_t meta_row_height[],
3439                 dml_uint_t meta_row_height_chroma[],
3440                 dml_uint_t meta_req_width[],
3441                 dml_uint_t meta_req_width_chroma[],
3442                 dml_uint_t meta_req_height[],
3443                 dml_uint_t meta_req_height_chroma[],
3444                 dml_uint_t dpte_group_bytes[],
3445                 dml_uint_t PTERequestSizeY[],
3446                 dml_uint_t PTERequestSizeC[],
3447                 dml_uint_t PixelPTEReqWidthY[],
3448                 dml_uint_t PixelPTEReqHeightY[],
3449                 dml_uint_t PixelPTEReqWidthC[],
3450                 dml_uint_t PixelPTEReqHeightC[],
3451                 dml_uint_t dpte_row_width_luma_ub[],
3452                 dml_uint_t dpte_row_width_chroma_ub[],
3453
3454                 // Output
3455                 dml_float_t DST_Y_PER_PTE_ROW_NOM_L[],
3456                 dml_float_t DST_Y_PER_PTE_ROW_NOM_C[],
3457                 dml_float_t DST_Y_PER_META_ROW_NOM_L[],
3458                 dml_float_t DST_Y_PER_META_ROW_NOM_C[],
3459                 dml_float_t TimePerMetaChunkNominal[],
3460                 dml_float_t TimePerChromaMetaChunkNominal[],
3461                 dml_float_t TimePerMetaChunkVBlank[],
3462                 dml_float_t TimePerChromaMetaChunkVBlank[],
3463                 dml_float_t TimePerMetaChunkFlip[],
3464                 dml_float_t TimePerChromaMetaChunkFlip[],
3465                 dml_float_t time_per_pte_group_nom_luma[],
3466                 dml_float_t time_per_pte_group_vblank_luma[],
3467                 dml_float_t time_per_pte_group_flip_luma[],
3468                 dml_float_t time_per_pte_group_nom_chroma[],
3469                 dml_float_t time_per_pte_group_vblank_chroma[],
3470                 dml_float_t time_per_pte_group_flip_chroma[])
3471 {
3472         dml_uint_t meta_chunk_width;
3473         dml_uint_t min_meta_chunk_width;
3474         dml_uint_t meta_chunk_per_row_int;
3475         dml_uint_t meta_row_remainder;
3476         dml_uint_t meta_chunk_threshold;
3477         dml_uint_t meta_chunks_per_row_ub;
3478         dml_uint_t meta_chunk_width_chroma;
3479         dml_uint_t min_meta_chunk_width_chroma;
3480         dml_uint_t meta_chunk_per_row_int_chroma;
3481         dml_uint_t meta_row_remainder_chroma;
3482         dml_uint_t meta_chunk_threshold_chroma;
3483         dml_uint_t meta_chunks_per_row_ub_chroma;
3484         dml_uint_t dpte_group_width_luma;
3485         dml_uint_t dpte_groups_per_row_luma_ub;
3486         dml_uint_t dpte_group_width_chroma;
3487         dml_uint_t dpte_groups_per_row_chroma_ub;
3488
3489         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3490                 DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k];
3491                 if (BytePerPixelC[k] == 0) {
3492                         DST_Y_PER_PTE_ROW_NOM_C[k] = 0;
3493                 } else {
3494                         DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k];
3495                 }
3496                 DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k];
3497                 if (BytePerPixelC[k] == 0) {
3498                         DST_Y_PER_META_ROW_NOM_C[k] = 0;
3499                 } else {
3500                         DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k];
3501                 }
3502         }
3503
3504         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3505                 if (DCCEnable[k] == true) {
3506                         meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k];
3507                         min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k];
3508                         meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width;
3509                         meta_row_remainder = meta_row_width[k] % meta_chunk_width;
3510                         if (!dml_is_vertical_rotation(SourceScan[k])) {
3511                                 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k];
3512                         } else {
3513                                 meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k];
3514                         }
3515                         if (meta_row_remainder <= meta_chunk_threshold) {
3516                                 meta_chunks_per_row_ub = meta_chunk_per_row_int + 1;
3517                         } else {
3518                                 meta_chunks_per_row_ub = meta_chunk_per_row_int + 2;
3519                         }
3520                         TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3521                         TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3522                         TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
3523                         if (BytePerPixelC[k] == 0) {
3524                                 TimePerChromaMetaChunkNominal[k] = 0;
3525                                 TimePerChromaMetaChunkVBlank[k] = 0;
3526                                 TimePerChromaMetaChunkFlip[k] = 0;
3527                         } else {
3528                                 meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
3529                                 min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] / meta_row_height_chroma[k];
3530                                 meta_chunk_per_row_int_chroma = (dml_uint_t)((dml_float_t) meta_row_width_chroma[k] / meta_chunk_width_chroma);
3531                                 meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma;
3532                                 if (!dml_is_vertical_rotation(SourceScan[k])) {
3533                                         meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_width_chroma[k];
3534                                 } else {
3535                                         meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - meta_req_height_chroma[k];
3536                                 }
3537                                 if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma) {
3538                                         meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1;
3539                                 } else {
3540                                         meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2;
3541                                 }
3542                                 TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3543                                 TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3544                                 TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
3545                         }
3546                 } else {
3547                         TimePerMetaChunkNominal[k] = 0;
3548                         TimePerMetaChunkVBlank[k] = 0;
3549                         TimePerMetaChunkFlip[k] = 0;
3550                         TimePerChromaMetaChunkNominal[k] = 0;
3551                         TimePerChromaMetaChunkVBlank[k] = 0;
3552                         TimePerChromaMetaChunkFlip[k] = 0;
3553                 }
3554         }
3555
3556         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3557                 if (GPUVMEnable == true) {
3558                         if (!dml_is_vertical_rotation(SourceScan[k])) {
3559                                 dpte_group_width_luma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeY[k] * PixelPTEReqWidthY[k]);
3560                         } else {
3561                                 dpte_group_width_luma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeY[k] * PixelPTEReqHeightY[k]);
3562                         }
3563
3564                         if (use_one_row_for_frame[k]) {
3565                                 dpte_groups_per_row_luma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_luma_ub[k] / (dml_float_t) dpte_group_width_luma / 2.0, 1.0));
3566                         } else {
3567                                 dpte_groups_per_row_luma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_luma_ub[k] / (dml_float_t) dpte_group_width_luma, 1.0));
3568                         }
3569
3570                         dml_print("DML::%s: k=%u, use_one_row_for_frame = %u\n", __func__, k, use_one_row_for_frame[k]);
3571                         dml_print("DML::%s: k=%u, dpte_group_bytes = %u\n", __func__, k, dpte_group_bytes[k]);
3572                         dml_print("DML::%s: k=%u, PTERequestSizeY = %u\n", __func__, k, PTERequestSizeY[k]);
3573                         dml_print("DML::%s: k=%u, PixelPTEReqWidthY = %u\n", __func__, k, PixelPTEReqWidthY[k]);
3574                         dml_print("DML::%s: k=%u, PixelPTEReqHeightY = %u\n", __func__, k, PixelPTEReqHeightY[k]);
3575                         dml_print("DML::%s: k=%u, dpte_row_width_luma_ub = %u\n", __func__, k, dpte_row_width_luma_ub[k]);
3576                         dml_print("DML::%s: k=%u, dpte_group_width_luma = %u\n", __func__, k, dpte_group_width_luma);
3577                         dml_print("DML::%s: k=%u, dpte_groups_per_row_luma_ub = %u\n", __func__, k, dpte_groups_per_row_luma_ub);
3578
3579                         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;
3580                         time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
3581                         time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
3582                         if (BytePerPixelC[k] == 0) {
3583                                 time_per_pte_group_nom_chroma[k] = 0;
3584                                 time_per_pte_group_vblank_chroma[k] = 0;
3585                                 time_per_pte_group_flip_chroma[k] = 0;
3586                         } else {
3587                                 if (!dml_is_vertical_rotation(SourceScan[k])) {
3588                                         dpte_group_width_chroma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeC[k] * PixelPTEReqWidthC[k]);
3589                                 } else {
3590                                         dpte_group_width_chroma = (dml_uint_t)((dml_float_t) dpte_group_bytes[k] / (dml_float_t) PTERequestSizeC[k] * PixelPTEReqHeightC[k]);
3591                                 }
3592
3593                                 if (use_one_row_for_frame[k]) {
3594                                         dpte_groups_per_row_chroma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_chroma_ub[k] / (dml_float_t) dpte_group_width_chroma / 2.0, 1.0));
3595                                 } else {
3596                                         dpte_groups_per_row_chroma_ub = (dml_uint_t)(dml_ceil((dml_float_t) dpte_row_width_chroma_ub[k] / (dml_float_t) dpte_group_width_chroma, 1.0));
3597                                 }
3598                                 dml_print("DML::%s: k=%u, dpte_row_width_chroma_ub = %u\n", __func__, k, dpte_row_width_chroma_ub[k]);
3599                                 dml_print("DML::%s: k=%u, dpte_group_width_chroma = %u\n", __func__, k, dpte_group_width_chroma);
3600                                 dml_print("DML::%s: k=%u, dpte_groups_per_row_chroma_ub = %u\n", __func__, k, dpte_groups_per_row_chroma_ub);
3601
3602                                 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;
3603                                 time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
3604                                 time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
3605                         }
3606                 } else {
3607                         time_per_pte_group_nom_luma[k] = 0;
3608                         time_per_pte_group_vblank_luma[k] = 0;
3609                         time_per_pte_group_flip_luma[k] = 0;
3610                         time_per_pte_group_nom_chroma[k] = 0;
3611                         time_per_pte_group_vblank_chroma[k] = 0;
3612                         time_per_pte_group_flip_chroma[k] = 0;
3613                 }
3614 #ifdef __DML_VBA_DEBUG__
3615                 dml_print("DML::%s: k=%u, DestinationLinesToRequestRowInVBlank = %f\n", __func__, k, DestinationLinesToRequestRowInVBlank[k]);
3616                 dml_print("DML::%s: k=%u, DestinationLinesToRequestRowInImmediateFlip = %f\n", __func__, k, DestinationLinesToRequestRowInImmediateFlip[k]);
3617
3618                 dml_print("DML::%s: k=%u, DST_Y_PER_PTE_ROW_NOM_L = %f\n", __func__, k, DST_Y_PER_PTE_ROW_NOM_L[k]);
3619                 dml_print("DML::%s: k=%u, DST_Y_PER_PTE_ROW_NOM_C = %f\n", __func__, k, DST_Y_PER_PTE_ROW_NOM_C[k]);
3620                 dml_print("DML::%s: k=%u, DST_Y_PER_META_ROW_NOM_L = %f\n", __func__, k, DST_Y_PER_META_ROW_NOM_L[k]);
3621                 dml_print("DML::%s: k=%u, DST_Y_PER_META_ROW_NOM_C = %f\n", __func__, k, DST_Y_PER_META_ROW_NOM_C[k]);
3622                 dml_print("DML::%s: k=%u, TimePerMetaChunkNominal = %f\n", __func__, k, TimePerMetaChunkNominal[k]);
3623                 dml_print("DML::%s: k=%u, TimePerMetaChunkVBlank = %f\n", __func__, k, TimePerMetaChunkVBlank[k]);
3624                 dml_print("DML::%s: k=%u, TimePerMetaChunkFlip = %f\n", __func__, k, TimePerMetaChunkFlip[k]);
3625                 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkNominal = %f\n", __func__, k, TimePerChromaMetaChunkNominal[k]);
3626                 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkVBlank = %f\n", __func__, k, TimePerChromaMetaChunkVBlank[k]);
3627                 dml_print("DML::%s: k=%u, TimePerChromaMetaChunkFlip = %f\n", __func__, k, TimePerChromaMetaChunkFlip[k]);
3628                 dml_print("DML::%s: k=%u, time_per_pte_group_nom_luma = %f\n", __func__, k, time_per_pte_group_nom_luma[k]);
3629                 dml_print("DML::%s: k=%u, time_per_pte_group_vblank_luma = %f\n", __func__, k, time_per_pte_group_vblank_luma[k]);
3630                 dml_print("DML::%s: k=%u, time_per_pte_group_flip_luma = %f\n", __func__, k, time_per_pte_group_flip_luma[k]);
3631                 dml_print("DML::%s: k=%u, time_per_pte_group_nom_chroma = %f\n", __func__, k, time_per_pte_group_nom_chroma[k]);
3632                 dml_print("DML::%s: k=%u, time_per_pte_group_vblank_chroma = %f\n", __func__, k, time_per_pte_group_vblank_chroma[k]);
3633                 dml_print("DML::%s: k=%u, time_per_pte_group_flip_chroma   = %f\n", __func__, k, time_per_pte_group_flip_chroma[k]);
3634 #endif
3635         }
3636 } // CalculateMetaAndPTETimes
3637
3638 static void CalculateVMGroupAndRequestTimes(
3639                 dml_uint_t NumberOfActiveSurfaces,
3640                 dml_bool_t GPUVMEnable,
3641                 dml_uint_t GPUVMMaxPageTableLevels,
3642                 dml_uint_t HTotal[],
3643                 dml_uint_t BytePerPixelC[],
3644                 dml_float_t DestinationLinesToRequestVMInVBlank[],
3645                 dml_float_t DestinationLinesToRequestVMInImmediateFlip[],
3646                 dml_bool_t DCCEnable[],
3647                 dml_float_t PixelClock[],
3648                 dml_uint_t dpte_row_width_luma_ub[],
3649                 dml_uint_t dpte_row_width_chroma_ub[],
3650                 dml_uint_t vm_group_bytes[],
3651                 dml_uint_t dpde0_bytes_per_frame_ub_l[],
3652                 dml_uint_t dpde0_bytes_per_frame_ub_c[],
3653                 dml_uint_t meta_pte_bytes_per_frame_ub_l[],
3654                 dml_uint_t meta_pte_bytes_per_frame_ub_c[],
3655
3656                 // Output
3657                 dml_float_t TimePerVMGroupVBlank[],
3658                 dml_float_t TimePerVMGroupFlip[],
3659                 dml_float_t TimePerVMRequestVBlank[],
3660                 dml_float_t TimePerVMRequestFlip[])
3661 {
3662         dml_uint_t num_group_per_lower_vm_stage;
3663         dml_uint_t num_req_per_lower_vm_stage;
3664
3665 #ifdef __DML_VBA_DEBUG__
3666         dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
3667         dml_print("DML::%s: GPUVMEnable = %u\n", __func__, GPUVMEnable);
3668 #endif
3669         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
3670
3671 #ifdef __DML_VBA_DEBUG__
3672                 dml_print("DML::%s: k=%u, DCCEnable = %u\n", __func__, k, DCCEnable[k]);
3673                 dml_print("DML::%s: k=%u, vm_group_bytes = %u\n", __func__, k, vm_group_bytes[k]);
3674                 dml_print("DML::%s: k=%u, dpde0_bytes_per_frame_ub_l = %u\n", __func__, k, dpde0_bytes_per_frame_ub_l[k]);
3675                 dml_print("DML::%s: k=%u, dpde0_bytes_per_frame_ub_c = %u\n", __func__, k, dpde0_bytes_per_frame_ub_c[k]);
3676                 dml_print("DML::%s: k=%u, meta_pte_bytes_per_frame_ub_l = %u\n", __func__, k, meta_pte_bytes_per_frame_ub_l[k]);
3677                 dml_print("DML::%s: k=%u, meta_pte_bytes_per_frame_ub_c = %u\n", __func__, k, meta_pte_bytes_per_frame_ub_c[k]);
3678 #endif
3679
3680                 if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) {
3681                         if (DCCEnable[k] == false) {
3682                                 if (BytePerPixelC[k] > 0) {
3683                                         num_group_per_lower_vm_stage = (dml_uint_t) (dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_l[k] / (dml_float_t) vm_group_bytes[k], 1.0) +
3684                                                                                                         dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_c[k] / (dml_float_t) vm_group_bytes[k], 1.0));
3685                                 } else {
3686                                         num_group_per_lower_vm_stage = (dml_uint_t) (dml_ceil((dml_float_t) dpde0_bytes_per_frame_ub_l[k] / (dml_float_t) vm_group_bytes[k], 1.0));
3687                                 }
3688                         } else {
3689                                 if (GPUVMMaxPageTableLevels == 1) {
3690                                         if (BytePerPixelC[k] > 0) {
3691                                                 num_group_per_lower_vm_stage = (dml_uint_t)(dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0) +
3692                                                                                                                                         dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0));
3693                                         } else {
3694                                                 num_group_per_lower_vm_stage = (dml_uint_t)(dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1.0));
3695                                         }
3696                                 } else {
3697                                         if (BytePerPixelC[k] > 0) {
3698                                                 num_group_per_lower_vm_stage = (dml_uint_t)(2.0 + dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3699                                                                                                                 dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3700                                                                                                                 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3701                                                                                                                 dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_c[k]) / (dml_float_t) (vm_group_bytes[k]), 1));
3702                                         } else {
3703                                                 num_group_per_lower_vm_stage = (dml_uint_t)(1.0 + dml_ceil((dml_float_t) (dpde0_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1) +
3704                                                                                                                                         dml_ceil((dml_float_t) (meta_pte_bytes_per_frame_ub_l[k]) / (dml_float_t) (vm_group_bytes[k]), 1));
3705                                         }
3706                                 }
3707                         }
3708
3709                         if (DCCEnable[k] == false) {
3710                                 if (BytePerPixelC[k] > 0) {
3711                                         num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64;
3712                                 } else {
3713                                         num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64;
3714                                 }
3715                         } else {
3716                                 if (GPUVMMaxPageTableLevels == 1) {
3717                                         if (BytePerPixelC[k] > 0) {
3718                                                 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
3719                                         } else {
3720                                                 num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64;
3721                                         }
3722                                 } else {
3723                                         if (BytePerPixelC[k] > 0) {
3724                                                 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + dpde0_bytes_per_frame_ub_c[k] / 64 + meta_pte_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_c[k] / 64;
3725                                         } else {
3726                                                 num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + meta_pte_bytes_per_frame_ub_l[k] / 64;
3727                                         }
3728                                 }
3729                         }
3730
3731                         TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
3732                         TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
3733                         TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
3734                         TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
3735
3736                         if (GPUVMMaxPageTableLevels > 2) {
3737                                 TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2;
3738                                 TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2;
3739                                 TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2;
3740                                 TimePerVMRequestFlip[k]    = TimePerVMRequestFlip[k] / 2;
3741                         }
3742
3743                 } else {
3744                         TimePerVMGroupVBlank[k] = 0;
3745                         TimePerVMGroupFlip[k] = 0;
3746                         TimePerVMRequestVBlank[k] = 0;
3747                         TimePerVMRequestFlip[k] = 0;
3748                 }
3749
3750 #ifdef __DML_VBA_DEBUG__
3751                         dml_print("DML::%s: k=%u, TimePerVMGroupVBlank = %f\n", __func__, k, TimePerVMGroupVBlank[k]);
3752                         dml_print("DML::%s: k=%u, TimePerVMGroupFlip = %f\n", __func__, k, TimePerVMGroupFlip[k]);
3753                         dml_print("DML::%s: k=%u, TimePerVMRequestVBlank = %f\n", __func__, k, TimePerVMRequestVBlank[k]);
3754                         dml_print("DML::%s: k=%u, TimePerVMRequestFlip = %f\n", __func__, k, TimePerVMRequestFlip[k]);
3755 #endif
3756         }
3757 } // CalculateVMGroupAndRequestTimes
3758
3759 static void CalculateStutterEfficiency(struct display_mode_lib_scratch_st *scratch,
3760                 struct CalculateStutterEfficiency_params_st *p)
3761 {
3762         dml_float_t DETBufferingTimeY = 0;
3763         dml_float_t SwathWidthYCriticalSurface = 0;
3764         dml_float_t SwathHeightYCriticalSurface = 0;
3765         dml_float_t VActiveTimeCriticalSurface = 0;
3766         dml_float_t FrameTimeCriticalSurface = 0;
3767         dml_uint_t BytePerPixelYCriticalSurface = 0;
3768         dml_float_t LinesToFinishSwathTransferStutterCriticalSurface = 0;
3769         dml_uint_t DETBufferSizeYCriticalSurface = 0;
3770         dml_float_t MinTTUVBlankCriticalSurface = 0;
3771         dml_uint_t BlockWidth256BytesYCriticalSurface = 0;
3772         dml_bool_t SinglePlaneCriticalSurface = 0;
3773         dml_bool_t SinglePipeCriticalSurface = 0;
3774         dml_float_t TotalCompressedReadBandwidth = 0;
3775         dml_float_t TotalRowReadBandwidth = 0;
3776         dml_float_t AverageDCCCompressionRate = 0;
3777         dml_float_t EffectiveCompressedBufferSize = 0;
3778         dml_float_t PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = 0;
3779         dml_float_t StutterBurstTime = 0;
3780         dml_uint_t TotalActiveWriteback = 0;
3781         dml_float_t LinesInDETY = 0;
3782         dml_float_t LinesInDETYRoundedDownToSwath = 0;
3783         dml_float_t MaximumEffectiveCompressionLuma = 0;
3784         dml_float_t MaximumEffectiveCompressionChroma = 0;
3785         dml_float_t TotalZeroSizeRequestReadBandwidth = 0;
3786         dml_float_t TotalZeroSizeCompressedReadBandwidth = 0;
3787         dml_float_t AverageDCCZeroSizeFraction = 0;
3788         dml_float_t AverageZeroSizeCompressionRate = 0;
3789
3790         dml_bool_t FoundCriticalSurface = false;
3791
3792         dml_uint_t TotalNumberOfActiveOTG = 0;
3793         dml_float_t SinglePixelClock;
3794         dml_uint_t SingleHTotal;
3795         dml_uint_t SingleVTotal;
3796         dml_bool_t SameTiming = true;
3797
3798         dml_float_t LastStutterPeriod = 0.0;
3799         dml_float_t LastZ8StutterPeriod = 0.0;
3800
3801         dml_uint_t SwathSizeCriticalSurface;
3802         dml_uint_t LastChunkOfSwathSize;
3803         dml_uint_t MissingPartOfLastSwathOfDETSize;
3804
3805         TotalZeroSizeRequestReadBandwidth = 0;
3806         TotalZeroSizeCompressedReadBandwidth = 0;
3807         TotalRowReadBandwidth = 0;
3808         TotalCompressedReadBandwidth = 0;
3809
3810         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3811         if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
3812                 if (p->DCCEnable[k] == true) {
3813                         if ((dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockWidth256BytesY[k] > p->SwathHeightY[k]) || (!dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockHeight256BytesY[k] > p->SwathHeightY[k]) || p->DCCYMaxUncompressedBlock[k] < 256) {
3814                                 MaximumEffectiveCompressionLuma = 2;
3815                         } else {
3816                                 MaximumEffectiveCompressionLuma = 4;
3817                         }
3818                         TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] / dml_min(p->NetDCCRateLuma[k], MaximumEffectiveCompressionLuma);
3819 #ifdef __DML_VBA_DEBUG__
3820                         dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, p->ReadBandwidthSurfaceLuma[k]);
3821                         dml_print("DML::%s: k=%u, NetDCCRateLuma = %f\n", __func__, k, p->NetDCCRateLuma[k]);
3822                         dml_print("DML::%s: k=%u, MaximumEffectiveCompressionLuma = %f\n", __func__, k, MaximumEffectiveCompressionLuma);
3823 #endif
3824                         TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth + p->ReadBandwidthSurfaceLuma[k] * p->DCCFractionOfZeroSizeRequestsLuma[k];
3825                         TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] * p->DCCFractionOfZeroSizeRequestsLuma[k] / MaximumEffectiveCompressionLuma;
3826
3827                         if (p->ReadBandwidthSurfaceChroma[k] > 0) {
3828                                 if ((dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockWidth256BytesC[k] > p->SwathHeightC[k]) || (!dml_is_vertical_rotation(p->SourceScan[k]) && p->BlockHeight256BytesC[k] > p->SwathHeightC[k]) || p->DCCCMaxUncompressedBlock[k] < 256) {
3829                                         MaximumEffectiveCompressionChroma = 2;
3830                                 } else {
3831                                         MaximumEffectiveCompressionChroma = 4;
3832                                 }
3833                                 TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceChroma[k] / dml_min(p->NetDCCRateChroma[k], MaximumEffectiveCompressionChroma);
3834 #ifdef __DML_VBA_DEBUG__
3835                                 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceChroma = %f\n", __func__, k, p->ReadBandwidthSurfaceChroma[k]);
3836                                 dml_print("DML::%s: k=%u, NetDCCRateChroma = %f\n", __func__, k, p->NetDCCRateChroma[k]);
3837                                 dml_print("DML::%s: k=%u, MaximumEffectiveCompressionChroma = %f\n", __func__, k, MaximumEffectiveCompressionChroma);
3838 #endif
3839                                 TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth + p->ReadBandwidthSurfaceChroma[k] * p->DCCFractionOfZeroSizeRequestsChroma[k];
3840                                 TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth + p->ReadBandwidthSurfaceChroma[k] * p->DCCFractionOfZeroSizeRequestsChroma[k] / MaximumEffectiveCompressionChroma;
3841                         }
3842                 } else {
3843                         TotalCompressedReadBandwidth = TotalCompressedReadBandwidth + p->ReadBandwidthSurfaceLuma[k] + p->ReadBandwidthSurfaceChroma[k];
3844                 }
3845                 TotalRowReadBandwidth = TotalRowReadBandwidth + p->DPPPerSurface[k] * (p->meta_row_bw[k] + p->dpte_row_bw[k]);
3846         }
3847         }
3848
3849         AverageDCCCompressionRate = p->TotalDataReadBandwidth / TotalCompressedReadBandwidth;
3850         AverageDCCZeroSizeFraction = TotalZeroSizeRequestReadBandwidth / p->TotalDataReadBandwidth;
3851
3852 #ifdef __DML_VBA_DEBUG__
3853         dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, p->UnboundedRequestEnabled);
3854         dml_print("DML::%s: TotalCompressedReadBandwidth = %f\n", __func__, TotalCompressedReadBandwidth);
3855         dml_print("DML::%s: TotalZeroSizeRequestReadBandwidth = %f\n", __func__, TotalZeroSizeRequestReadBandwidth);
3856         dml_print("DML::%s: TotalZeroSizeCompressedReadBandwidth = %f\n", __func__, TotalZeroSizeCompressedReadBandwidth);
3857         dml_print("DML::%s: MaximumEffectiveCompressionLuma = %f\n", __func__, MaximumEffectiveCompressionLuma);
3858         dml_print("DML::%s: MaximumEffectiveCompressionChroma = %f\n", __func__, MaximumEffectiveCompressionChroma);
3859         dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
3860         dml_print("DML::%s: AverageDCCZeroSizeFraction = %f\n", __func__, AverageDCCZeroSizeFraction);
3861         dml_print("DML::%s: CompbufReservedSpace64B = %u\n", __func__, p->CompbufReservedSpace64B);
3862         dml_print("DML::%s: CompbufReservedSpaceZs = %u\n", __func__, p->CompbufReservedSpaceZs);
3863         dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, p->CompressedBufferSizeInkByte);
3864 #endif
3865         if (AverageDCCZeroSizeFraction == 1) {
3866                 AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth / TotalZeroSizeCompressedReadBandwidth;
3867                 EffectiveCompressedBufferSize = (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageZeroSizeCompressionRate + ((dml_float_t)p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 * AverageZeroSizeCompressionRate;
3868         }       else if (AverageDCCZeroSizeFraction > 0) {
3869                 AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth / TotalZeroSizeCompressedReadBandwidth;
3870                 EffectiveCompressedBufferSize = dml_min((dml_float_t)p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
3871                                                                                         (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 / AverageDCCCompressionRate)) +
3872                                                                                 dml_min(((dml_float_t)p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate,
3873                                                                                         ((dml_float_t)p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
3874
3875 #ifdef __DML_VBA_DEBUG__
3876                 dml_print("DML::%s: min 1 = %f\n", __func__, p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
3877                 dml_print("DML::%s: min 2 = %f\n", __func__, p->MetaFIFOSizeInKEntries * 1024 * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 / AverageDCCCompressionRate));
3878                 dml_print("DML::%s: min 3 = %f\n", __func__, (p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate);
3879                 dml_print("DML::%s: min 4 = %f\n", __func__, (p->ZeroSizeBufferEntries - p->CompbufReservedSpaceZs) * 64 / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
3880 #endif
3881         } else {
3882                 EffectiveCompressedBufferSize = dml_min((dml_float_t)p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
3883                                                                                                 (dml_float_t)p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate) +
3884                                                                                                 ((dml_float_t)p->ROBBufferSizeInKByte * 1024 - p->CompbufReservedSpace64B * 64) * AverageDCCCompressionRate;
3885
3886 #ifdef __DML_VBA_DEBUG__
3887                 dml_print("DML::%s: min 1 = %f\n", __func__, p->CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
3888                 dml_print("DML::%s: min 2 = %f\n", __func__, p->MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate);
3889 #endif
3890         }
3891
3892 #ifdef __DML_VBA_DEBUG__
3893         dml_print("DML::%s: MetaFIFOSizeInKEntries = %u\n", __func__, p->MetaFIFOSizeInKEntries);
3894         dml_print("DML::%s: AverageZeroSizeCompressionRate = %f\n", __func__, AverageZeroSizeCompressionRate);
3895         dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
3896 #endif
3897
3898         *p->StutterPeriod = 0;
3899
3900         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3901         if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
3902                 LinesInDETY = ((dml_float_t)p->DETBufferSizeY[k] + (p->UnboundedRequestEnabled == true ? EffectiveCompressedBufferSize : 0) * p->ReadBandwidthSurfaceLuma[k] / p->TotalDataReadBandwidth) / p->BytePerPixelDETY[k] / p->SwathWidthY[k];
3903                 LinesInDETYRoundedDownToSwath = dml_floor(LinesInDETY, p->SwathHeightY[k]);
3904                 DETBufferingTimeY = LinesInDETYRoundedDownToSwath * ((dml_float_t)p->HTotal[k] / p->PixelClock[k]) / p->VRatio[k];
3905 #ifdef __DML_VBA_DEBUG__
3906                 dml_print("DML::%s: k=%u, DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
3907                 dml_print("DML::%s: k=%u, BytePerPixelDETY = %f\n", __func__, k, p->BytePerPixelDETY[k]);
3908                 dml_print("DML::%s: k=%u, SwathWidthY = %u\n", __func__, k, p->SwathWidthY[k]);
3909                 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, p->ReadBandwidthSurfaceLuma[k]);
3910                 dml_print("DML::%s: k=%u, TotalDataReadBandwidth = %f\n", __func__, k, p->TotalDataReadBandwidth);
3911                 dml_print("DML::%s: k=%u, LinesInDETY = %f\n", __func__, k, LinesInDETY);
3912                 dml_print("DML::%s: k=%u, LinesInDETYRoundedDownToSwath = %f\n", __func__, k, LinesInDETYRoundedDownToSwath);
3913                 dml_print("DML::%s: k=%u, HTotal = %u\n", __func__, k, p->HTotal[k]);
3914                 dml_print("DML::%s: k=%u, PixelClock = %f\n", __func__, k, p->PixelClock[k]);
3915                 dml_print("DML::%s: k=%u, VRatio = %f\n", __func__, k, p->VRatio[k]);
3916                 dml_print("DML::%s: k=%u, DETBufferingTimeY = %f\n", __func__, k, DETBufferingTimeY);
3917                 dml_print("DML::%s: k=%u,PixelClock = %f\n", __func__, k, p->PixelClock[k]);
3918 #endif
3919
3920                 if (!FoundCriticalSurface || DETBufferingTimeY < *p->StutterPeriod) {
3921                         dml_bool_t isInterlaceTiming = p->Interlace[k] && !p->ProgressiveToInterlaceUnitInOPP;
3922
3923                         FoundCriticalSurface = true;
3924                         *p->StutterPeriod = DETBufferingTimeY;
3925                         FrameTimeCriticalSurface = (isInterlaceTiming ? dml_floor((dml_float_t)p->VTotal[k]/2.0, 1.0) : p->VTotal[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
3926                         VActiveTimeCriticalSurface = (isInterlaceTiming ? dml_floor((dml_float_t)p->VActive[k]/2.0, 1.0) : p->VActive[k]) * (dml_float_t)p->HTotal[k] / p->PixelClock[k];
3927                         BytePerPixelYCriticalSurface = p->BytePerPixelY[k];
3928                         SwathWidthYCriticalSurface = p->SwathWidthY[k];
3929                         SwathHeightYCriticalSurface = p->SwathHeightY[k];
3930                         BlockWidth256BytesYCriticalSurface = p->BlockWidth256BytesY[k];
3931                         LinesToFinishSwathTransferStutterCriticalSurface = p->SwathHeightY[k] - (LinesInDETY - LinesInDETYRoundedDownToSwath);
3932                         DETBufferSizeYCriticalSurface = p->DETBufferSizeY[k];
3933                         MinTTUVBlankCriticalSurface = p->MinTTUVBlank[k];
3934                         SinglePlaneCriticalSurface = (p->ReadBandwidthSurfaceChroma[k] == 0);
3935                         SinglePipeCriticalSurface = (p->DPPPerSurface[k] == 1);
3936
3937 #ifdef __DML_VBA_DEBUG__
3938                         dml_print("DML::%s: k=%u, FoundCriticalSurface = %u\n", __func__, k, FoundCriticalSurface);
3939                         dml_print("DML::%s: k=%u, StutterPeriod = %f\n", __func__, k, *p->StutterPeriod);
3940                         dml_print("DML::%s: k=%u, MinTTUVBlankCriticalSurface = %f\n", __func__, k, MinTTUVBlankCriticalSurface);
3941                         dml_print("DML::%s: k=%u, FrameTimeCriticalSurface = %f\n", __func__, k, FrameTimeCriticalSurface);
3942                         dml_print("DML::%s: k=%u, VActiveTimeCriticalSurface = %f\n", __func__, k, VActiveTimeCriticalSurface);
3943                         dml_print("DML::%s: k=%u, BytePerPixelYCriticalSurface = %u\n", __func__, k, BytePerPixelYCriticalSurface);
3944                         dml_print("DML::%s: k=%u, SwathWidthYCriticalSurface = %f\n", __func__, k, SwathWidthYCriticalSurface);
3945                         dml_print("DML::%s: k=%u, SwathHeightYCriticalSurface = %f\n", __func__, k, SwathHeightYCriticalSurface);
3946                         dml_print("DML::%s: k=%u, BlockWidth256BytesYCriticalSurface = %u\n", __func__, k, BlockWidth256BytesYCriticalSurface);
3947                         dml_print("DML::%s: k=%u, SinglePlaneCriticalSurface = %u\n", __func__, k, SinglePlaneCriticalSurface);
3948                         dml_print("DML::%s: k=%u, SinglePipeCriticalSurface = %u\n", __func__, k, SinglePipeCriticalSurface);
3949                         dml_print("DML::%s: k=%u, LinesToFinishSwathTransferStutterCriticalSurface = %f\n", __func__, k, LinesToFinishSwathTransferStutterCriticalSurface);
3950 #endif
3951                 }
3952         }
3953         }
3954
3955         PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = dml_min(*p->StutterPeriod * p->TotalDataReadBandwidth, EffectiveCompressedBufferSize);
3956 #ifdef __DML_VBA_DEBUG__
3957         dml_print("DML::%s: ROBBufferSizeInKByte = %u\n", __func__, p->ROBBufferSizeInKByte);
3958         dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
3959         dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", __func__, *p->StutterPeriod * p->TotalDataReadBandwidth);
3960         dml_print("DML::%s: ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate + EffectiveCompressedBufferSize = %f\n", __func__, p->ROBBufferSizeInKByte * 1024 * AverageDCCCompressionRate + EffectiveCompressedBufferSize);
3961         dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
3962         dml_print("DML::%s: PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer);
3963         dml_print("DML::%s: ReturnBW = %f\n", __func__, p->ReturnBW);
3964         dml_print("DML::%s: TotalDataReadBandwidth = %f\n", __func__, p->TotalDataReadBandwidth);
3965         dml_print("DML::%s: TotalRowReadBandwidth = %f\n", __func__, TotalRowReadBandwidth);
3966         dml_print("DML::%s: DCFCLK = %f\n", __func__, p->DCFCLK);
3967 #endif
3968
3969         StutterBurstTime = PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate / p->ReturnBW + (*p->StutterPeriod * p->TotalDataReadBandwidth - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (p->DCFCLK * 64) + *p->StutterPeriod * TotalRowReadBandwidth / p->ReturnBW;
3970 #ifdef __DML_VBA_DEBUG__
3971         dml_print("DML::%s: Part 1 = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate / p->ReturnBW);
3972         dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", __func__, (*p->StutterPeriod * p->TotalDataReadBandwidth));
3973         dml_print("DML::%s: Part 2 = %f\n", __func__, (*p->StutterPeriod * p->TotalDataReadBandwidth - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (p->DCFCLK * 64));
3974         dml_print("DML::%s: Part 3 = %f\n", __func__, *p->StutterPeriod * TotalRowReadBandwidth / p->ReturnBW);
3975         dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
3976 #endif
3977         StutterBurstTime = dml_max(StutterBurstTime, LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / p->ReturnBW);
3978
3979         dml_print("DML::%s: Time to finish residue swath=%f\n", __func__, LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / p->ReturnBW);
3980
3981         TotalActiveWriteback = 0;
3982         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
3983                 if (p->WritebackEnable[k]) {
3984                         TotalActiveWriteback = TotalActiveWriteback + 1;
3985                 }
3986         }
3987
3988         if (TotalActiveWriteback == 0) {
3989 #ifdef __DML_VBA_DEBUG__
3990                 dml_print("DML::%s: SRExitTime = %f\n", __func__, p->SRExitTime);
3991                 dml_print("DML::%s: SRExitZ8Time = %f\n", __func__, p->SRExitZ8Time);
3992                 dml_print("DML::%s: StutterBurstTime = %f (final)\n", __func__, StutterBurstTime);
3993                 dml_print("DML::%s: StutterPeriod = %f\n", __func__, *p->StutterPeriod);
3994 #endif
3995                 *p->StutterEfficiencyNotIncludingVBlank = dml_max(0., 1 - (p->SRExitTime + StutterBurstTime) / *p->StutterPeriod) * 100;
3996                 *p->Z8StutterEfficiencyNotIncludingVBlank = dml_max(0., 1 - (p->SRExitZ8Time + StutterBurstTime) / *p->StutterPeriod) * 100;
3997                 *p->NumberOfStutterBurstsPerFrame = (*p->StutterEfficiencyNotIncludingVBlank > 0 ? (dml_uint_t)(dml_ceil(VActiveTimeCriticalSurface / *p->StutterPeriod, 1)) : 0);
3998                 *p->Z8NumberOfStutterBurstsPerFrame = (*p->Z8StutterEfficiencyNotIncludingVBlank > 0 ? (dml_uint_t)(dml_ceil(VActiveTimeCriticalSurface / *p->StutterPeriod, 1)) : 0);
3999         } else {
4000                 *p->StutterEfficiencyNotIncludingVBlank = 0.;
4001                 *p->Z8StutterEfficiencyNotIncludingVBlank = 0.;
4002                 *p->NumberOfStutterBurstsPerFrame = 0;
4003                 *p->Z8NumberOfStutterBurstsPerFrame = 0;
4004         }
4005 #ifdef __DML_VBA_DEBUG__
4006         dml_print("DML::%s: VActiveTimeCriticalSurface = %f\n", __func__, VActiveTimeCriticalSurface);
4007         dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->StutterEfficiencyNotIncludingVBlank);
4008         dml_print("DML::%s: Z8StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->Z8StutterEfficiencyNotIncludingVBlank);
4009         dml_print("DML::%s: NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->NumberOfStutterBurstsPerFrame);
4010         dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->Z8NumberOfStutterBurstsPerFrame);
4011 #endif
4012
4013         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4014                 if (p->UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
4015                         if (p->BlendingAndTiming[k] == k) {
4016                                 if (TotalNumberOfActiveOTG == 0) {
4017                                         SinglePixelClock = p->PixelClock[k];
4018                                         SingleHTotal = p->HTotal[k];
4019                                         SingleVTotal = p->VTotal[k];
4020                                 } else if (SinglePixelClock != p->PixelClock[k] || SingleHTotal != p->HTotal[k] || SingleVTotal != p->VTotal[k]) {
4021                                         SameTiming = false;
4022                                 }
4023                                 TotalNumberOfActiveOTG = TotalNumberOfActiveOTG + 1;
4024                         }
4025                 }
4026         }
4027
4028         if (*p->StutterEfficiencyNotIncludingVBlank > 0) {
4029                 LastStutterPeriod = VActiveTimeCriticalSurface - (*p->NumberOfStutterBurstsPerFrame - 1) * *p->StutterPeriod;
4030
4031                 if ((p->SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming &&
4032                         LastStutterPeriod + MinTTUVBlankCriticalSurface > p->StutterEnterPlusExitWatermark) {
4033                         *p->StutterEfficiency = (1 - (*p->NumberOfStutterBurstsPerFrame * p->SRExitTime + StutterBurstTime * VActiveTimeCriticalSurface / *p->StutterPeriod) / FrameTimeCriticalSurface) * 100;
4034                 } else {
4035                         *p->StutterEfficiency = *p->StutterEfficiencyNotIncludingVBlank;
4036                 }
4037         } else {
4038                 *p->StutterEfficiency = 0;
4039         }
4040
4041         if (*p->Z8StutterEfficiencyNotIncludingVBlank > 0) {
4042                 LastZ8StutterPeriod = VActiveTimeCriticalSurface - (*p->NumberOfStutterBurstsPerFrame - 1) * *p->StutterPeriod;
4043                 if ((p->SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming && LastZ8StutterPeriod + MinTTUVBlankCriticalSurface > p->Z8StutterEnterPlusExitWatermark) {
4044                         *p->Z8StutterEfficiency = (1 - (*p->NumberOfStutterBurstsPerFrame * p->SRExitZ8Time + StutterBurstTime * VActiveTimeCriticalSurface / *p->StutterPeriod) / FrameTimeCriticalSurface) * 100;
4045                 } else {
4046                         *p->Z8StutterEfficiency = *p->Z8StutterEfficiencyNotIncludingVBlank;
4047                 }
4048         } else {
4049                 *p->Z8StutterEfficiency = 0.;
4050         }
4051
4052 #ifdef __DML_VBA_DEBUG__
4053                 dml_print("DML::%s: LastZ8StutterPeriod = %f\n", __func__, LastZ8StutterPeriod);
4054                 dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, p->Z8StutterEnterPlusExitWatermark);
4055                 dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
4056                 dml_print("DML::%s: StutterPeriod = %f\n", __func__, *p->StutterPeriod);
4057                 dml_print("DML::%s: StutterEfficiency = %f\n", __func__, *p->StutterEfficiency);
4058                 dml_print("DML::%s: Z8StutterEfficiency = %f\n", __func__, *p->Z8StutterEfficiency);
4059                 dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", __func__, *p->StutterEfficiencyNotIncludingVBlank);
4060                 dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %u\n", __func__, *p->Z8NumberOfStutterBurstsPerFrame);
4061 #endif
4062
4063                 SwathSizeCriticalSurface = (dml_uint_t)(BytePerPixelYCriticalSurface * SwathHeightYCriticalSurface * dml_ceil(SwathWidthYCriticalSurface, BlockWidth256BytesYCriticalSurface));
4064                 LastChunkOfSwathSize = SwathSizeCriticalSurface % (p->PixelChunkSizeInKByte * 1024);
4065                 MissingPartOfLastSwathOfDETSize = (dml_uint_t)(dml_ceil(DETBufferSizeYCriticalSurface, SwathSizeCriticalSurface) - DETBufferSizeYCriticalSurface);
4066
4067                 *p->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = !(!p->UnboundedRequestEnabled && (p->NumberOfActiveSurfaces == 1) && SinglePlaneCriticalSurface && SinglePipeCriticalSurface && (LastChunkOfSwathSize > 0) &&
4068                         (LastChunkOfSwathSize <= 4096) && (MissingPartOfLastSwathOfDETSize > 0) && (MissingPartOfLastSwathOfDETSize <= LastChunkOfSwathSize));
4069
4070 #ifdef __DML_VBA_DEBUG__
4071         dml_print("DML::%s: SwathSizeCriticalSurface = %u\n", __func__, SwathSizeCriticalSurface);
4072         dml_print("DML::%s: DETBufferSizeYCriticalSurface = %u\n", __func__, DETBufferSizeYCriticalSurface);
4073         dml_print("DML::%s: PixelChunkSizeInKByte = %u\n", __func__, p->PixelChunkSizeInKByte);
4074         dml_print("DML::%s: LastChunkOfSwathSize = %u\n", __func__, LastChunkOfSwathSize);
4075         dml_print("DML::%s: MissingPartOfLastSwathOfDETSize = %u\n", __func__, MissingPartOfLastSwathOfDETSize);
4076         dml_print("DML::%s: DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = %u\n", __func__, *p->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
4077 #endif
4078 } // CalculateStutterEfficiency
4079
4080 /// \CalculateSwathAndDETConfiguration
4081 /// @brief Calculates swath width and different return buffers sizing (DET, CDB, etc.)
4082 static void CalculateSwathAndDETConfiguration(struct display_mode_lib_scratch_st *scratch,
4083         struct CalculateSwathAndDETConfiguration_params_st *p)
4084 {
4085         dml_uint_t MaximumSwathHeightY[__DML_NUM_PLANES__];
4086         dml_uint_t MaximumSwathHeightC[__DML_NUM_PLANES__];
4087         dml_uint_t RoundedUpMaxSwathSizeBytesY[__DML_NUM_PLANES__];
4088         dml_uint_t RoundedUpMaxSwathSizeBytesC[__DML_NUM_PLANES__];
4089         dml_uint_t RoundedUpSwathSizeBytesY[__DML_NUM_PLANES__];
4090         dml_uint_t RoundedUpSwathSizeBytesC[__DML_NUM_PLANES__];
4091         dml_uint_t SwathWidthSingleDPP[__DML_NUM_PLANES__];
4092         dml_uint_t SwathWidthSingleDPPChroma[__DML_NUM_PLANES__];
4093
4094         dml_uint_t TotalActiveDPP = 0;
4095         dml_bool_t NoChromaOrLinearSurfaces = true;
4096         dml_uint_t SurfaceDoingUnboundedRequest = 0;
4097
4098         dml_uint_t DETBufferSizeInKByteForSwathCalculation;
4099
4100         const long TTUFIFODEPTH = 8;
4101         const long MAXIMUMCOMPRESSION = 4;
4102
4103 #ifdef __DML_VBA_DEBUG__
4104         dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, p->ForceSingleDPP);
4105         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4106                 dml_print("DML::%s: DPPPerSurface[%u] = %u\n", __func__, k, p->DPPPerSurface[k]);
4107         }
4108 #endif
4109         CalculateSwathWidth(p->ForceSingleDPP,
4110                 p->NumberOfActiveSurfaces,
4111                 p->SourcePixelFormat,
4112                 p->SourceScan,
4113                 p->ViewportStationary,
4114                 p->ViewportWidth,
4115                 p->ViewportHeight,
4116                 p->ViewportXStart,
4117                 p->ViewportYStart,
4118                 p->ViewportXStartC,
4119                 p->ViewportYStartC,
4120                 p->SurfaceWidthY,
4121                 p->SurfaceWidthC,
4122                 p->SurfaceHeightY,
4123                 p->SurfaceHeightC,
4124                 p->ODMMode,
4125                 p->BytePerPixY,
4126                 p->BytePerPixC,
4127                 p->Read256BytesBlockHeightY,
4128                 p->Read256BytesBlockHeightC,
4129                 p->Read256BytesBlockWidthY,
4130                 p->Read256BytesBlockWidthC,
4131                 p->BlendingAndTiming,
4132                 p->HActive,
4133                 p->HRatio,
4134                 p->DPPPerSurface,
4135
4136                 // Output
4137                 SwathWidthSingleDPP,
4138                 SwathWidthSingleDPPChroma,
4139                 p->SwathWidth,
4140                 p->SwathWidthChroma,
4141                 MaximumSwathHeightY,
4142                 MaximumSwathHeightC,
4143                 p->swath_width_luma_ub,
4144                 p->swath_width_chroma_ub);
4145
4146         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4147                 RoundedUpMaxSwathSizeBytesY[k] = (dml_uint_t)(p->swath_width_luma_ub[k] * p->BytePerPixDETY[k] * MaximumSwathHeightY[k]);
4148                 RoundedUpMaxSwathSizeBytesC[k] = (dml_uint_t)(p->swath_width_chroma_ub[k] * p->BytePerPixDETC[k] * MaximumSwathHeightC[k]);
4149 #ifdef __DML_VBA_DEBUG__
4150                 dml_print("DML::%s: k=%u DPPPerSurface = %u\n", __func__, k, p->DPPPerSurface[k]);
4151                 dml_print("DML::%s: k=%u swath_width_luma_ub = %u\n", __func__, k, p->swath_width_luma_ub[k]);
4152                 dml_print("DML::%s: k=%u BytePerPixDETY = %f\n", __func__, k, p->BytePerPixDETY[k]);
4153                 dml_print("DML::%s: k=%u MaximumSwathHeightY = %u\n", __func__, k, MaximumSwathHeightY[k]);
4154                 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4155                 dml_print("DML::%s: k=%u swath_width_chroma_ub = %u\n", __func__, k, p->swath_width_chroma_ub[k]);
4156                 dml_print("DML::%s: k=%u BytePerPixDETC = %f\n", __func__, k, p->BytePerPixDETC[k]);
4157                 dml_print("DML::%s: k=%u MaximumSwathHeightC = %u\n", __func__, k, MaximumSwathHeightC[k]);
4158                 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4159 #endif
4160                 if (p->SourcePixelFormat[k] == dml_420_10) {
4161                         RoundedUpMaxSwathSizeBytesY[k] = (dml_uint_t)(dml_ceil((dml_float_t) RoundedUpMaxSwathSizeBytesY[k], 256));
4162                         RoundedUpMaxSwathSizeBytesC[k] = (dml_uint_t)(dml_ceil((dml_float_t) RoundedUpMaxSwathSizeBytesC[k], 256));
4163                 }
4164         }
4165
4166         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4167                 TotalActiveDPP = TotalActiveDPP + (p->ForceSingleDPP ? 1 : p->DPPPerSurface[k]);
4168                 if (p->DPPPerSurface[k] > 0)
4169                         SurfaceDoingUnboundedRequest = k;
4170                 if (p->SourcePixelFormat[k] == dml_420_8 || p->SourcePixelFormat[k] == dml_420_10 ||
4171                                 p->SourcePixelFormat[k] == dml_420_12 || p->SourcePixelFormat[k] == dml_rgbe_alpha
4172                                 || p->SurfaceTiling[k] == dml_sw_linear) {
4173                         NoChromaOrLinearSurfaces = false;
4174                 }
4175         }
4176
4177         *p->UnboundedRequestEnabled = UnboundedRequest(p->UseUnboundedRequestingFinal, TotalActiveDPP,
4178                         NoChromaOrLinearSurfaces, p->Output[0]);
4179
4180         CalculateDETBufferSize(p->DETSizeOverride,
4181                 p->UseMALLForPStateChange,
4182                 p->ForceSingleDPP,
4183                 p->NumberOfActiveSurfaces,
4184                 *p->UnboundedRequestEnabled,
4185                 p->nomDETInKByte,
4186                 p->MaxTotalDETInKByte,
4187                 p->ConfigReturnBufferSizeInKByte,
4188                 p->MinCompressedBufferSizeInKByte,
4189                 p->ConfigReturnBufferSegmentSizeInkByte,
4190                 p->CompressedBufferSegmentSizeInkByteFinal,
4191                 p->SourcePixelFormat,
4192                 p->ReadBandwidthLuma,
4193                 p->ReadBandwidthChroma,
4194                 RoundedUpMaxSwathSizeBytesY,
4195                 RoundedUpMaxSwathSizeBytesC,
4196                 p->DPPPerSurface,
4197
4198                 // Output
4199                 p->DETBufferSizeInKByte, // per hubp pipe
4200                 p->CompressedBufferSizeInkByte);
4201
4202 #ifdef __DML_VBA_DEBUG__
4203                 dml_print("DML::%s: TotalActiveDPP = %u\n", __func__, TotalActiveDPP);
4204                 dml_print("DML::%s: nomDETInKByte = %u\n", __func__, p->nomDETInKByte);
4205                 dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, p->ConfigReturnBufferSizeInKByte);
4206                 dml_print("DML::%s: UseUnboundedRequestingFinal = %u\n", __func__, p->UseUnboundedRequestingFinal);
4207                 dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, *p->UnboundedRequestEnabled);
4208                 dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, *p->CompressedBufferSizeInkByte);
4209 #endif
4210
4211         *p->ViewportSizeSupport = true;
4212         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4213
4214                 DETBufferSizeInKByteForSwathCalculation =  (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe ? 1024 : p->DETBufferSizeInKByte[k]);
4215 #ifdef __DML_VBA_DEBUG__
4216         dml_print("DML::%s: k=%u DETBufferSizeInKByteForSwathCalculation = %u\n", __func__, k, DETBufferSizeInKByteForSwathCalculation);
4217 #endif
4218
4219                 if (RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4220                         p->SwathHeightY[k] = MaximumSwathHeightY[k];
4221                         p->SwathHeightC[k] = MaximumSwathHeightC[k];
4222                         RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k];
4223                         RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k];
4224                 } else if (RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * RoundedUpMaxSwathSizeBytesC[k] && RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4225                         p->SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
4226                         p->SwathHeightC[k] = MaximumSwathHeightC[k];
4227                         RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k] / 2;
4228                         RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k];
4229                 } else if (RoundedUpMaxSwathSizeBytesY[k] < 1.5 * RoundedUpMaxSwathSizeBytesC[k] && RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] / 2 <= DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
4230                         p->SwathHeightY[k] = MaximumSwathHeightY[k];
4231                         p->SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
4232                         RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k];
4233                         RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k] / 2;
4234                 } else {
4235                         p->SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
4236                         p->SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
4237                         RoundedUpSwathSizeBytesY[k] = RoundedUpMaxSwathSizeBytesY[k] / 2;
4238                         RoundedUpSwathSizeBytesC[k] = RoundedUpMaxSwathSizeBytesC[k] / 2;
4239                 }
4240
4241                 if ((RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] / 2 > DETBufferSizeInKByteForSwathCalculation * 1024 / 2) ||
4242                         p->SwathWidth[k] > p->MaximumSwathWidthLuma[k] || (p->SwathHeightC[k] > 0 && p->SwathWidthChroma[k] > p->MaximumSwathWidthChroma[k])) {
4243                         *p->ViewportSizeSupport = false;
4244                         p->ViewportSizeSupportPerSurface[k] = false;
4245                 } else {
4246                         p->ViewportSizeSupportPerSurface[k] = true;
4247                 }
4248
4249         if (p->SwathHeightC[k] == 0) {
4250 #ifdef __DML_VBA_DEBUG__
4251                         dml_print("DML::%s: k=%u All DET for plane0\n", __func__, k);
4252 #endif
4253                         p->DETBufferSizeY[k] = p->DETBufferSizeInKByte[k] * 1024;
4254                         p->DETBufferSizeC[k] = 0;
4255                 } else if (RoundedUpSwathSizeBytesY[k] <= 1.5 * RoundedUpSwathSizeBytesC[k]) {
4256 #ifdef __DML_VBA_DEBUG__
4257                         dml_print("DML::%s: k=%u Half DET for plane0, half for plane1\n", __func__, k);
4258 #endif
4259                         p->DETBufferSizeY[k] = p->DETBufferSizeInKByte[k] * 1024 / 2;
4260                         p->DETBufferSizeC[k] = p->DETBufferSizeInKByte[k] * 1024 / 2;
4261                 } else {
4262 #ifdef __DML_VBA_DEBUG__
4263                         dml_print("DML::%s: k=%u 2/3 DET for plane0, 1/3 for plane1\n", __func__, k);
4264 #endif
4265                         p->DETBufferSizeY[k] = (dml_uint_t)(dml_floor(p->DETBufferSizeInKByte[k] * 1024 * 2 / 3, 1024));
4266                         p->DETBufferSizeC[k] = p->DETBufferSizeInKByte[k] * 1024 - p->DETBufferSizeY[k];
4267                 }
4268
4269 #ifdef __DML_VBA_DEBUG__
4270                 dml_print("DML::%s: k=%u SwathHeightY = %u\n", __func__, k, p->SwathHeightY[k]);
4271                 dml_print("DML::%s: k=%u SwathHeightC = %u\n", __func__, k, p->SwathHeightC[k]);
4272                 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4273                 dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4274                 dml_print("DML::%s: k=%u RoundedUpSwathSizeBytesY = %u\n", __func__, k, RoundedUpSwathSizeBytesY[k]);
4275                 dml_print("DML::%s: k=%u RoundedUpSwathSizeBytesC = %u\n", __func__, k, RoundedUpSwathSizeBytesC[k]);
4276                 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u\n", __func__, k, p->DETBufferSizeInKByte[k]);
4277                 dml_print("DML::%s: k=%u DETBufferSizeY = %u\n", __func__, k, p->DETBufferSizeY[k]);
4278                 dml_print("DML::%s: k=%u DETBufferSizeC = %u\n", __func__, k, p->DETBufferSizeC[k]);
4279                 dml_print("DML::%s: k=%u ViewportSizeSupportPerSurface = %u\n", __func__, k, p->ViewportSizeSupportPerSurface[k]);
4280 #endif
4281
4282         }
4283
4284         *p->compbuf_reserved_space_64b = 2 * p->PixelChunkSizeInKByte * 1024 / 64;
4285         if (p->UnboundedRequestEnabled) {
4286                 *p->compbuf_reserved_space_64b = dml_max(*p->compbuf_reserved_space_64b,
4287                                 (dml_float_t)(p->ROBBufferSizeInKByte * 1024/64)
4288                                 - (dml_float_t)(RoundedUpSwathSizeBytesY[SurfaceDoingUnboundedRequest] * TTUFIFODEPTH / MAXIMUMCOMPRESSION/64));
4289         }
4290         *p->compbuf_reserved_space_zs = 2 * p->PixelChunkSizeInKByte * 1024 / 256;
4291 } // CalculateSwathAndDETConfiguration
4292
4293 static void CalculateSwathWidth(
4294                 dml_bool_t ForceSingleDPP,
4295                 dml_uint_t NumberOfActiveSurfaces,
4296                 enum dml_source_format_class SourcePixelFormat[],
4297                 enum dml_rotation_angle SourceScan[],
4298                 dml_bool_t ViewportStationary[],
4299                 dml_uint_t ViewportWidth[],
4300                 dml_uint_t ViewportHeight[],
4301                 dml_uint_t ViewportXStart[],
4302                 dml_uint_t ViewportYStart[],
4303                 dml_uint_t ViewportXStartC[],
4304                 dml_uint_t ViewportYStartC[],
4305                 dml_uint_t SurfaceWidthY[],
4306                 dml_uint_t SurfaceWidthC[],
4307                 dml_uint_t SurfaceHeightY[],
4308                 dml_uint_t SurfaceHeightC[],
4309                 enum dml_odm_mode ODMMode[],
4310                 dml_uint_t BytePerPixY[],
4311                 dml_uint_t BytePerPixC[],
4312                 dml_uint_t Read256BytesBlockHeightY[],
4313                 dml_uint_t Read256BytesBlockHeightC[],
4314                 dml_uint_t Read256BytesBlockWidthY[],
4315                 dml_uint_t Read256BytesBlockWidthC[],
4316                 dml_uint_t BlendingAndTiming[],
4317                 dml_uint_t HActive[],
4318                 dml_float_t HRatio[],
4319                 dml_uint_t DPPPerSurface[],
4320
4321                 // Output
4322                 dml_uint_t SwathWidthSingleDPPY[],
4323                 dml_uint_t SwathWidthSingleDPPC[],
4324                 dml_uint_t SwathWidthY[], // per-pipe
4325                 dml_uint_t SwathWidthC[], // per-pipe
4326                 dml_uint_t MaximumSwathHeightY[],
4327                 dml_uint_t MaximumSwathHeightC[],
4328                 dml_uint_t swath_width_luma_ub[], // per-pipe
4329                 dml_uint_t swath_width_chroma_ub[]) // per-pipe
4330 {
4331         enum dml_odm_mode   MainSurfaceODMMode;
4332         dml_uint_t surface_width_ub_l;
4333         dml_uint_t surface_height_ub_l;
4334         dml_uint_t surface_width_ub_c = 0;
4335         dml_uint_t surface_height_ub_c = 0;
4336
4337 #ifdef __DML_VBA_DEBUG__
4338         dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, ForceSingleDPP);
4339         dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
4340 #endif
4341
4342         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4343                 if (!dml_is_vertical_rotation(SourceScan[k])) {
4344                         SwathWidthSingleDPPY[k] = ViewportWidth[k];
4345                 } else {
4346                         SwathWidthSingleDPPY[k] = ViewportHeight[k];
4347                 }
4348
4349 #ifdef __DML_VBA_DEBUG__
4350                 dml_print("DML::%s: k=%u ViewportWidth=%u\n", __func__, k, ViewportWidth[k]);
4351                 dml_print("DML::%s: k=%u ViewportHeight=%u\n", __func__, k, ViewportHeight[k]);
4352                 dml_print("DML::%s: k=%u DPPPerSurface=%u\n", __func__, k, DPPPerSurface[k]);
4353 #endif
4354
4355                 MainSurfaceODMMode = ODMMode[k];
4356                 for (dml_uint_t j = 0; j < NumberOfActiveSurfaces; ++j) {
4357                         if (BlendingAndTiming[k] == j) {
4358                                 MainSurfaceODMMode = ODMMode[j];
4359                         }
4360                 }
4361
4362                 if (ForceSingleDPP) {
4363                         SwathWidthY[k] = SwathWidthSingleDPPY[k];
4364                 } else {
4365                         if (MainSurfaceODMMode == dml_odm_mode_combine_4to1) {
4366                                 SwathWidthY[k] = (dml_uint_t)(dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 4.0 * HRatio[k], true)));
4367                         } else if (MainSurfaceODMMode == dml_odm_mode_combine_2to1) {
4368                                 SwathWidthY[k] = (dml_uint_t)(dml_min(SwathWidthSingleDPPY[k], dml_round(HActive[k] / 2.0 * HRatio[k], true)));
4369                         } else if (DPPPerSurface[k] == 2) {
4370                                 SwathWidthY[k] = SwathWidthSingleDPPY[k] / 2;
4371                         } else {
4372                                 SwathWidthY[k] = SwathWidthSingleDPPY[k];
4373                         }
4374                 }
4375
4376 #ifdef __DML_VBA_DEBUG__
4377                 dml_print("DML::%s: k=%u HActive=%u\n", __func__, k, HActive[k]);
4378                 dml_print("DML::%s: k=%u HRatio=%f\n", __func__, k, HRatio[k]);
4379                 dml_print("DML::%s: k=%u MainSurfaceODMMode=%u\n", __func__, k, MainSurfaceODMMode);
4380                 dml_print("DML::%s: k=%u SwathWidthSingleDPPY=%u\n", __func__, k, SwathWidthSingleDPPY[k]);
4381                 dml_print("DML::%s: k=%u SwathWidthY=%u\n", __func__, k, SwathWidthY[k]);
4382 #endif
4383
4384                 if (SourcePixelFormat[k] == dml_420_8 || SourcePixelFormat[k] == dml_420_10 || SourcePixelFormat[k] == dml_420_12) {
4385                         SwathWidthC[k] = SwathWidthY[k] / 2;
4386                         SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k] / 2;
4387                 } else {
4388                         SwathWidthC[k] = SwathWidthY[k];
4389                         SwathWidthSingleDPPC[k] = SwathWidthSingleDPPY[k];
4390                 }
4391
4392                 if (ForceSingleDPP == true) {
4393                         SwathWidthY[k] = SwathWidthSingleDPPY[k];
4394                         SwathWidthC[k] = SwathWidthSingleDPPC[k];
4395                 }
4396
4397                 surface_width_ub_l = (dml_uint_t)dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
4398                 surface_height_ub_l = (dml_uint_t)dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
4399
4400                 if (!dml_is_vertical_rotation(SourceScan[k])) {
4401                         MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k];
4402                         MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k];
4403                         if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4404                                 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_l, dml_floor(ViewportXStart[k] + SwathWidthY[k] + Read256BytesBlockWidthY[k] - 1, Read256BytesBlockWidthY[k]) - dml_floor(ViewportXStart[k], Read256BytesBlockWidthY[k])));
4405                         } else {
4406                                 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_l, dml_ceil(SwathWidthY[k] - 1, Read256BytesBlockWidthY[k]) + Read256BytesBlockWidthY[k]));
4407                         }
4408                         if (BytePerPixC[k] > 0) {
4409                                 surface_width_ub_c = (dml_uint_t)dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
4410                                 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4411                                         swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_c, dml_floor(ViewportXStartC[k] + SwathWidthC[k] + Read256BytesBlockWidthC[k] - 1, Read256BytesBlockWidthC[k]) - dml_floor(ViewportXStartC[k], Read256BytesBlockWidthC[k])));
4412                                 } else {
4413                                         swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_width_ub_c, dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockWidthC[k]) + Read256BytesBlockWidthC[k]));
4414                                 }
4415                         } else {
4416                                 swath_width_chroma_ub[k] = 0;
4417                         }
4418                 } else {
4419                         MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k];
4420                         MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k];
4421
4422                         if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4423                                 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_l, dml_floor(ViewportYStart[k] + SwathWidthY[k] + Read256BytesBlockHeightY[k] - 1, Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStart[k], Read256BytesBlockHeightY[k])));
4424                         } else {
4425                                 swath_width_luma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_l, dml_ceil(SwathWidthY[k] - 1, Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]));
4426                         }
4427                         if (BytePerPixC[k] > 0) {
4428                                 surface_height_ub_c = (dml_uint_t)dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
4429                                 if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
4430                                         swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_c, dml_floor(ViewportYStartC[k] + SwathWidthC[k] + Read256BytesBlockHeightC[k] - 1, Read256BytesBlockHeightC[k]) - dml_floor(ViewportYStartC[k], Read256BytesBlockHeightC[k])));
4431                                 } else {
4432                                         swath_width_chroma_ub[k] = (dml_uint_t)(dml_min(surface_height_ub_c, dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockHeightC[k]) + Read256BytesBlockHeightC[k]));
4433                                 }
4434                         } else {
4435                                 swath_width_chroma_ub[k] = 0;
4436                         }
4437                 }
4438
4439 #ifdef __DML_VBA_DEBUG__
4440                 dml_print("DML::%s: k=%u surface_width_ub_l=%u\n", __func__, k, surface_width_ub_l);
4441                 dml_print("DML::%s: k=%u surface_height_ub_l=%u\n", __func__, k, surface_height_ub_l);
4442                 dml_print("DML::%s: k=%u surface_width_ub_c=%u\n", __func__, k, surface_width_ub_c);
4443                 dml_print("DML::%s: k=%u surface_height_ub_c=%u\n", __func__, k, surface_height_ub_c);
4444                 dml_print("DML::%s: k=%u Read256BytesBlockWidthY=%u\n", __func__, k, Read256BytesBlockWidthY[k]);
4445                 dml_print("DML::%s: k=%u Read256BytesBlockHeightY=%u\n", __func__, k, Read256BytesBlockHeightY[k]);
4446                 dml_print("DML::%s: k=%u Read256BytesBlockWidthC=%u\n", __func__, k, Read256BytesBlockWidthC[k]);
4447                 dml_print("DML::%s: k=%u Read256BytesBlockHeightC=%u\n", __func__, k, Read256BytesBlockHeightC[k]);
4448                 dml_print("DML::%s: k=%u ViewportStationary=%u\n", __func__, k, ViewportStationary[k]);
4449                 dml_print("DML::%s: k=%u DPPPerSurface=%u\n", __func__, k, DPPPerSurface[k]);
4450                 dml_print("DML::%s: k=%u swath_width_luma_ub=%u\n", __func__, k, swath_width_luma_ub[k]);
4451                 dml_print("DML::%s: k=%u swath_width_chroma_ub=%u\n", __func__, k, swath_width_chroma_ub[k]);
4452                 dml_print("DML::%s: k=%u MaximumSwathHeightY=%u\n", __func__, k, MaximumSwathHeightY[k]);
4453                 dml_print("DML::%s: k=%u MaximumSwathHeightC=%u\n", __func__, k, MaximumSwathHeightC[k]);
4454 #endif
4455
4456         }
4457 } // CalculateSwathWidth
4458
4459 static  dml_float_t CalculateExtraLatency(
4460                 dml_uint_t RoundTripPingLatencyCycles,
4461                 dml_uint_t ReorderingBytes,
4462                 dml_float_t DCFCLK,
4463                 dml_uint_t TotalNumberOfActiveDPP,
4464                 dml_uint_t PixelChunkSizeInKByte,
4465                 dml_uint_t TotalNumberOfDCCActiveDPP,
4466                 dml_uint_t MetaChunkSize,
4467                 dml_float_t ReturnBW,
4468                 dml_bool_t GPUVMEnable,
4469                 dml_bool_t HostVMEnable,
4470                 dml_uint_t NumberOfActiveSurfaces,
4471                 dml_uint_t NumberOfDPP[],
4472                 dml_uint_t dpte_group_bytes[],
4473                 dml_float_t HostVMInefficiencyFactor,
4474                 dml_uint_t HostVMMinPageSize,
4475                 dml_uint_t HostVMMaxNonCachedPageTableLevels)
4476 {
4477         dml_float_t ExtraLatencyBytes;
4478         dml_float_t ExtraLatency;
4479
4480         ExtraLatencyBytes = CalculateExtraLatencyBytes(
4481                         ReorderingBytes,
4482                         TotalNumberOfActiveDPP,
4483                         PixelChunkSizeInKByte,
4484                         TotalNumberOfDCCActiveDPP,
4485                         MetaChunkSize,
4486                         GPUVMEnable,
4487                         HostVMEnable,
4488                         NumberOfActiveSurfaces,
4489                         NumberOfDPP,
4490                         dpte_group_bytes,
4491                         HostVMInefficiencyFactor,
4492                         HostVMMinPageSize,
4493                         HostVMMaxNonCachedPageTableLevels);
4494
4495         ExtraLatency = (RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__) / DCFCLK + ExtraLatencyBytes / ReturnBW;
4496
4497 #ifdef __DML_VBA_DEBUG__
4498         dml_print("DML::%s: RoundTripPingLatencyCycles=%u\n", __func__, RoundTripPingLatencyCycles);
4499         dml_print("DML::%s: DCFCLK=%f\n", __func__, DCFCLK);
4500         dml_print("DML::%s: ExtraLatencyBytes=%f\n", __func__, ExtraLatencyBytes);
4501         dml_print("DML::%s: ReturnBW=%f\n", __func__, ReturnBW);
4502         dml_print("DML::%s: ExtraLatency=%f\n", __func__, ExtraLatency);
4503 #endif
4504
4505         return ExtraLatency;
4506 } // CalculateExtraLatency
4507
4508 static dml_uint_t CalculateHostVMDynamicLevels(
4509                                                                         dml_bool_t GPUVMEnable,
4510                                                                         dml_bool_t HostVMEnable,
4511                                                                         dml_uint_t HostVMMinPageSize,
4512                                                                         dml_uint_t HostVMMaxNonCachedPageTableLevels)
4513 {
4514         dml_uint_t HostVMDynamicLevels = 0;
4515
4516         if (GPUVMEnable && HostVMEnable) {
4517                 if (HostVMMinPageSize < 2048)
4518                         HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
4519                 else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576)
4520                         HostVMDynamicLevels = (dml_uint_t) dml_max(0, (dml_float_t) HostVMMaxNonCachedPageTableLevels - 1);
4521                 else
4522                         HostVMDynamicLevels = (dml_uint_t) dml_max(0, (dml_float_t) HostVMMaxNonCachedPageTableLevels - 2);
4523         } else {
4524                 HostVMDynamicLevels = 0;
4525         }
4526         return HostVMDynamicLevels;
4527 }
4528
4529 static dml_uint_t CalculateExtraLatencyBytes(dml_uint_t ReorderingBytes,
4530                                                                                 dml_uint_t TotalNumberOfActiveDPP,
4531                                                                                 dml_uint_t PixelChunkSizeInKByte,
4532                                                                                 dml_uint_t TotalNumberOfDCCActiveDPP,
4533                                                                                 dml_uint_t MetaChunkSize,
4534                                                                                 dml_bool_t GPUVMEnable,
4535                                                                                 dml_bool_t HostVMEnable,
4536                                                                                 dml_uint_t NumberOfActiveSurfaces,
4537                                                                                 dml_uint_t NumberOfDPP[],
4538                                                                                 dml_uint_t dpte_group_bytes[],
4539                                                                                 dml_float_t HostVMInefficiencyFactor,
4540                                                                                 dml_uint_t HostVMMinPageSize,
4541                                                                                 dml_uint_t HostVMMaxNonCachedPageTableLevels)
4542 {
4543         dml_uint_t  HostVMDynamicLevels = CalculateHostVMDynamicLevels(GPUVMEnable, HostVMEnable, HostVMMinPageSize, HostVMMaxNonCachedPageTableLevels);
4544         dml_float_t ret                 = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte + TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0;
4545
4546         if (GPUVMEnable == true) {
4547                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4548                         ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] * (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor;
4549                 }
4550         }
4551         return (dml_uint_t)(ret);
4552 }
4553
4554 static dml_float_t CalculateUrgentLatency(
4555                 dml_float_t UrgentLatencyPixelDataOnly,
4556                 dml_float_t UrgentLatencyPixelMixedWithVMData,
4557                 dml_float_t UrgentLatencyVMDataOnly,
4558                 dml_bool_t DoUrgentLatencyAdjustment,
4559                 dml_float_t UrgentLatencyAdjustmentFabricClockComponent,
4560                 dml_float_t UrgentLatencyAdjustmentFabricClockReference,
4561                 dml_float_t FabricClock)
4562 {
4563         dml_float_t   ret;
4564
4565         ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly);
4566         if (DoUrgentLatencyAdjustment == true) {
4567                 ret = ret + UrgentLatencyAdjustmentFabricClockComponent * (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
4568         }
4569         return ret;
4570 }
4571
4572 static dml_float_t RequiredDTBCLK(
4573                 dml_bool_t DSCEnable,
4574                 dml_float_t PixelClock,
4575                 enum dml_output_format_class OutputFormat,
4576                 dml_float_t OutputBpp,
4577                 dml_uint_t DSCSlices,
4578                 dml_uint_t HTotal,
4579                 dml_uint_t HActive,
4580                 dml_uint_t AudioRate,
4581                 dml_uint_t AudioLayout)
4582 {
4583         if (DSCEnable != true) {
4584                 return dml_max(PixelClock / 4.0 * OutputBpp / 24.0, 25.0);
4585         } else {
4586                 dml_float_t PixelWordRate = PixelClock / (OutputFormat == dml_444 ? 1 : 2);
4587                 dml_float_t HCActive = dml_ceil(DSCSlices * dml_ceil(OutputBpp * dml_ceil(HActive / DSCSlices, 1) / 8.0, 1) / 3.0, 1);
4588                 dml_float_t HCBlank = 64 + 32 * dml_ceil(AudioRate * (AudioLayout == 1 ? 1 : 0.25) * HTotal / (PixelClock * 1000), 1);
4589                 dml_float_t AverageTribyteRate = PixelWordRate * (HCActive + HCBlank) / HTotal;
4590                 dml_float_t HActiveTribyteRate = PixelWordRate * HCActive / HActive;
4591                 return dml_max4(PixelWordRate / 4.0, AverageTribyteRate / 4.0, HActiveTribyteRate / 4.0, 25.0) * 1.002;
4592         }
4593 }
4594
4595 static void UseMinimumDCFCLK(struct display_mode_lib_scratch_st *scratch, struct UseMinimumDCFCLK_params_st *p)
4596 {
4597         struct UseMinimumDCFCLK_locals_st *s = &scratch->UseMinimumDCFCLK_locals;
4598
4599         s->NormalEfficiency = p->PercentOfIdealSDPPortBWReceivedAfterUrgLatency / 100.0;
4600         for (dml_uint_t j = 0; j < 2; ++j) {
4601
4602
4603                 s->TotalMaxPrefetchFlipDPTERowBandwidth[j] = 0;
4604                 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4605                         s->TotalMaxPrefetchFlipDPTERowBandwidth[j] = s->TotalMaxPrefetchFlipDPTERowBandwidth[j] + p->NoOfDPP[j][k] * p->DPTEBytesPerRow[j][k] / (15.75 * p->HTotal[k] / p->PixelClock[k]);
4606                 }
4607
4608                 for (dml_uint_t k = 0; k <= p->NumberOfActiveSurfaces - 1; ++k) {
4609                         s->NoOfDPPState[k] = p->NoOfDPP[j][k];
4610                 }
4611
4612                 s->DPTEBandwidth = s->TotalMaxPrefetchFlipDPTERowBandwidth[j];
4613
4614                 s->DCFCLKRequiredForAverageBandwidth = dml_max(p->ProjectedDCFCLKDeepSleep[j], s->DPTEBandwidth / s->NormalEfficiency / p->ReturnBusWidth);
4615
4616                 s->ExtraLatencyBytes = CalculateExtraLatencyBytes(p->ReorderingBytes, p->TotalNumberOfActiveDPP[j], p->PixelChunkSizeInKByte, p->TotalNumberOfDCCActiveDPP[j],
4617                         p->MetaChunkSize, p->GPUVMEnable, p->HostVMEnable, p->NumberOfActiveSurfaces, s->NoOfDPPState, p->dpte_group_bytes,
4618                                                                                                 1, p->HostVMMinPageSize, p->HostVMMaxNonCachedPageTableLevels);
4619                 s->ExtraLatencyCycles = p->RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__ + s->ExtraLatencyBytes / s->NormalEfficiency / p->ReturnBusWidth;
4620                 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4621                         dml_float_t DCFCLKCyclesRequiredInPrefetch;
4622                         dml_float_t PrefetchTime;
4623
4624                         s->PixelDCFCLKCyclesRequiredInPrefetch[k] = (p->PrefetchLinesY[j][k] * p->swath_width_luma_ub_all_states[j][k] * p->BytePerPixelY[k] + p->PrefetchLinesC[j][k] * p->swath_width_chroma_ub_all_states[j][k] * p->BytePerPixelC[k]) / s->NormalEfficiency / p->ReturnBusWidth;
4625                         DCFCLKCyclesRequiredInPrefetch = 2 * s->ExtraLatencyCycles / s->NoOfDPPState[k] + p->PDEAndMetaPTEBytesPerFrame[j][k] / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth * (p->GPUVMMaxPageTableLevels > 2 ? 1 : 0) + 2 * p->DPTEBytesPerRow[j][k] / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth + 2 * p->MetaRowBytes[j][k] / s->NormalEfficiency / p->ReturnBusWidth + s->PixelDCFCLKCyclesRequiredInPrefetch[k];
4626                         s->PrefetchPixelLinesTime[k] = dml_max(p->PrefetchLinesY[j][k], p->PrefetchLinesC[j][k]) * p->HTotal[k] / p->PixelClock[k];
4627                         s->DynamicMetadataVMExtraLatency[k] = (p->GPUVMEnable == true && p->DynamicMetadataEnable[k] == true && p->DynamicMetadataVMEnabled == true) ? p->UrgLatency * p->GPUVMMaxPageTableLevels * (p->HostVMEnable == true ? p->HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0;
4628
4629                         s->MinimumTWait = CalculateTWait(p->MaxPrefetchMode,
4630                                 p->UseMALLForPStateChange[k],
4631                                 p->SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
4632                                 p->DRRDisplay[k],
4633                                 p->DRAMClockChangeLatencyFinal,
4634                                 p->FCLKChangeLatency,
4635                                 p->UrgLatency,
4636                                 p->SREnterPlusExitTime);
4637
4638                         PrefetchTime = (p->MaximumVStartup[j][k] - 1) * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - p->UrgLatency * ((p->GPUVMMaxPageTableLevels <= 2 ? p->GPUVMMaxPageTableLevels : p->GPUVMMaxPageTableLevels - 2) *  (p->HostVMEnable == true ? p->HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) - s->DynamicMetadataVMExtraLatency[k];
4639
4640                         if (PrefetchTime > 0) {
4641                                 dml_float_t ExpectedVRatioPrefetch;
4642                                 ExpectedVRatioPrefetch = s->PrefetchPixelLinesTime[k] / (PrefetchTime * s->PixelDCFCLKCyclesRequiredInPrefetch[k] / DCFCLKCyclesRequiredInPrefetch);
4643                                 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = s->NoOfDPPState[k] * s->PixelDCFCLKCyclesRequiredInPrefetch[k] / s->PrefetchPixelLinesTime[k] * dml_max(1.0, ExpectedVRatioPrefetch) * dml_max(1.0, ExpectedVRatioPrefetch / 4);
4644                                 if (p->HostVMEnable == true || p->ImmediateFlipRequirement == true) {
4645                                         s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = s->DCFCLKRequiredForPeakBandwidthPerSurface[k] + s->NoOfDPPState[k] * s->DPTEBandwidth / s->NormalEfficiency / s->NormalEfficiency / p->ReturnBusWidth;
4646                                 }
4647                         } else {
4648                                 s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = p->DCFCLKPerState;
4649                         }
4650                         if (p->DynamicMetadataEnable[k] == true) {
4651                                 dml_float_t TSetupPipe;
4652                                 dml_float_t TdmbfPipe;
4653                                 dml_float_t TdmsksPipe;
4654                                 dml_float_t TdmecPipe;
4655                                 dml_float_t AllowedTimeForUrgentExtraLatency;
4656
4657                                 CalculateVUpdateAndDynamicMetadataParameters(
4658                                         p->MaxInterDCNTileRepeaters,
4659                                         p->RequiredDPPCLKPerSurface[j][k],
4660                                         p->RequiredDISPCLK[j],
4661                                         p->ProjectedDCFCLKDeepSleep[j],
4662                                         p->PixelClock[k],
4663                                         p->HTotal[k],
4664                                         p->VTotal[k] - p->VActive[k],
4665                                         p->DynamicMetadataTransmittedBytes[k],
4666                                         p->DynamicMetadataLinesBeforeActiveRequired[k],
4667                                         p->Interlace[k],
4668                                         p->ProgressiveToInterlaceUnitInOPP,
4669
4670                                         // Output
4671                                         &TSetupPipe,
4672                                         &TdmbfPipe,
4673                                         &TdmecPipe,
4674                                         &TdmsksPipe,
4675                                         &s->dummy1,
4676                                         &s->dummy2,
4677                                         &s->dummy3);
4678
4679                                 AllowedTimeForUrgentExtraLatency = p->MaximumVStartup[j][k] * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - TSetupPipe - TdmbfPipe - TdmecPipe - TdmsksPipe - s->DynamicMetadataVMExtraLatency[k];
4680                                 if (AllowedTimeForUrgentExtraLatency > 0) {
4681                                         s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = dml_max(s->DCFCLKRequiredForPeakBandwidthPerSurface[k], s->ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency);
4682                                 } else {
4683                                         s->DCFCLKRequiredForPeakBandwidthPerSurface[k] = p->DCFCLKPerState;
4684                                 }
4685                         }
4686                 }
4687                 s->DCFCLKRequiredForPeakBandwidth = 0;
4688                 for (dml_uint_t k = 0; k <= p->NumberOfActiveSurfaces - 1; ++k) {
4689                         s->DCFCLKRequiredForPeakBandwidth = s->DCFCLKRequiredForPeakBandwidth + s->DCFCLKRequiredForPeakBandwidthPerSurface[k];
4690                 }
4691                 s->MinimumTvmPlus2Tr0 = p->UrgLatency * (p->GPUVMEnable == true ? (p->HostVMEnable == true ? (p->GPUVMMaxPageTableLevels + 2) * (p->HostVMMaxNonCachedPageTableLevels + 1) - 1 : p->GPUVMMaxPageTableLevels + 1) : 0);
4692                 for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
4693                         dml_float_t MaximumTvmPlus2Tr0PlusTsw;
4694                         MaximumTvmPlus2Tr0PlusTsw = (p->MaximumVStartup[j][k] - 2) * p->HTotal[k] / p->PixelClock[k] - s->MinimumTWait - s->DynamicMetadataVMExtraLatency[k];
4695                         if (MaximumTvmPlus2Tr0PlusTsw <= s->MinimumTvmPlus2Tr0 + s->PrefetchPixelLinesTime[k] / 4) {
4696                                 s->DCFCLKRequiredForPeakBandwidth = p->DCFCLKPerState;
4697                         } else {
4698                                 s->DCFCLKRequiredForPeakBandwidth = dml_max3(s->DCFCLKRequiredForPeakBandwidth,
4699                                                                                                                 2 * s->ExtraLatencyCycles / (MaximumTvmPlus2Tr0PlusTsw - s->MinimumTvmPlus2Tr0 - s->PrefetchPixelLinesTime[k] / 4),
4700                                                                                                                 (2 * s->ExtraLatencyCycles + s->PixelDCFCLKCyclesRequiredInPrefetch[k]) / (MaximumTvmPlus2Tr0PlusTsw - s->MinimumTvmPlus2Tr0));
4701                         }
4702                 }
4703                 p->DCFCLKState[j] = dml_min(p->DCFCLKPerState, 1.05 * dml_max(s->DCFCLKRequiredForAverageBandwidth, s->DCFCLKRequiredForPeakBandwidth));
4704         }
4705 }
4706
4707
4708 static dml_bool_t UnboundedRequest(enum dml_unbounded_requesting_policy UseUnboundedRequestingFinal,
4709                                                 dml_uint_t TotalNumberOfActiveDPP,
4710                                                 dml_bool_t NoChromaOrLinear,
4711                                                 enum dml_output_encoder_class Output)
4712 {
4713         dml_bool_t ret_val = false;
4714
4715         ret_val = (UseUnboundedRequestingFinal != dml_unbounded_requesting_disable
4716                         && TotalNumberOfActiveDPP == 1 && NoChromaOrLinear);
4717         if (UseUnboundedRequestingFinal == dml_unbounded_requesting_edp_only && Output != dml_edp) {
4718                 ret_val = false;
4719         }
4720         return (ret_val);
4721 }
4722
4723 static void CalculateSurfaceSizeInMall(
4724                 dml_uint_t NumberOfActiveSurfaces,
4725                 dml_uint_t MALLAllocatedForDCN,
4726                 enum dml_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
4727                 dml_bool_t DCCEnable[],
4728                 dml_bool_t ViewportStationary[],
4729                 dml_uint_t ViewportXStartY[],
4730                 dml_uint_t ViewportYStartY[],
4731                 dml_uint_t ViewportXStartC[],
4732                 dml_uint_t ViewportYStartC[],
4733                 dml_uint_t ViewportWidthY[],
4734                 dml_uint_t ViewportHeightY[],
4735                 dml_uint_t BytesPerPixelY[],
4736                 dml_uint_t ViewportWidthC[],
4737                 dml_uint_t ViewportHeightC[],
4738                 dml_uint_t BytesPerPixelC[],
4739                 dml_uint_t SurfaceWidthY[],
4740                 dml_uint_t SurfaceWidthC[],
4741                 dml_uint_t SurfaceHeightY[],
4742                 dml_uint_t SurfaceHeightC[],
4743                 dml_uint_t Read256BytesBlockWidthY[],
4744                 dml_uint_t Read256BytesBlockWidthC[],
4745                 dml_uint_t Read256BytesBlockHeightY[],
4746                 dml_uint_t Read256BytesBlockHeightC[],
4747                 dml_uint_t ReadBlockWidthY[],
4748                 dml_uint_t ReadBlockWidthC[],
4749                 dml_uint_t ReadBlockHeightY[],
4750                 dml_uint_t ReadBlockHeightC[],
4751
4752                 // Output
4753                 dml_uint_t SurfaceSizeInMALL[],
4754                 dml_bool_t *ExceededMALLSize)
4755 {
4756         dml_uint_t TotalSurfaceSizeInMALL  = 0;
4757
4758         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4759                 if (ViewportStationary[k]) {
4760                         SurfaceSizeInMALL[k] = (dml_uint_t)(dml_min(dml_ceil(SurfaceWidthY[k], ReadBlockWidthY[k]), dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + ReadBlockWidthY[k] - 1, ReadBlockWidthY[k]) - dml_floor(ViewportXStartY[k], ReadBlockWidthY[k])) *
4761                                                                         dml_min(dml_ceil(SurfaceHeightY[k], ReadBlockHeightY[k]), dml_floor(ViewportYStartY[k] + ViewportHeightY[k] + ReadBlockHeightY[k] - 1, ReadBlockHeightY[k]) - dml_floor(ViewportYStartY[k], ReadBlockHeightY[k])) *
4762                                                                         BytesPerPixelY[k]);
4763
4764                         if (ReadBlockWidthC[k] > 0) {
4765                                 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4766                                                                                 dml_min(dml_ceil(SurfaceWidthC[k], ReadBlockWidthC[k]), dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + ReadBlockWidthC[k] - 1, ReadBlockWidthC[k]) - dml_floor(ViewportXStartC[k], ReadBlockWidthC[k])) *
4767                                                                                 dml_min(dml_ceil(SurfaceHeightC[k], ReadBlockHeightC[k]), dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + ReadBlockHeightC[k] - 1, ReadBlockHeightC[k]) - dml_floor(ViewportYStartC[k], ReadBlockHeightC[k])) * BytesPerPixelC[k]);
4768                         }
4769                         if (DCCEnable[k] == true) {
4770                                 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4771                                         dml_min(dml_ceil(SurfaceWidthY[k], 8 * Read256BytesBlockWidthY[k]), dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + 8 * Read256BytesBlockWidthY[k] - 1, 8 * Read256BytesBlockWidthY[k]) - dml_floor(ViewportXStartY[k], 8 * Read256BytesBlockWidthY[k])) *
4772                                         dml_min(dml_ceil(SurfaceHeightY[k], 8 * Read256BytesBlockHeightY[k]), dml_floor(ViewportYStartY[k] + ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1, 8 * Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStartY[k], 8 * Read256BytesBlockHeightY[k])) * BytesPerPixelY[k] / 256);
4773                                 if (Read256BytesBlockWidthC[k] > 0) {
4774                                         SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4775                                                 dml_min(dml_ceil(SurfaceWidthC[k], 8 * Read256BytesBlockWidthC[k]), dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + 8 * Read256BytesBlockWidthC[k] - 1, 8 * Read256BytesBlockWidthC[k]) - dml_floor(ViewportXStartC[k], 8 * Read256BytesBlockWidthC[k])) *
4776                                                 dml_min(dml_ceil(SurfaceHeightC[k], 8 * Read256BytesBlockHeightC[k]), dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + 8 * Read256BytesBlockHeightC[k] - 1, 8 * Read256BytesBlockHeightC[k]) - dml_floor(ViewportYStartC[k], 8 * Read256BytesBlockHeightC[k])) * BytesPerPixelC[k] / 256);
4777                                 }
4778                         }
4779                 } else {
4780                         SurfaceSizeInMALL[k] = (dml_uint_t)(dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + ReadBlockWidthY[k] - 1), ReadBlockWidthY[k]) * dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + ReadBlockHeightY[k] - 1), ReadBlockHeightY[k]) * BytesPerPixelY[k]);
4781                         if (ReadBlockWidthC[k] > 0) {
4782                                 SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4783                                                                                 dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + ReadBlockWidthC[k] - 1), ReadBlockWidthC[k]) *
4784                                                                                 dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + ReadBlockHeightC[k] - 1), ReadBlockHeightC[k]) * BytesPerPixelC[k]);
4785                 }
4786                 if (DCCEnable[k] == true) {
4787                         SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4788                                         dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + 8 * Read256BytesBlockWidthY[k] - 1), 8 * Read256BytesBlockWidthY[k]) *
4789                                         dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1), 8 * Read256BytesBlockHeightY[k]) * BytesPerPixelY[k] / 256);
4790
4791                                 if (Read256BytesBlockWidthC[k] > 0) {
4792                                         SurfaceSizeInMALL[k] = (dml_uint_t)(SurfaceSizeInMALL[k] +
4793                                                 dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + 8 * Read256BytesBlockWidthC[k] - 1), 8 * Read256BytesBlockWidthC[k]) *
4794                                                 dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + 8 * Read256BytesBlockHeightC[k] - 1), 8 * Read256BytesBlockHeightC[k]) * BytesPerPixelC[k] / 256);
4795                                 }
4796                         }
4797                 }
4798         }
4799
4800         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4801                 if (UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable)
4802                         TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k];
4803         }
4804         *ExceededMALLSize = (TotalSurfaceSizeInMALL > MALLAllocatedForDCN * 1024 * 1024);
4805 } // CalculateSurfaceSizeInMall
4806
4807 static void CalculateDETBufferSize(
4808                                                 dml_uint_t DETSizeOverride[],
4809                                                 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
4810                                                 dml_bool_t ForceSingleDPP,
4811                                                 dml_uint_t NumberOfActiveSurfaces,
4812                                                 dml_bool_t UnboundedRequestEnabled,
4813                                                 dml_uint_t nomDETInKByte,
4814                                                 dml_uint_t MaxTotalDETInKByte,
4815                                                 dml_uint_t ConfigReturnBufferSizeInKByte,
4816                                                 dml_uint_t MinCompressedBufferSizeInKByte,
4817                                                 dml_uint_t ConfigReturnBufferSegmentSizeInkByte,
4818                                                 dml_uint_t CompressedBufferSegmentSizeInkByteFinal,
4819                                                 enum dml_source_format_class SourcePixelFormat[],
4820                                                 dml_float_t ReadBandwidthLuma[],
4821                                                 dml_float_t ReadBandwidthChroma[],
4822                                                 dml_uint_t RoundedUpMaxSwathSizeBytesY[],
4823                                                 dml_uint_t RoundedUpMaxSwathSizeBytesC[],
4824                                                 dml_uint_t DPPPerSurface[],
4825                                                 // Output
4826                                                 dml_uint_t DETBufferSizeInKByte[],
4827                                                 dml_uint_t *CompressedBufferSizeInkByte)
4828 {
4829         dml_uint_t DETBufferSizePoolInKByte;
4830         dml_uint_t NextDETBufferPieceInKByte;
4831         dml_bool_t DETPieceAssignedToThisSurfaceAlready[__DML_NUM_PLANES__];
4832         dml_bool_t NextPotentialSurfaceToAssignDETPieceFound;
4833         dml_uint_t NextSurfaceToAssignDETPiece;
4834         dml_float_t TotalBandwidth;
4835         dml_float_t BandwidthOfSurfacesNotAssignedDETPiece;
4836         dml_uint_t max_minDET;
4837         dml_uint_t minDET;
4838         dml_uint_t minDET_pipe;
4839
4840 #ifdef __DML_VBA_DEBUG__
4841         dml_print("DML::%s: ForceSingleDPP = %u\n", __func__, ForceSingleDPP);
4842         dml_print("DML::%s: nomDETInKByte = %u\n", __func__, nomDETInKByte);
4843         dml_print("DML::%s: NumberOfActiveSurfaces = %u\n", __func__, NumberOfActiveSurfaces);
4844         dml_print("DML::%s: UnboundedRequestEnabled = %u\n", __func__, UnboundedRequestEnabled);
4845         dml_print("DML::%s: MaxTotalDETInKByte = %u\n", __func__, MaxTotalDETInKByte);
4846         dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, ConfigReturnBufferSizeInKByte);
4847         dml_print("DML::%s: MinCompressedBufferSizeInKByte = %u\n", __func__, MinCompressedBufferSizeInKByte);
4848         dml_print("DML::%s: CompressedBufferSegmentSizeInkByteFinal = %u\n", __func__, CompressedBufferSegmentSizeInkByteFinal);
4849 #endif
4850
4851         // Note: Will use default det size if that fits 2 swaths
4852         if (UnboundedRequestEnabled) {
4853                 if (DETSizeOverride[0] > 0) {
4854                         DETBufferSizeInKByte[0] = DETSizeOverride[0];
4855                 } else {
4856                         DETBufferSizeInKByte[0] = (dml_uint_t) dml_max(128.0, dml_ceil(2.0 * ((dml_float_t) RoundedUpMaxSwathSizeBytesY[0] + (dml_float_t) RoundedUpMaxSwathSizeBytesC[0]) / 1024.0, ConfigReturnBufferSegmentSizeInkByte));
4857                 }
4858                 *CompressedBufferSizeInkByte = ConfigReturnBufferSizeInKByte - DETBufferSizeInKByte[0];
4859         } else {
4860                 DETBufferSizePoolInKByte = MaxTotalDETInKByte;
4861                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4862                         DETBufferSizeInKByte[k] = 0;
4863                         if (SourcePixelFormat[k] == dml_420_8 || SourcePixelFormat[k] == dml_420_10 || SourcePixelFormat[k] == dml_420_12) {
4864                                 max_minDET = nomDETInKByte - ConfigReturnBufferSegmentSizeInkByte;
4865                         } else {
4866                                 max_minDET = nomDETInKByte;
4867                         }
4868                         minDET = 128;
4869                         minDET_pipe = 0;
4870
4871                         // add DET resource until can hold 2 full swaths
4872                         while (minDET <= max_minDET && minDET_pipe == 0) {
4873                                 if (2.0 * ((dml_float_t) RoundedUpMaxSwathSizeBytesY[k] + (dml_float_t) RoundedUpMaxSwathSizeBytesC[k]) / 1024.0 <= minDET)
4874                                         minDET_pipe = minDET;
4875                                 minDET = minDET + ConfigReturnBufferSegmentSizeInkByte;
4876                         }
4877
4878 #ifdef __DML_VBA_DEBUG__
4879                         dml_print("DML::%s: k=%u minDET = %u\n", __func__, k, minDET);
4880                         dml_print("DML::%s: k=%u max_minDET = %u\n", __func__, k, max_minDET);
4881                         dml_print("DML::%s: k=%u minDET_pipe = %u\n", __func__, k, minDET_pipe);
4882                         dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesY = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesY[k]);
4883                         dml_print("DML::%s: k=%u RoundedUpMaxSwathSizeBytesC = %u\n", __func__, k, RoundedUpMaxSwathSizeBytesC[k]);
4884 #endif
4885
4886                         if (minDET_pipe == 0) {
4887                                 minDET_pipe = (dml_uint_t)(dml_max(128, dml_ceil(((dml_float_t)RoundedUpMaxSwathSizeBytesY[k] + (dml_float_t)RoundedUpMaxSwathSizeBytesC[k]) / 1024.0, ConfigReturnBufferSegmentSizeInkByte)));
4888 #ifdef __DML_VBA_DEBUG__
4889                                 dml_print("DML::%s: k=%u minDET_pipe = %u (assume each plane take half DET)\n", __func__, k, minDET_pipe);
4890 #endif
4891                         }
4892
4893                         if (UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) {
4894                                 DETBufferSizeInKByte[k] = 0;
4895                         } else if (DETSizeOverride[k] > 0) {
4896                                 DETBufferSizeInKByte[k] = DETSizeOverride[k];
4897                                 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - (ForceSingleDPP ? 1 : DPPPerSurface[k]) * DETSizeOverride[k];
4898                         } else if ((ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe <= DETBufferSizePoolInKByte) {
4899                                 DETBufferSizeInKByte[k] = minDET_pipe;
4900                                 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - (ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe;
4901                         }
4902
4903 #ifdef __DML_VBA_DEBUG__
4904                         dml_print("DML::%s: k=%u DPPPerSurface = %u\n", __func__, k, DPPPerSurface[k]);
4905                         dml_print("DML::%s: k=%u DETSizeOverride = %u\n", __func__, k, DETSizeOverride[k]);
4906                         dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u\n", __func__, k, DETBufferSizeInKByte[k]);
4907                         dml_print("DML::%s: DETBufferSizePoolInKByte = %u\n", __func__, DETBufferSizePoolInKByte);
4908 #endif
4909                 }
4910
4911                 TotalBandwidth = 0;
4912                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4913                         if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe)
4914                                 TotalBandwidth = TotalBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
4915                 }
4916 #ifdef __DML_VBA_DEBUG__
4917                 dml_print("DML::%s: --- Before bandwidth adjustment ---\n", __func__);
4918                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4919                         dml_print("DML::%s: k=%u DETBufferSizeInKByte   = %u\n", __func__, k, DETBufferSizeInKByte[k]);
4920                 }
4921                 dml_print("DML::%s: --- DET allocation with bandwidth ---\n", __func__);
4922 #endif
4923                 dml_print("DML::%s: TotalBandwidth = %f\n", __func__, TotalBandwidth);
4924                 BandwidthOfSurfacesNotAssignedDETPiece = TotalBandwidth;
4925                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4926
4927                         if (UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) {
4928                                 DETPieceAssignedToThisSurfaceAlready[k] = true;
4929                         } else if (DETSizeOverride[k] > 0 || (((dml_float_t) (ForceSingleDPP ? 1 : DPPPerSurface[k]) * (dml_float_t) DETBufferSizeInKByte[k] / (dml_float_t) MaxTotalDETInKByte) >= ((ReadBandwidthLuma[k] + ReadBandwidthChroma[k]) / TotalBandwidth))) {
4930                                 DETPieceAssignedToThisSurfaceAlready[k] = true;
4931                                 BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - ReadBandwidthLuma[k] - ReadBandwidthChroma[k];
4932                         } else {
4933                                 DETPieceAssignedToThisSurfaceAlready[k] = false;
4934                         }
4935 #ifdef __DML_VBA_DEBUG__
4936                         dml_print("DML::%s: k=%u DETPieceAssignedToThisSurfaceAlready = %u\n", __func__, k, DETPieceAssignedToThisSurfaceAlready[k]);
4937                         dml_print("DML::%s: k=%u BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, k, BandwidthOfSurfacesNotAssignedDETPiece);
4938 #endif
4939                 }
4940
4941                 for (dml_uint_t j = 0; j < NumberOfActiveSurfaces; ++j) {
4942                         NextPotentialSurfaceToAssignDETPieceFound = false;
4943                         NextSurfaceToAssignDETPiece = 0;
4944
4945                         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
4946 #ifdef __DML_VBA_DEBUG__
4947                                 dml_print("DML::%s: j=%u k=%u, ReadBandwidthLuma[k] = %f\n", __func__, j, k, ReadBandwidthLuma[k]);
4948                                 dml_print("DML::%s: j=%u k=%u, ReadBandwidthChroma[k] = %f\n", __func__, j, k, ReadBandwidthChroma[k]);
4949                                 dml_print("DML::%s: j=%u k=%u, ReadBandwidthLuma[Next] = %f\n", __func__, j, k, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
4950                                 dml_print("DML::%s: j=%u k=%u, ReadBandwidthChroma[Next] = %f\n", __func__, j, k, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4951                                 dml_print("DML::%s: j=%u k=%u, NextSurfaceToAssignDETPiece = %u\n", __func__, j, k, NextSurfaceToAssignDETPiece);
4952 #endif
4953                                 if (!DETPieceAssignedToThisSurfaceAlready[k] && (!NextPotentialSurfaceToAssignDETPieceFound ||
4954                                         ReadBandwidthLuma[k] + ReadBandwidthChroma[k] < ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece])) {
4955                                         NextSurfaceToAssignDETPiece = k;
4956                                         NextPotentialSurfaceToAssignDETPieceFound = true;
4957                                 }
4958 #ifdef __DML_VBA_DEBUG__
4959                                 dml_print("DML::%s: j=%u k=%u, DETPieceAssignedToThisSurfaceAlready = %u\n", __func__, j, k, DETPieceAssignedToThisSurfaceAlready[k]);
4960                                 dml_print("DML::%s: j=%u k=%u, NextPotentialSurfaceToAssignDETPieceFound = %u\n", __func__, j, k, NextPotentialSurfaceToAssignDETPieceFound);
4961 #endif
4962                         }
4963
4964                         if (NextPotentialSurfaceToAssignDETPieceFound) {
4965                                 // Note: To show the banker's rounding behavior in VBA and also the fact that the DET buffer size varies due to precision issue
4966                                 //
4967                                 //dml_float_t tmp1 =  ((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4968                                 //                         ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
4969                                 //dml_float_t tmp2 =  dml_round((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4970                                 //                         ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
4971                                 //
4972                                 //dml_print("DML::%s: j=%u, tmp1 = %f\n", __func__, j, tmp1);
4973                                 //dml_print("DML::%s: j=%u, tmp2 = %f\n", __func__, j, tmp2);
4974
4975                                 NextDETBufferPieceInKByte = (dml_uint_t)(dml_min(
4976                                                                                         dml_round((dml_float_t) DETBufferSizePoolInKByte * (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / BandwidthOfSurfacesNotAssignedDETPiece /
4977                                                                                                 ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte), true)
4978                                                                                                 * (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte,
4979                                                                                         dml_floor((dml_float_t) DETBufferSizePoolInKByte, (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * ConfigReturnBufferSegmentSizeInkByte)));
4980
4981 #ifdef __DML_VBA_DEBUG__
4982                                 dml_print("DML::%s: j=%u, DETBufferSizePoolInKByte = %u\n", __func__, j, DETBufferSizePoolInKByte);
4983                                 dml_print("DML::%s: j=%u, NextSurfaceToAssignDETPiece = %u\n", __func__, j, NextSurfaceToAssignDETPiece);
4984                                 dml_print("DML::%s: j=%u, ReadBandwidthLuma[%u] = %f\n", __func__, j, NextSurfaceToAssignDETPiece, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
4985                                 dml_print("DML::%s: j=%u, ReadBandwidthChroma[%u] = %f\n", __func__, j, NextSurfaceToAssignDETPiece, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4986                                 dml_print("DML::%s: j=%u, BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, j, BandwidthOfSurfacesNotAssignedDETPiece);
4987                                 dml_print("DML::%s: j=%u, NextDETBufferPieceInKByte = %u\n", __func__, j, NextDETBufferPieceInKByte);
4988                                 dml_print("DML::%s: j=%u, DETBufferSizeInKByte[%u] increases from %u ", __func__, j, NextSurfaceToAssignDETPiece, DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
4989 #endif
4990
4991                                 DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] = DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] + NextDETBufferPieceInKByte / (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]);
4992 #ifdef __DML_VBA_DEBUG__
4993                                 dml_print("to %u\n", DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
4994 #endif
4995
4996                                 DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - NextDETBufferPieceInKByte;
4997                                 DETPieceAssignedToThisSurfaceAlready[NextSurfaceToAssignDETPiece] = true;
4998                                 BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
4999                         }
5000                 }
5001                 *CompressedBufferSizeInkByte = MinCompressedBufferSizeInKByte;
5002         }
5003         *CompressedBufferSizeInkByte = *CompressedBufferSizeInkByte * CompressedBufferSegmentSizeInkByteFinal / ConfigReturnBufferSegmentSizeInkByte;
5004
5005 #ifdef __DML_VBA_DEBUG__
5006         dml_print("DML::%s: --- After bandwidth adjustment ---\n", __func__);
5007         dml_print("DML::%s: CompressedBufferSizeInkByte = %u\n", __func__, *CompressedBufferSizeInkByte);
5008         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5009                 dml_print("DML::%s: k=%u DETBufferSizeInKByte = %u (TotalReadBandWidth=%f)\n", __func__, k, DETBufferSizeInKByte[k], ReadBandwidthLuma[k] + ReadBandwidthChroma[k]);
5010         }
5011 #endif
5012 } // CalculateDETBufferSize
5013
5014
5015 /// @brief Calculate the bound for return buffer sizing
5016 static void CalculateMaxDETAndMinCompressedBufferSize(
5017                 dml_uint_t  ConfigReturnBufferSizeInKByte,
5018                 dml_uint_t  ConfigReturnBufferSegmentSizeInKByte,
5019                 dml_uint_t  ROBBufferSizeInKByte,
5020                 dml_uint_t MaxNumDPP,
5021                 dml_bool_t nomDETInKByteOverrideEnable, // VBA_DELTA, allow DV to override default DET size
5022                 dml_uint_t nomDETInKByteOverrideValue,  // VBA_DELTA
5023
5024                 // Output
5025                 dml_uint_t *MaxTotalDETInKByte,
5026                 dml_uint_t *nomDETInKByte,
5027                 dml_uint_t *MinCompressedBufferSizeInKByte)
5028 {
5029         *MaxTotalDETInKByte = ConfigReturnBufferSizeInKByte - ConfigReturnBufferSegmentSizeInKByte;
5030         *nomDETInKByte = (dml_uint_t)(dml_floor((dml_float_t) *MaxTotalDETInKByte / (dml_float_t) MaxNumDPP, ConfigReturnBufferSegmentSizeInKByte));
5031         *MinCompressedBufferSizeInKByte = ConfigReturnBufferSizeInKByte - *MaxTotalDETInKByte;
5032
5033 #ifdef __DML_VBA_DEBUG__
5034         dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %u\n", __func__, ConfigReturnBufferSizeInKByte);
5035         dml_print("DML::%s: ROBBufferSizeInKByte = %u\n", __func__, ROBBufferSizeInKByte);
5036         dml_print("DML::%s: MaxNumDPP = %u\n", __func__, MaxNumDPP);
5037         dml_print("DML::%s: MaxTotalDETInKByte = %u\n", __func__, *MaxTotalDETInKByte);
5038         dml_print("DML::%s: nomDETInKByte = %u\n", __func__, *nomDETInKByte);
5039         dml_print("DML::%s: MinCompressedBufferSizeInKByte = %u\n", __func__, *MinCompressedBufferSizeInKByte);
5040 #endif
5041
5042         if (nomDETInKByteOverrideEnable) {
5043                 *nomDETInKByte = nomDETInKByteOverrideValue;
5044                 dml_print("DML::%s: nomDETInKByte = %u (overrided)\n", __func__, *nomDETInKByte);
5045         }
5046 } // CalculateMaxDETAndMinCompressedBufferSize
5047
5048 /// @brief Calculate all the RQ request attributes, like row height and # swath
5049 static void CalculateVMRowAndSwath(struct display_mode_lib_scratch_st *scratch,
5050                 struct CalculateVMRowAndSwath_params_st *p)
5051 {
5052         struct CalculateVMRowAndSwath_locals_st *s = &scratch->CalculateVMRowAndSwath_locals;
5053
5054         s->HostVMDynamicLevels = CalculateHostVMDynamicLevels(p->GPUVMEnable, p->HostVMEnable, p->HostVMMinPageSize, p->HostVMMaxNonCachedPageTableLevels);
5055
5056         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5057                 if (p->HostVMEnable == true) {
5058                         p->vm_group_bytes[k] = 512;
5059                         p->dpte_group_bytes[k] = 512;
5060                 } else if (p->GPUVMEnable == true) {
5061                         p->vm_group_bytes[k] = 2048;
5062                         if (p->GPUVMMinPageSizeKBytes[k] >= 64 && dml_is_vertical_rotation(p->myPipe[k].SourceScan)) {
5063                                 p->dpte_group_bytes[k] = 512;
5064                         } else {
5065                                 p->dpte_group_bytes[k] = 2048;
5066                         }
5067                 } else {
5068                         p->vm_group_bytes[k] = 0;
5069                         p->dpte_group_bytes[k] = 0;
5070                 }
5071
5072                 if (p->myPipe[k].SourcePixelFormat == dml_420_8 || p->myPipe[k].SourcePixelFormat == dml_420_10 ||
5073                         p->myPipe[k].SourcePixelFormat == dml_420_12 || p->myPipe[k].SourcePixelFormat == dml_rgbe_alpha) {
5074                         if ((p->myPipe[k].SourcePixelFormat == dml_420_10 || p->myPipe[k].SourcePixelFormat == dml_420_12) && !dml_is_vertical_rotation(p->myPipe[k].SourceScan)) {
5075                                 s->PTEBufferSizeInRequestsForLuma[k] = (p->PTEBufferSizeInRequestsLuma + p->PTEBufferSizeInRequestsChroma) / 2;
5076                                 s->PTEBufferSizeInRequestsForChroma[k] = s->PTEBufferSizeInRequestsForLuma[k];
5077                         } else {
5078                                 s->PTEBufferSizeInRequestsForLuma[k] = p->PTEBufferSizeInRequestsLuma;
5079                                 s->PTEBufferSizeInRequestsForChroma[k] = p->PTEBufferSizeInRequestsChroma;
5080                         }
5081
5082                         s->PDEAndMetaPTEBytesFrameC = CalculateVMAndRowBytes(
5083                                 p->myPipe[k].ViewportStationary,
5084                                 p->myPipe[k].DCCEnable,
5085                                 p->myPipe[k].DPPPerSurface,
5086                                 p->myPipe[k].BlockHeight256BytesC,
5087                                 p->myPipe[k].BlockWidth256BytesC,
5088                                 p->myPipe[k].SourcePixelFormat,
5089                                 p->myPipe[k].SurfaceTiling,
5090                                 p->myPipe[k].BytePerPixelC,
5091                                 p->myPipe[k].SourceScan,
5092                                 p->SwathWidthC[k],
5093                                 p->myPipe[k].ViewportHeightChroma,
5094                                 p->myPipe[k].ViewportXStartC,
5095                                 p->myPipe[k].ViewportYStartC,
5096                                 p->GPUVMEnable,
5097                                 p->GPUVMMaxPageTableLevels,
5098                                 p->GPUVMMinPageSizeKBytes[k],
5099                                 s->PTEBufferSizeInRequestsForChroma[k],
5100                                 p->myPipe[k].PitchC,
5101                                 p->myPipe[k].DCCMetaPitchC,
5102                                 p->myPipe[k].BlockWidthC,
5103                                 p->myPipe[k].BlockHeightC,
5104
5105                                 // Output
5106                                 &s->MetaRowByteC[k],
5107                                 &s->PixelPTEBytesPerRowC[k],
5108                                 &s->PixelPTEBytesPerRowStorageC[k],
5109                                 &p->dpte_row_width_chroma_ub[k],
5110                                 &p->dpte_row_height_chroma[k],
5111                                 &p->dpte_row_height_linear_chroma[k],
5112                                 &s->PixelPTEBytesPerRowC_one_row_per_frame[k],
5113                                 &s->dpte_row_width_chroma_ub_one_row_per_frame[k],
5114                                 &s->dpte_row_height_chroma_one_row_per_frame[k],
5115                                 &p->meta_req_width_chroma[k],
5116                                 &p->meta_req_height_chroma[k],
5117                                 &p->meta_row_width_chroma[k],
5118                                 &p->meta_row_height_chroma[k],
5119                                 &p->PixelPTEReqWidthC[k],
5120                                 &p->PixelPTEReqHeightC[k],
5121                                 &p->PTERequestSizeC[k],
5122                                 &p->dpde0_bytes_per_frame_ub_c[k],
5123                                 &p->meta_pte_bytes_per_frame_ub_c[k]);
5124
5125                         p->PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines (
5126                                 p->myPipe[k].VRatioChroma,
5127                                 p->myPipe[k].VTapsChroma,
5128                                 p->myPipe[k].InterlaceEnable,
5129                                 p->myPipe[k].ProgressiveToInterlaceUnitInOPP,
5130                                 p->myPipe[k].SwathHeightC,
5131                                 p->myPipe[k].SourceScan,
5132                                 p->myPipe[k].ViewportStationary,
5133                                 p->SwathWidthC[k],
5134                                 p->myPipe[k].ViewportHeightChroma,
5135                                 p->myPipe[k].ViewportXStartC,
5136                                 p->myPipe[k].ViewportYStartC,
5137
5138                                 // Output
5139                                 &p->VInitPreFillC[k],
5140                                 &p->MaxNumSwathC[k]);
5141                 } else {
5142                         s->PTEBufferSizeInRequestsForLuma[k] = p->PTEBufferSizeInRequestsLuma + p->PTEBufferSizeInRequestsChroma;
5143                         s->PTEBufferSizeInRequestsForChroma[k] = 0;
5144                         s->PixelPTEBytesPerRowC[k] = 0;
5145                         s->PixelPTEBytesPerRowStorageC[k] = 0;
5146                         s->PDEAndMetaPTEBytesFrameC = 0;
5147                         s->MetaRowByteC[k] = 0;
5148                         p->MaxNumSwathC[k] = 0;
5149                         p->PrefetchSourceLinesC[k] = 0;
5150                         s->dpte_row_height_chroma_one_row_per_frame[k] = 0;
5151                         s->dpte_row_width_chroma_ub_one_row_per_frame[k] = 0;
5152                         s->PixelPTEBytesPerRowC_one_row_per_frame[k] = 0;
5153                 }
5154
5155                 s->PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
5156                         p->myPipe[k].ViewportStationary,
5157                         p->myPipe[k].DCCEnable,
5158                         p->myPipe[k].DPPPerSurface,
5159                         p->myPipe[k].BlockHeight256BytesY,
5160                         p->myPipe[k].BlockWidth256BytesY,
5161                         p->myPipe[k].SourcePixelFormat,
5162                         p->myPipe[k].SurfaceTiling,
5163                         p->myPipe[k].BytePerPixelY,
5164                         p->myPipe[k].SourceScan,
5165                         p->SwathWidthY[k],
5166                         p->myPipe[k].ViewportHeight,
5167                         p->myPipe[k].ViewportXStart,
5168                         p->myPipe[k].ViewportYStart,
5169                         p->GPUVMEnable,
5170                         p->GPUVMMaxPageTableLevels,
5171                         p->GPUVMMinPageSizeKBytes[k],
5172                         s->PTEBufferSizeInRequestsForLuma[k],
5173                         p->myPipe[k].PitchY,
5174                         p->myPipe[k].DCCMetaPitchY,
5175                         p->myPipe[k].BlockWidthY,
5176                         p->myPipe[k].BlockHeightY,
5177
5178                         // Output
5179                         &s->MetaRowByteY[k],
5180                         &s->PixelPTEBytesPerRowY[k],
5181                         &s->PixelPTEBytesPerRowStorageY[k],
5182                         &p->dpte_row_width_luma_ub[k],
5183                         &p->dpte_row_height_luma[k],
5184                         &p->dpte_row_height_linear_luma[k],
5185                         &s->PixelPTEBytesPerRowY_one_row_per_frame[k],
5186                         &s->dpte_row_width_luma_ub_one_row_per_frame[k],
5187                         &s->dpte_row_height_luma_one_row_per_frame[k],
5188                         &p->meta_req_width[k],
5189                         &p->meta_req_height[k],
5190                         &p->meta_row_width[k],
5191                         &p->meta_row_height[k],
5192                         &p->PixelPTEReqWidthY[k],
5193                         &p->PixelPTEReqHeightY[k],
5194                         &p->PTERequestSizeY[k],
5195                         &p->dpde0_bytes_per_frame_ub_l[k],
5196                         &p->meta_pte_bytes_per_frame_ub_l[k]);
5197
5198                         p->PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
5199                         p->myPipe[k].VRatio,
5200                         p->myPipe[k].VTaps,
5201                         p->myPipe[k].InterlaceEnable,
5202                         p->myPipe[k].ProgressiveToInterlaceUnitInOPP,
5203                         p->myPipe[k].SwathHeightY,
5204                         p->myPipe[k].SourceScan,
5205                         p->myPipe[k].ViewportStationary,
5206                         p->SwathWidthY[k],
5207                         p->myPipe[k].ViewportHeight,
5208                         p->myPipe[k].ViewportXStart,
5209                         p->myPipe[k].ViewportYStart,
5210
5211                         // Output
5212                         &p->VInitPreFillY[k],
5213                         &p->MaxNumSwathY[k]);
5214
5215                 p->PDEAndMetaPTEBytesFrame[k] = (s->PDEAndMetaPTEBytesFrameY + s->PDEAndMetaPTEBytesFrameC) * (1 + 8 * s->HostVMDynamicLevels);
5216                 p->MetaRowByte[k] = s->MetaRowByteY[k] + s->MetaRowByteC[k];
5217
5218                 if (s->PixelPTEBytesPerRowStorageY[k] <= 64 * s->PTEBufferSizeInRequestsForLuma[k] && s->PixelPTEBytesPerRowStorageC[k] <= 64 * s->PTEBufferSizeInRequestsForChroma[k]) {
5219                         p->PTEBufferSizeNotExceeded[k] = true;
5220                 } else {
5221                         p->PTEBufferSizeNotExceeded[k] = false;
5222 #ifdef __DML_VBA_DEBUG__
5223                         dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY = %u\n", __func__, k, s->PixelPTEBytesPerRowY[k]);
5224                         dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC = %u\n", __func__, k, s->PixelPTEBytesPerRowC[k]);
5225                         dml_print("DML::%s: k=%u, PixelPTEBytesPerRowStorageY = %u\n", __func__, k, s->PixelPTEBytesPerRowStorageY[k]);
5226                         dml_print("DML::%s: k=%u, PixelPTEBytesPerRowStorageC = %u\n", __func__, k, s->PixelPTEBytesPerRowStorageC[k]);
5227                         dml_print("DML::%s: k=%u, PTEBufferSizeInRequestsForLuma = %u\n", __func__, k, s->PTEBufferSizeInRequestsForLuma[k]);
5228                         dml_print("DML::%s: k=%u, PTEBufferSizeInRequestsForChroma = %u\n", __func__, k, s->PTEBufferSizeInRequestsForChroma[k]);
5229                         dml_print("DML::%s: k=%u, PTEBufferSizeNotExceeded          = %u\n",  __func__, k, p->PTEBufferSizeNotExceeded[k]);
5230 #endif
5231                 }
5232                 s->one_row_per_frame_fits_in_buffer[k] = (s->PixelPTEBytesPerRowY_one_row_per_frame[k] <= 64 * 2 * s->PTEBufferSizeInRequestsForLuma[k] &&
5233                         s->PixelPTEBytesPerRowC_one_row_per_frame[k] <= 64 * 2 * s->PTEBufferSizeInRequestsForChroma[k]);
5234
5235 #ifdef __DML_VBA_DEBUG__
5236                 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrame = %u\n", __func__, k, p->PDEAndMetaPTEBytesFrame[k]);
5237                 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrameY = %u\n", __func__, k, s->PDEAndMetaPTEBytesFrameY);
5238                 dml_print("DML::%s: k=%u, PDEAndMetaPTEBytesFrameC = %u\n", __func__, k, s->PDEAndMetaPTEBytesFrameC);
5239                 dml_print("DML::%s: k=%u, HostVMDynamicLevels = %u\n", __func__, k, s->HostVMDynamicLevels);
5240                 dml_print("DML::%s: k=%u, one_row_per_frame_fits_in_buffer = %u\n", __func__, k, s->one_row_per_frame_fits_in_buffer[k]);
5241                 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY_one_row_per_frame = %u\n", __func__, k, s->PixelPTEBytesPerRowY_one_row_per_frame[k]);
5242                 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC_one_row_per_frame    = %u\n",  __func__, k, s->PixelPTEBytesPerRowC_one_row_per_frame[k]);
5243 #endif
5244         }
5245
5246         CalculateMALLUseForStaticScreen(
5247                 p->NumberOfActiveSurfaces,
5248                 p->MALLAllocatedForDCN,
5249                 p->UseMALLForStaticScreen,   // mode
5250                 p->SurfaceSizeInMALL,
5251                 s->one_row_per_frame_fits_in_buffer,
5252                 // Output
5253                 p->UsesMALLForStaticScreen); // boolen
5254
5255         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5256                 if (p->PTEBufferModeOverrideEn[k] == 1) {
5257                         p->PTE_BUFFER_MODE[k] = p->PTEBufferModeOverrideVal[k];
5258                 }
5259                 p->PTE_BUFFER_MODE[k] = p->myPipe[k].FORCE_ONE_ROW_FOR_FRAME || p->UsesMALLForStaticScreen[k] || (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) ||
5260                         (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) || (p->GPUVMMinPageSizeKBytes[k] > 64);
5261                 p->BIGK_FRAGMENT_SIZE[k] = (dml_uint_t)(dml_log2(p->GPUVMMinPageSizeKBytes[k] * 1024) - 12);
5262         }
5263
5264         for (dml_uint_t k = 0; k < p->NumberOfActiveSurfaces; ++k) {
5265 #ifdef __DML_VBA_DEBUG__
5266                 dml_print("DML::%s: k=%u, SurfaceSizeInMALL         = %u\n",  __func__, k, p->SurfaceSizeInMALL[k]);
5267                 dml_print("DML::%s: k=%u, UsesMALLForStaticScreen   = %u\n",  __func__, k, p->UsesMALLForStaticScreen[k]);
5268 #endif
5269                 p->use_one_row_for_frame[k] = p->myPipe[k].FORCE_ONE_ROW_FOR_FRAME || p->UsesMALLForStaticScreen[k] || (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) ||
5270                                                                         (p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe) || (p->GPUVMMinPageSizeKBytes[k] > 64 && dml_is_vertical_rotation(p->myPipe[k].SourceScan));
5271
5272                 p->use_one_row_for_frame_flip[k] = p->use_one_row_for_frame[k] && !(p->UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame);
5273
5274                 if (p->use_one_row_for_frame[k]) {
5275                         p->dpte_row_height_luma[k] = s->dpte_row_height_luma_one_row_per_frame[k];
5276                         p->dpte_row_width_luma_ub[k] = s->dpte_row_width_luma_ub_one_row_per_frame[k];
5277                         s->PixelPTEBytesPerRowY[k] = s->PixelPTEBytesPerRowY_one_row_per_frame[k];
5278                         p->dpte_row_height_chroma[k] = s->dpte_row_height_chroma_one_row_per_frame[k];
5279                         p->dpte_row_width_chroma_ub[k] = s->dpte_row_width_chroma_ub_one_row_per_frame[k];
5280                         s->PixelPTEBytesPerRowC[k] = s->PixelPTEBytesPerRowC_one_row_per_frame[k];
5281                         p->PTEBufferSizeNotExceeded[k] = s->one_row_per_frame_fits_in_buffer[k];
5282                 }
5283
5284                 if (p->MetaRowByte[k] <= p->DCCMetaBufferSizeBytes) {
5285                         p->DCCMetaBufferSizeNotExceeded[k] = true;
5286                 } else {
5287                         p->DCCMetaBufferSizeNotExceeded[k] = false;
5288
5289 #ifdef __DML_VBA_DEBUG__
5290                         dml_print("DML::%s: k=%u, MetaRowByte                   = %u\n",  __func__, k, p->MetaRowByte[k]);
5291                         dml_print("DML::%s: k=%u, DCCMetaBufferSizeBytes        = %u\n",  __func__, k, p->DCCMetaBufferSizeBytes);
5292                         dml_print("DML::%s: k=%u, DCCMetaBufferSizeNotExceeded  = %u\n",  __func__, k, p->DCCMetaBufferSizeNotExceeded[k]);
5293 #endif
5294                 }
5295                 s->PixelPTEBytesPerRowY[k] = s->PixelPTEBytesPerRowY[k] * (1 + 8 * s->HostVMDynamicLevels);
5296                 s->PixelPTEBytesPerRowC[k] = s->PixelPTEBytesPerRowC[k] * (1 + 8 * s->HostVMDynamicLevels);
5297                 p->PixelPTEBytesPerRow[k] = s->PixelPTEBytesPerRowY[k] + s->PixelPTEBytesPerRowC[k];
5298                 if (p->use_one_row_for_frame[k])
5299                         p->PixelPTEBytesPerRow[k] = p->PixelPTEBytesPerRow[k] / 2;
5300
5301                 CalculateRowBandwidth(
5302                         p->GPUVMEnable,
5303                         p->myPipe[k].SourcePixelFormat,
5304                         p->myPipe[k].VRatio,
5305                         p->myPipe[k].VRatioChroma,
5306                         p->myPipe[k].DCCEnable,
5307                         p->myPipe[k].HTotal / p->myPipe[k].PixelClock,
5308                         s->MetaRowByteY[k],
5309                         s->MetaRowByteC[k],
5310                         p->meta_row_height[k],
5311                         p->meta_row_height_chroma[k],
5312                         s->PixelPTEBytesPerRowY[k],
5313                         s->PixelPTEBytesPerRowC[k],
5314                         p->dpte_row_height_luma[k],
5315                         p->dpte_row_height_chroma[k],
5316
5317                         // Output
5318                         &p->meta_row_bw[k],
5319                         &p->dpte_row_bw[k]);
5320 #ifdef __DML_VBA_DEBUG__
5321                 dml_print("DML::%s: k=%u, use_one_row_for_frame = %u\n", __func__, k, p->use_one_row_for_frame[k]);
5322                 dml_print("DML::%s: k=%u, use_one_row_for_frame_flip = %u\n", __func__, k, p->use_one_row_for_frame_flip[k]);
5323                 dml_print("DML::%s: k=%u, UseMALLForPStateChange = %u\n", __func__, k, p->UseMALLForPStateChange[k]);
5324                 dml_print("DML::%s: k=%u, dpte_row_height_luma = %u\n", __func__, k, p->dpte_row_height_luma[k]);
5325                 dml_print("DML::%s: k=%u, dpte_row_width_luma_ub = %u\n", __func__, k, p->dpte_row_width_luma_ub[k]);
5326                 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowY = %u\n", __func__, k, s->PixelPTEBytesPerRowY[k]);
5327                 dml_print("DML::%s: k=%u, dpte_row_height_chroma = %u\n", __func__, k, p->dpte_row_height_chroma[k]);
5328                 dml_print("DML::%s: k=%u, dpte_row_width_chroma_ub = %u\n", __func__, k, p->dpte_row_width_chroma_ub[k]);
5329                 dml_print("DML::%s: k=%u, PixelPTEBytesPerRowC = %u\n", __func__, k, s->PixelPTEBytesPerRowC[k]);
5330                 dml_print("DML::%s: k=%u, PixelPTEBytesPerRow = %u\n", __func__, k, p->PixelPTEBytesPerRow[k]);
5331                 dml_print("DML::%s: k=%u, PTEBufferSizeNotExceeded = %u\n", __func__, k, p->PTEBufferSizeNotExceeded[k]);
5332                 dml_print("DML::%s: k=%u, PTE_BUFFER_MODE = %u\n", __func__, k, p->PTE_BUFFER_MODE[k]);
5333                 dml_print("DML::%s: k=%u, BIGK_FRAGMENT_SIZE     = %u\n", __func__, k, p->BIGK_FRAGMENT_SIZE[k]);
5334 #endif
5335         }
5336 }
5337
5338 static void CalculateOutputLink(
5339                 dml_float_t PHYCLKPerState,
5340                 dml_float_t PHYCLKD18PerState,
5341                 dml_float_t PHYCLKD32PerState,
5342                 dml_float_t Downspreading,
5343                 dml_bool_t IsMainSurfaceUsingTheIndicatedTiming,
5344                 enum dml_output_encoder_class Output,
5345                 enum dml_output_format_class OutputFormat,
5346                 dml_uint_t HTotal,
5347                 dml_uint_t HActive,
5348                 dml_float_t PixelClockBackEnd,
5349                 dml_float_t ForcedOutputLinkBPP,
5350                 dml_uint_t DSCInputBitPerComponent,
5351                 dml_uint_t NumberOfDSCSlices,
5352                 dml_float_t AudioSampleRate,
5353                 dml_uint_t AudioSampleLayout,
5354                 enum dml_odm_mode ODMModeNoDSC,
5355                 enum dml_odm_mode ODMModeDSC,
5356                 enum dml_dsc_enable DSCEnable,
5357                 dml_uint_t OutputLinkDPLanes,
5358                 enum dml_output_link_dp_rate OutputLinkDPRate,
5359
5360                 // Output
5361                 dml_bool_t *RequiresDSC,
5362                 dml_bool_t *RequiresFEC,
5363                 dml_float_t *OutBpp,
5364                 enum dml_output_type_and_rate__type *OutputType,
5365                 enum dml_output_type_and_rate__rate *OutputRate,
5366                 dml_uint_t *RequiredSlots)
5367 {
5368         dml_bool_t LinkDSCEnable;
5369         dml_uint_t dummy;
5370         *RequiresDSC = false;
5371         *RequiresFEC = false;
5372         *OutBpp = 0;
5373
5374         *OutputType = dml_output_type_unknown;
5375         *OutputRate = dml_output_rate_unknown;
5376
5377         if (IsMainSurfaceUsingTheIndicatedTiming) {
5378                 if (Output == dml_hdmi) {
5379                         *RequiresDSC = false;
5380                         *RequiresFEC = false;
5381                         *OutBpp = TruncToValidBPP(dml_min(600, PHYCLKPerState) * 10, 3, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, false, Output,
5382                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, &dummy);
5383                         //OutputTypeAndRate = "HDMI";
5384                         *OutputType = dml_output_type_hdmi;
5385
5386                 } else if (Output == dml_dp || Output == dml_dp2p0 || Output == dml_edp) {
5387                         if (DSCEnable == dml_dsc_enable) {
5388                                 *RequiresDSC = true;
5389                                 LinkDSCEnable = true;
5390                                 if (Output == dml_dp || Output == dml_dp2p0) {
5391                                         *RequiresFEC = true;
5392                                 } else {
5393                                         *RequiresFEC = false;
5394                                 }
5395                         } else {
5396                                 *RequiresDSC = false;
5397                                 LinkDSCEnable = false;
5398                                 if (Output == dml_dp2p0) {
5399                                         *RequiresFEC = true;
5400                                 } else {
5401                                         *RequiresFEC = false;
5402                                 }
5403                         }
5404                         if (Output == dml_dp2p0) {
5405                                 *OutBpp = 0;
5406                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr10) && PHYCLKD32PerState >= 10000 / 32) {
5407                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 10000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5408                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5409                                         if (*OutBpp == 0 && PHYCLKD32PerState < 13500 / 32 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5410                                                 *RequiresDSC = true;
5411                                                 LinkDSCEnable = true;
5412                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 10000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5413                                                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5414                                         }
5415                                         //OutputTypeAndRate = Output & " UHBR10";
5416                                         *OutputType = dml_output_type_dp2p0;
5417                                         *OutputRate = dml_output_rate_dp_rate_uhbr10;
5418                                 }
5419                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr13p5) && *OutBpp == 0 && PHYCLKD32PerState >= 13500 / 32) {
5420                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 13500, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5421                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5422
5423                                         if (*OutBpp == 0 && PHYCLKD32PerState < 20000 / 32 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5424                                                 *RequiresDSC = true;
5425                                                 LinkDSCEnable = true;
5426                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 13500, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5427                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5428                                         }
5429                                         //OutputTypeAndRate = Output & " UHBR13p5";
5430                                         *OutputType = dml_output_type_dp2p0;
5431                                         *OutputRate = dml_output_rate_dp_rate_uhbr13p5;
5432                                 }
5433                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_uhbr20) && *OutBpp == 0 && PHYCLKD32PerState >= 20000 / 32) {
5434                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 20000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5435                                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5436                                         if (*OutBpp == 0 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5437                                                 *RequiresDSC = true;
5438                                                 LinkDSCEnable = true;
5439                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 20000, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5440                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5441                                         }
5442                                         //OutputTypeAndRate = Output & " UHBR20";
5443                                         *OutputType = dml_output_type_dp2p0;
5444                                         *OutputRate = dml_output_rate_dp_rate_uhbr20;
5445                                 }
5446                         } else { // output is dp or edp
5447                                 *OutBpp = 0;
5448                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr) && PHYCLKPerState >= 270) {
5449                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 2700, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5450                                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5451                                         if (*OutBpp == 0 && PHYCLKPerState < 540 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5452                                                 *RequiresDSC = true;
5453                                                 LinkDSCEnable = true;
5454                                                 if (Output == dml_dp) {
5455                                                         *RequiresFEC = true;
5456                                                 }
5457                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 2700, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5458                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5459                                         }
5460                                         //OutputTypeAndRate = Output & " HBR";
5461                                         *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5462                                         *OutputRate = dml_output_rate_dp_rate_hbr;
5463                                 }
5464                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr2) && *OutBpp == 0 && PHYCLKPerState >= 540) {
5465                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 5400, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5466                                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5467
5468                                         if (*OutBpp == 0 && PHYCLKPerState < 810 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5469                                                 *RequiresDSC = true;
5470                                                 LinkDSCEnable = true;
5471                                                 if (Output == dml_dp) {
5472                                                         *RequiresFEC = true;
5473                                                 }
5474                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 5400, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5475                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5476                                         }
5477                                         //OutputTypeAndRate = Output & " HBR2";
5478                                         *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5479                                         *OutputRate = dml_output_rate_dp_rate_hbr2;
5480                                 }
5481                                 if ((OutputLinkDPRate == dml_dp_rate_na || OutputLinkDPRate == dml_dp_rate_hbr3) && *OutBpp == 0 && PHYCLKPerState >= 810) { // VBA_ERROR, vba code doesn't have hbr3 check
5482                                         *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 8100, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5483                                                                                         OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5484
5485                                         if (*OutBpp == 0 && DSCEnable == dml_dsc_enable_if_necessary && ForcedOutputLinkBPP == 0) {
5486                                                 *RequiresDSC = true;
5487                                                 LinkDSCEnable = true;
5488                                                 if (Output == dml_dp) {
5489                                                         *RequiresFEC = true;
5490                                                 }
5491                                                 *OutBpp = TruncToValidBPP((1 - Downspreading / 100) * 8100, OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, ForcedOutputLinkBPP, LinkDSCEnable, Output,
5492                                                                                                 OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, (dml_uint_t)AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
5493                                         }
5494                                         //OutputTypeAndRate = Output & " HBR3";
5495                                         *OutputType = (Output == dml_dp) ? dml_output_type_dp : dml_output_type_edp;
5496                                         *OutputRate = dml_output_rate_dp_rate_hbr3;
5497                                 }
5498                         }
5499                 }
5500         }
5501 }
5502
5503 /// @brief Determine the ODM mode and number of DPP used per plane based on dispclk, dsc usage, odm usage policy
5504 static void CalculateODMMode(
5505                 dml_uint_t MaximumPixelsPerLinePerDSCUnit,
5506                 dml_uint_t HActive,
5507                 enum dml_output_encoder_class Output,
5508                 enum dml_output_format_class OutputFormat,
5509                 enum dml_odm_use_policy ODMUse,
5510                 dml_float_t StateDispclk,
5511                 dml_float_t MaxDispclk,
5512                 dml_bool_t DSCEnable,
5513                 dml_uint_t TotalNumberOfActiveDPP,
5514                 dml_uint_t MaxNumDPP,
5515                 dml_float_t PixelClock,
5516                 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5517                 dml_float_t DISPCLKRampingMargin,
5518                 dml_float_t DISPCLKDPPCLKVCOSpeed,
5519
5520                 // Output
5521                 dml_bool_t *TotalAvailablePipesSupport,
5522                 dml_uint_t *NumberOfDPP,
5523                 enum dml_odm_mode *ODMMode,
5524                 dml_float_t *RequiredDISPCLKPerSurface)
5525 {
5526
5527         dml_float_t SurfaceRequiredDISPCLKWithoutODMCombine;
5528         dml_float_t SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
5529         dml_float_t SurfaceRequiredDISPCLKWithODMCombineFourToOne;
5530
5531         SurfaceRequiredDISPCLKWithoutODMCombine = CalculateRequiredDispclk(dml_odm_mode_bypass, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5532         SurfaceRequiredDISPCLKWithODMCombineTwoToOne = CalculateRequiredDispclk(dml_odm_mode_combine_2to1, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5533         SurfaceRequiredDISPCLKWithODMCombineFourToOne = CalculateRequiredDispclk(dml_odm_mode_combine_4to1, PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, MaxDispclk);
5534         *TotalAvailablePipesSupport = true;
5535
5536         if (OutputFormat == dml_420) {
5537                 if (HActive > 4 * DML2_MAX_FMT_420_BUFFER_WIDTH)
5538                         *TotalAvailablePipesSupport = false;
5539                 else if (HActive > 2 * DML2_MAX_FMT_420_BUFFER_WIDTH)
5540                         ODMUse = dml_odm_use_policy_combine_4to1;
5541                 else if (HActive > DML2_MAX_FMT_420_BUFFER_WIDTH)
5542                         ODMUse = dml_odm_use_policy_combine_2to1;
5543                 if (Output == dml_hdmi && ODMUse == dml_odm_use_policy_combine_2to1)
5544                         *TotalAvailablePipesSupport = false;
5545                 if ((Output == dml_hdmi || Output == dml_dp || Output == dml_edp) && ODMUse == dml_odm_use_policy_combine_4to1)
5546                         *TotalAvailablePipesSupport = false;
5547         }
5548
5549         if (ODMUse == dml_odm_use_policy_bypass || ODMUse == dml_odm_use_policy_combine_as_needed)
5550                 *ODMMode = dml_odm_mode_bypass;
5551         else if (ODMUse == dml_odm_use_policy_combine_2to1)
5552                 *ODMMode = dml_odm_mode_combine_2to1;
5553         else if (ODMUse == dml_odm_use_policy_combine_4to1)
5554                 *ODMMode = dml_odm_mode_combine_4to1;
5555         else if (ODMUse == dml_odm_use_policy_split_1to2)
5556                 *ODMMode = dml_odm_mode_split_1to2;
5557         else if (ODMUse == dml_odm_use_policy_mso_1to2)
5558                 *ODMMode = dml_odm_mode_mso_1to2;
5559         else if (ODMUse == dml_odm_use_policy_mso_1to4)
5560                 *ODMMode = dml_odm_mode_mso_1to4;
5561
5562         *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithoutODMCombine;
5563         *NumberOfDPP = 0;
5564
5565         if (!(Output == dml_hdmi || Output == dml_dp || Output == dml_edp) && (ODMUse == dml_odm_use_policy_combine_4to1 || (ODMUse == dml_odm_use_policy_combine_as_needed &&
5566                 (SurfaceRequiredDISPCLKWithODMCombineTwoToOne > StateDispclk || (DSCEnable && (HActive > 2 * MaximumPixelsPerLinePerDSCUnit)))))) {
5567                 if (TotalNumberOfActiveDPP + 4 <= MaxNumDPP) {
5568                         *ODMMode = dml_odm_mode_combine_4to1;
5569                         *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineFourToOne;
5570                         *NumberOfDPP = 4;
5571                 } else {
5572                         *TotalAvailablePipesSupport = false;
5573                 }
5574         } else if (Output != dml_hdmi && (ODMUse == dml_odm_use_policy_combine_2to1 || (ODMUse == dml_odm_use_policy_combine_as_needed &&
5575                                 ((SurfaceRequiredDISPCLKWithoutODMCombine > StateDispclk && SurfaceRequiredDISPCLKWithODMCombineTwoToOne <= StateDispclk) ||
5576                                 (DSCEnable && (HActive > MaximumPixelsPerLinePerDSCUnit)))))) {
5577                 if (TotalNumberOfActiveDPP + 2 <= MaxNumDPP) {
5578                         *ODMMode = dml_odm_mode_combine_2to1;
5579                         *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
5580                         *NumberOfDPP = 2;
5581                 } else {
5582                         *TotalAvailablePipesSupport = false;
5583                 }
5584         } else {
5585                 if (TotalNumberOfActiveDPP + 1 <= MaxNumDPP) {
5586                         *NumberOfDPP = 1;
5587                 } else {
5588                         *TotalAvailablePipesSupport = false;
5589                 }
5590         }
5591 }
5592
5593 /// @brief Calculate the required DISPCLK given the odm mode and pixclk
5594 static dml_float_t CalculateRequiredDispclk(
5595                 enum dml_odm_mode ODMMode,
5596                 dml_float_t PixelClock,
5597                 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5598                 dml_float_t DISPCLKRampingMargin,
5599                 dml_float_t DISPCLKDPPCLKVCOSpeed,
5600                 dml_float_t MaxDispclk)
5601 {
5602         dml_float_t RequiredDispclk = 0.;
5603         dml_float_t PixelClockAfterODM;
5604
5605         dml_float_t DISPCLKWithRampingRoundedToDFSGranularity;
5606         dml_float_t DISPCLKWithoutRampingRoundedToDFSGranularity;
5607         dml_float_t MaxDispclkRoundedDownToDFSGranularity;
5608
5609         if (ODMMode == dml_odm_mode_combine_4to1) {
5610                 PixelClockAfterODM = PixelClock / 4;
5611         } else if (ODMMode == dml_odm_mode_combine_2to1) {
5612                 PixelClockAfterODM = PixelClock / 2;
5613         } else {
5614                 PixelClockAfterODM = PixelClock;
5615         }
5616
5617         DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularity(PixelClockAfterODM * (1.0 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + DISPCLKRampingMargin / 100.0), 1, DISPCLKDPPCLKVCOSpeed);
5618         DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularity(PixelClockAfterODM * (1.0 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0), 1, DISPCLKDPPCLKVCOSpeed);
5619         MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularity(MaxDispclk, 0, DISPCLKDPPCLKVCOSpeed);
5620
5621         if (DISPCLKWithoutRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) {
5622                 RequiredDispclk = DISPCLKWithoutRampingRoundedToDFSGranularity;
5623         } else if (DISPCLKWithRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) {
5624                 RequiredDispclk = MaxDispclkRoundedDownToDFSGranularity;
5625         } else {
5626                 RequiredDispclk = DISPCLKWithRampingRoundedToDFSGranularity;
5627         }
5628
5629         return RequiredDispclk;
5630 }
5631
5632 /// @brief Determine DPPCLK if there only one DPP per plane, main factor is the pixel rate and DPP scaling parameter
5633 static void CalculateSinglePipeDPPCLKAndSCLThroughput(
5634                 dml_float_t HRatio,
5635                 dml_float_t HRatioChroma,
5636                 dml_float_t VRatio,
5637                 dml_float_t VRatioChroma,
5638                 dml_float_t MaxDCHUBToPSCLThroughput,
5639                 dml_float_t MaxPSCLToLBThroughput,
5640                 dml_float_t PixelClock,
5641                 enum dml_source_format_class SourcePixelFormat,
5642                 dml_uint_t HTaps,
5643                 dml_uint_t HTapsChroma,
5644                 dml_uint_t VTaps,
5645                 dml_uint_t VTapsChroma,
5646
5647                 // Output
5648                 dml_float_t *PSCL_THROUGHPUT,
5649                 dml_float_t *PSCL_THROUGHPUT_CHROMA,
5650                 dml_float_t *DPPCLKUsingSingleDPP)
5651 {
5652         dml_float_t DPPCLKUsingSingleDPPLuma;
5653         dml_float_t DPPCLKUsingSingleDPPChroma;
5654
5655         if (HRatio > 1) {
5656                 *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatio / dml_ceil((dml_float_t) HTaps / 6.0, 1.0));
5657         } else {
5658                 *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
5659         }
5660
5661         DPPCLKUsingSingleDPPLuma = PixelClock * dml_max3(VTaps / 6 * dml_min(1, HRatio), HRatio * VRatio / *PSCL_THROUGHPUT, 1);
5662
5663         if ((HTaps > 6 || VTaps > 6) && DPPCLKUsingSingleDPPLuma < 2 * PixelClock)
5664                 DPPCLKUsingSingleDPPLuma = 2 * PixelClock;
5665
5666         if ((SourcePixelFormat != dml_420_8 && SourcePixelFormat != dml_420_10 && SourcePixelFormat != dml_420_12 && SourcePixelFormat != dml_rgbe_alpha)) {
5667                 *PSCL_THROUGHPUT_CHROMA = 0;
5668                 *DPPCLKUsingSingleDPP = DPPCLKUsingSingleDPPLuma;
5669         } else {
5670                 if (HRatioChroma > 1) {
5671                         *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatioChroma / dml_ceil((dml_float_t) HTapsChroma / 6.0, 1.0));
5672                 } else {
5673                         *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
5674                 }
5675                 DPPCLKUsingSingleDPPChroma = PixelClock * dml_max3(VTapsChroma / 6 * dml_min(1, HRatioChroma),
5676                                                                                                                         HRatioChroma * VRatioChroma / *PSCL_THROUGHPUT_CHROMA, 1);
5677                 if ((HTapsChroma > 6 || VTapsChroma > 6) && DPPCLKUsingSingleDPPChroma < 2 * PixelClock)
5678                         DPPCLKUsingSingleDPPChroma = 2 * PixelClock;
5679                 *DPPCLKUsingSingleDPP = dml_max(DPPCLKUsingSingleDPPLuma, DPPCLKUsingSingleDPPChroma);
5680         }
5681 }
5682
5683 /// @brief Calculate the actual dppclk freq
5684 /// @param DPPCLKUsingSingleDPP DppClk freq required if there is only 1 DPP per plane
5685 /// @param DPPPerSurface Number of DPP for each plane
5686 static void CalculateDPPCLK(
5687                 dml_uint_t NumberOfActiveSurfaces,
5688                 dml_float_t DISPCLKDPPCLKDSCCLKDownSpreading,
5689                 dml_float_t DISPCLKDPPCLKVCOSpeed,
5690                 dml_float_t DPPCLKUsingSingleDPP[],
5691                 dml_uint_t DPPPerSurface[],
5692
5693                 // Output
5694                 dml_float_t *GlobalDPPCLK,
5695                 dml_float_t Dppclk[])
5696 {
5697         *GlobalDPPCLK = 0;
5698         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5699                 Dppclk[k] = DPPCLKUsingSingleDPP[k] / DPPPerSurface[k] * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
5700                 *GlobalDPPCLK = dml_max(*GlobalDPPCLK, Dppclk[k]);
5701         }
5702         *GlobalDPPCLK = RoundToDFSGranularity(*GlobalDPPCLK, 1, DISPCLKDPPCLKVCOSpeed);
5703
5704         dml_print("DML::%s: GlobalDPPCLK = %f\n", __func__, *GlobalDPPCLK);
5705         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5706                 Dppclk[k] = *GlobalDPPCLK / 255.0 * dml_ceil(Dppclk[k] * 255.0 / *GlobalDPPCLK, 1.0);
5707                 dml_print("DML::%s: Dppclk[%0d] = %f\n", __func__, k, Dppclk[k]);
5708         }
5709 }
5710
5711 static void CalculateMALLUseForStaticScreen(
5712                 dml_uint_t NumberOfActiveSurfaces,
5713                 dml_uint_t MALLAllocatedForDCNFinal,
5714                 enum dml_use_mall_for_static_screen_mode *UseMALLForStaticScreen,
5715                 dml_uint_t SurfaceSizeInMALL[],
5716                 dml_bool_t one_row_per_frame_fits_in_buffer[],
5717
5718                 // Output
5719                 dml_bool_t UsesMALLForStaticScreen[])
5720 {
5721
5722         dml_uint_t SurfaceToAddToMALL;
5723         dml_bool_t CanAddAnotherSurfaceToMALL;
5724         dml_uint_t TotalSurfaceSizeInMALL;
5725
5726         TotalSurfaceSizeInMALL = 0;
5727         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5728                 UsesMALLForStaticScreen[k] = (UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable);
5729                 if (UsesMALLForStaticScreen[k])
5730                         TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k];
5731 #ifdef __DML_VBA_DEBUG__
5732                 dml_print("DML::%s: k=%u, UsesMALLForStaticScreen = %u\n",  __func__, k, UsesMALLForStaticScreen[k]);
5733                 dml_print("DML::%s: k=%u, TotalSurfaceSizeInMALL = %u\n",  __func__, k, TotalSurfaceSizeInMALL);
5734 #endif
5735         }
5736
5737         SurfaceToAddToMALL = 0;
5738         CanAddAnotherSurfaceToMALL = true;
5739         while (CanAddAnotherSurfaceToMALL) {
5740                 CanAddAnotherSurfaceToMALL = false;
5741                 for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5742                         if (TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k] <= MALLAllocatedForDCNFinal * 1024 * 1024 &&
5743                                 !UsesMALLForStaticScreen[k] && UseMALLForStaticScreen[k] != dml_use_mall_static_screen_disable && one_row_per_frame_fits_in_buffer[k] &&
5744                                 (!CanAddAnotherSurfaceToMALL || SurfaceSizeInMALL[k] < SurfaceSizeInMALL[SurfaceToAddToMALL])) {
5745                                 CanAddAnotherSurfaceToMALL = true;
5746                                 SurfaceToAddToMALL = k;
5747                                 dml_print("DML::%s: k=%u, UseMALLForStaticScreen = %u (dis, en, optimize)\n",  __func__, k, UseMALLForStaticScreen[k]);
5748                         }
5749                 }
5750                 if (CanAddAnotherSurfaceToMALL) {
5751                         UsesMALLForStaticScreen[SurfaceToAddToMALL] = true;
5752                         TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[SurfaceToAddToMALL];
5753
5754 #ifdef __DML_VBA_DEBUG__
5755                         dml_print("DML::%s: SurfaceToAddToMALL       = %u\n",  __func__, SurfaceToAddToMALL);
5756                         dml_print("DML::%s: TotalSurfaceSizeInMALL   = %u\n",  __func__, TotalSurfaceSizeInMALL);
5757 #endif
5758                 }
5759         }
5760 }
5761
5762 // @brief Calculate return bw for VM only traffic
5763 dml_float_t dml_get_return_bw_mbps_vm_only(
5764                                                                 const struct soc_bounding_box_st *soc,
5765                                                                 dml_bool_t use_ideal_dram_bw_strobe,
5766                                                                 dml_bool_t HostVMEnable,
5767                                                                 dml_float_t DCFCLK,
5768                                                                 dml_float_t FabricClock,
5769                                                                 dml_float_t DRAMSpeed)
5770 {
5771         dml_float_t VMDataOnlyReturnBW =
5772                 dml_min3(soc->return_bus_width_bytes * DCFCLK * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
5773                                 FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
5774                                 DRAMSpeed * soc->num_chans *  soc->dram_channel_width_bytes *
5775                                 ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :  soc->pct_ideal_dram_bw_after_urgent_vm_only) / 100.0);
5776 #ifdef __DML_VBA_DEBUG__
5777         dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5778         dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5779         dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
5780         dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
5781         dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5782         dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
5783 #endif
5784         return VMDataOnlyReturnBW;
5785 }
5786
5787 // Function: dml_get_return_bw_mbps
5788 // Megabyte per second
5789 dml_float_t dml_get_return_bw_mbps(
5790                                                 const struct soc_bounding_box_st *soc,
5791                                                 dml_bool_t use_ideal_dram_bw_strobe,
5792                                                 dml_bool_t HostVMEnable,
5793                                                 dml_float_t DCFCLK,
5794                                                 dml_float_t FabricClock,
5795                                                 dml_float_t DRAMSpeed)
5796 {
5797         dml_float_t ReturnBW = 0.;
5798         dml_float_t IdealSDPPortBandwidth    = soc->return_bus_width_bytes * DCFCLK;
5799         dml_float_t IdealFabricBandwidth     = FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes;
5800         dml_float_t IdealDRAMBandwidth       = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes;
5801         dml_float_t PixelDataOnlyReturnBW    = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
5802                                                                                                 IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
5803                                                                                                 IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5804                                                                                                                                                                                 soc->pct_ideal_dram_bw_after_urgent_pixel_only) / 100);
5805         dml_float_t PixelMixedWithVMDataReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
5806                                                                                                         IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
5807                                                                                                         IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5808                                                                                                                                                                                         soc->pct_ideal_dram_bw_after_urgent_pixel_and_vm) / 100);
5809
5810         if (HostVMEnable != true) {
5811                 ReturnBW = PixelDataOnlyReturnBW;
5812         } else {
5813                 ReturnBW = PixelMixedWithVMDataReturnBW;
5814         }
5815
5816 #ifdef __DML_VBA_DEBUG__
5817         dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5818         dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5819         dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
5820         dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
5821         dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5822         dml_print("DML::%s: IdealSDPPortBandwidth = %f\n", __func__, IdealSDPPortBandwidth);
5823         dml_print("DML::%s: IdealFabricBandwidth = %f\n", __func__, IdealFabricBandwidth);
5824         dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth);
5825         dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW);
5826         dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW);
5827         dml_print("DML::%s: ReturnBW                  = %f MBps\n", __func__, ReturnBW);
5828 #endif
5829         return ReturnBW;
5830 }
5831
5832 // Function: dml_get_return_dram_bw_mbps
5833 // Megabyte per second
5834 static dml_float_t dml_get_return_dram_bw_mbps(
5835                                                 const struct soc_bounding_box_st *soc,
5836                                                 dml_bool_t use_ideal_dram_bw_strobe,
5837                                                 dml_bool_t HostVMEnable,
5838                                                 dml_float_t DRAMSpeed)
5839 {
5840         dml_float_t ReturnDRAMBW = 0.;
5841         dml_float_t IdealDRAMBandwidth       = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes;
5842         dml_float_t PixelDataOnlyReturnBW    = IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5843                                                                                                                                                                                 soc->pct_ideal_dram_bw_after_urgent_pixel_only) / 100;
5844         dml_float_t PixelMixedWithVMDataReturnBW =  IdealDRAMBandwidth * ((use_ideal_dram_bw_strobe && !HostVMEnable) ? soc->pct_ideal_dram_bw_after_urgent_strobe :
5845                                                                                                                                                                                         soc->pct_ideal_dram_bw_after_urgent_pixel_and_vm) / 100;
5846
5847         if (HostVMEnable != true) {
5848                 ReturnDRAMBW = PixelDataOnlyReturnBW;
5849         } else {
5850                 ReturnDRAMBW = PixelMixedWithVMDataReturnBW;
5851         }
5852
5853 #ifdef __DML_VBA_DEBUG__
5854         dml_print("DML::%s: use_ideal_dram_bw_strobe = %u\n", __func__, use_ideal_dram_bw_strobe);
5855         dml_print("DML::%s: HostVMEnable = %u\n", __func__, HostVMEnable);
5856         dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
5857         dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth);
5858         dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW);
5859         dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW);
5860         dml_print("DML::%s: ReturnDRAMBW                     = %f MBps\n", __func__, ReturnDRAMBW);
5861 #endif
5862         return ReturnDRAMBW;
5863 }
5864
5865 /// @brief BACKEND
5866 static dml_uint_t DSCDelayRequirement(
5867                                                 dml_bool_t DSCEnabled,
5868                                                 enum dml_odm_mode ODMMode,
5869                                                 dml_uint_t DSCInputBitPerComponent,
5870                                                 dml_float_t OutputBpp,
5871                                                 dml_uint_t HActive,
5872                                                 dml_uint_t HTotal,
5873                                                 dml_uint_t NumberOfDSCSlices,
5874                                                 enum dml_output_format_class OutputFormat,
5875                                                 enum dml_output_encoder_class Output,
5876                                                 dml_float_t PixelClock,
5877                                                 dml_float_t PixelClockBackEnd)
5878 {
5879         dml_uint_t DSCDelayRequirement_val = 0;
5880
5881         if (DSCEnabled == true && OutputBpp != 0) {
5882                 if (ODMMode == dml_odm_mode_combine_4to1) {
5883                         DSCDelayRequirement_val = 4 * (dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)(dml_ceil((dml_float_t) HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5884                                                                                                 (dml_uint_t) (NumberOfDSCSlices / 4.0), OutputFormat, Output) + dscComputeDelay(OutputFormat, Output));
5885                 } else if (ODMMode == dml_odm_mode_combine_2to1) {
5886                         DSCDelayRequirement_val = 2 * (dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)(dml_ceil((dml_float_t) HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5887                                                                                                 (dml_uint_t) (NumberOfDSCSlices / 2.0), OutputFormat, Output) + dscComputeDelay(OutputFormat, Output));
5888                 } else {
5889                         DSCDelayRequirement_val = dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, (dml_uint_t)((dml_float_t) dml_ceil(HActive / (dml_float_t) NumberOfDSCSlices, 1.0)),
5890                                                                                 NumberOfDSCSlices, OutputFormat, Output) + dscComputeDelay(OutputFormat, Output);
5891                 }
5892                 DSCDelayRequirement_val = (dml_uint_t)(DSCDelayRequirement_val + (HTotal - HActive) * dml_ceil((dml_float_t) DSCDelayRequirement_val / (dml_float_t) HActive, 1.0));
5893                 DSCDelayRequirement_val = (dml_uint_t)(DSCDelayRequirement_val * PixelClock / PixelClockBackEnd);
5894
5895         } else {
5896                 DSCDelayRequirement_val = 0;
5897         }
5898 #ifdef __DML_VBA_DEBUG__
5899         dml_print("DML::%s: DSCEnabled = %u\n", __func__, DSCEnabled);
5900         dml_print("DML::%s: ODMMode = %u\n", __func__, ODMMode);
5901         dml_print("DML::%s: OutputBpp = %f\n", __func__, OutputBpp);
5902         dml_print("DML::%s: HActive = %u\n", __func__, HActive);
5903         dml_print("DML::%s: HTotal = %u\n", __func__, HTotal);
5904         dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock);
5905         dml_print("DML::%s: PixelClockBackEnd = %f\n", __func__, PixelClockBackEnd);
5906         dml_print("DML::%s: OutputFormat = %u\n", __func__, OutputFormat);
5907         dml_print("DML::%s: DSCInputBitPerComponent = %u\n", __func__, DSCInputBitPerComponent);
5908         dml_print("DML::%s: NumberOfDSCSlices = %u\n", __func__, NumberOfDSCSlices);
5909         dml_print("DML::%s: DSCDelayRequirement_val = %u\n", __func__, DSCDelayRequirement_val);
5910 #endif
5911
5912         return DSCDelayRequirement_val;
5913 }
5914
5915 static dml_bool_t CalculateVActiveBandwithSupport(dml_uint_t NumberOfActiveSurfaces,
5916                                                                                 dml_float_t ReturnBW,
5917                                                                                 dml_bool_t NotUrgentLatencyHiding[],
5918                                                                                 dml_float_t ReadBandwidthLuma[],
5919                                                                                 dml_float_t ReadBandwidthChroma[],
5920                                                                                 dml_float_t cursor_bw[],
5921                                                                                 dml_float_t meta_row_bandwidth[],
5922                                                                                 dml_float_t dpte_row_bandwidth[],
5923                                                                                 dml_uint_t NumberOfDPP[],
5924                                                                                 dml_float_t UrgentBurstFactorLuma[],
5925                                                                                 dml_float_t UrgentBurstFactorChroma[],
5926                                                                                 dml_float_t UrgentBurstFactorCursor[])
5927 {
5928         dml_bool_t NotEnoughUrgentLatencyHiding = false;
5929         dml_bool_t CalculateVActiveBandwithSupport_val = false;
5930         dml_float_t VActiveBandwith = 0;
5931
5932         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5933                 if (NotUrgentLatencyHiding[k]) {
5934                         NotEnoughUrgentLatencyHiding = true;
5935                 }
5936         }
5937
5938         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5939                 VActiveBandwith = VActiveBandwith + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * meta_row_bandwidth[k] + NumberOfDPP[k] * dpte_row_bandwidth[k];
5940         }
5941
5942         CalculateVActiveBandwithSupport_val = (VActiveBandwith <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
5943
5944 #ifdef __DML_VBA_DEBUG__
5945         dml_print("DML::%s: NotEnoughUrgentLatencyHiding        = %u\n", __func__, NotEnoughUrgentLatencyHiding);
5946         dml_print("DML::%s: VActiveBandwith                     = %f\n", __func__, VActiveBandwith);
5947         dml_print("DML::%s: ReturnBW                            = %f\n", __func__, ReturnBW);
5948         dml_print("DML::%s: CalculateVActiveBandwithSupport_val = %u\n", __func__, CalculateVActiveBandwithSupport_val);
5949 #endif
5950         return CalculateVActiveBandwithSupport_val;
5951 }
5952
5953 static void CalculatePrefetchBandwithSupport(
5954                                                                                 dml_uint_t NumberOfActiveSurfaces,
5955                                                                                 dml_float_t ReturnBW,
5956                                                                                 enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
5957                                                                                 dml_bool_t NotUrgentLatencyHiding[],
5958                                                                                 dml_float_t ReadBandwidthLuma[],
5959                                                                                 dml_float_t ReadBandwidthChroma[],
5960                                                                                 dml_float_t PrefetchBandwidthLuma[],
5961                                                                                 dml_float_t PrefetchBandwidthChroma[],
5962                                                                                 dml_float_t cursor_bw[],
5963                                                                                 dml_float_t meta_row_bandwidth[],
5964                                                                                 dml_float_t dpte_row_bandwidth[],
5965                                                                                 dml_float_t cursor_bw_pre[],
5966                                                                                 dml_float_t prefetch_vmrow_bw[],
5967                                                                                 dml_uint_t NumberOfDPP[],
5968                                                                                 dml_float_t UrgentBurstFactorLuma[],
5969                                                                                 dml_float_t UrgentBurstFactorChroma[],
5970                                                                                 dml_float_t UrgentBurstFactorCursor[],
5971                                                                                 dml_float_t UrgentBurstFactorLumaPre[],
5972                                                                                 dml_float_t UrgentBurstFactorChromaPre[],
5973                                                                                 dml_float_t UrgentBurstFactorCursorPre[],
5974
5975                                                                                 // Output
5976                                                                                 dml_float_t *PrefetchBandwidth,
5977                                                                                 dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch,
5978                                                                                 dml_float_t *FractionOfUrgentBandwidth,
5979                                                                                 dml_bool_t *PrefetchBandwidthSupport)
5980 {
5981         dml_bool_t NotEnoughUrgentLatencyHiding = false;
5982         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5983                 if (NotUrgentLatencyHiding[k]) {
5984                         NotEnoughUrgentLatencyHiding = true;
5985                 }
5986         }
5987
5988         *PrefetchBandwidth = 0;
5989         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5990                 *PrefetchBandwidth = *PrefetchBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
5991                                                                                                                 ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]),
5992                                                                                                                 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
5993         }
5994
5995         *PrefetchBandwidthNotIncludingMALLPrefetch = 0;
5996         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
5997                 if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe)
5998                         *PrefetchBandwidthNotIncludingMALLPrefetch = *PrefetchBandwidthNotIncludingMALLPrefetch
5999                                 + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6000                                 ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k]
6001                                 + cursor_bw[k] * UrgentBurstFactorCursor[k]
6002                                 + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]),
6003                                 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k]
6004                                 + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6005                                 + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6006         }
6007
6008         *PrefetchBandwidthSupport = (*PrefetchBandwidth <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
6009         *FractionOfUrgentBandwidth = *PrefetchBandwidth / ReturnBW;
6010
6011 #ifdef __DML_VBA_DEBUG__
6012         dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
6013         dml_print("DML::%s: PrefetchBandwidth = %f\n", __func__, *PrefetchBandwidth);
6014         dml_print("DML::%s: FractionOfUrgentBandwidth = %f\n", __func__, *FractionOfUrgentBandwidth);
6015    dml_print("DML::%s: PrefetchBandwidthSupport = %u\n", __func__, *PrefetchBandwidthSupport);
6016 #endif
6017 }
6018
6019 static dml_float_t CalculateBandwidthAvailableForImmediateFlip(
6020                                                                                                         dml_uint_t NumberOfActiveSurfaces,
6021                                                                                                         dml_float_t ReturnBW,
6022                                                                                                         dml_float_t ReadBandwidthLuma[],
6023                                                                                                         dml_float_t ReadBandwidthChroma[],
6024                                                                                                         dml_float_t PrefetchBandwidthLuma[],
6025                                                                                                         dml_float_t PrefetchBandwidthChroma[],
6026                                                                                                         dml_float_t cursor_bw[],
6027                                                                                                         dml_float_t cursor_bw_pre[],
6028                                                                                                         dml_uint_t NumberOfDPP[],
6029                                                                                                         dml_float_t UrgentBurstFactorLuma[],
6030                                                                                                         dml_float_t UrgentBurstFactorChroma[],
6031                                                                                                         dml_float_t UrgentBurstFactorCursor[],
6032                                                                                                         dml_float_t UrgentBurstFactorLumaPre[],
6033                                                                                                         dml_float_t UrgentBurstFactorChromaPre[],
6034                                                                                                         dml_float_t UrgentBurstFactorCursorPre[])
6035 {
6036         dml_float_t ret_val = ReturnBW;
6037
6038         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6039                 ret_val = ret_val - dml_max(ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6040                                                                         NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) +
6041                                                                         cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6042 #ifdef __DML_VBA_DEBUG__
6043                 dml_print("DML::%s: k=%u\n", __func__, k);
6044                 dml_print("DML::%s: NumberOfDPP = %u\n", __func__, NumberOfDPP[k]);
6045                 dml_print("DML::%s: ReadBandwidthLuma = %f\n", __func__, ReadBandwidthLuma[k]);
6046                 dml_print("DML::%s: UrgentBurstFactorLuma = %f\n", __func__, UrgentBurstFactorLuma[k]);
6047                 dml_print("DML::%s: ReadBandwidthChroma = %f\n", __func__, ReadBandwidthChroma[k]);
6048                 dml_print("DML::%s: UrgentBurstFactorChroma = %f\n", __func__, UrgentBurstFactorChroma[k]);
6049                 dml_print("DML::%s: cursor_bw = %f\n", __func__, cursor_bw[k]);
6050                 dml_print("DML::%s: UrgentBurstFactorCursor = %f\n", __func__, UrgentBurstFactorCursor[k]);
6051
6052                 dml_print("DML::%s: PrefetchBandwidthLuma = %f\n", __func__, PrefetchBandwidthLuma[k]);
6053                 dml_print("DML::%s: UrgentBurstFactorLumaPre = %f\n", __func__, UrgentBurstFactorLumaPre[k]);
6054                 dml_print("DML::%s: PrefetchBandwidthChroma = %f\n", __func__, PrefetchBandwidthChroma[k]);
6055                 dml_print("DML::%s: UrgentBurstFactorChromaPre = %f\n", __func__, UrgentBurstFactorChromaPre[k]);
6056                 dml_print("DML::%s: cursor_bw_pre = %f\n", __func__, cursor_bw_pre[k]);
6057                 dml_print("DML::%s: UrgentBurstFactorCursorPre = %f\n", __func__, UrgentBurstFactorCursorPre[k]);
6058                 dml_print("DML::%s: ret_val              = %f\n", __func__, ret_val);
6059 #endif
6060         }
6061
6062         return ret_val;
6063 }
6064
6065 static void CalculateImmediateFlipBandwithSupport(
6066                                                                                         dml_uint_t NumberOfActiveSurfaces,
6067                                                                                         dml_float_t ReturnBW,
6068                                                                                         enum dml_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
6069                                                                                         enum dml_immediate_flip_requirement ImmediateFlipRequirement[],
6070                                                                                         dml_float_t final_flip_bw[],
6071                                                                                         dml_float_t ReadBandwidthLuma[],
6072                                                                                         dml_float_t ReadBandwidthChroma[],
6073                                                                                         dml_float_t PrefetchBandwidthLuma[],
6074                                                                                         dml_float_t PrefetchBandwidthChroma[],
6075                                                                                         dml_float_t cursor_bw[],
6076                                                                                         dml_float_t meta_row_bandwidth[],
6077                                                                                         dml_float_t dpte_row_bandwidth[],
6078                                                                                         dml_float_t cursor_bw_pre[],
6079                                                                                         dml_float_t prefetch_vmrow_bw[],
6080                                                                                         dml_uint_t NumberOfDPP[],
6081                                                                                         dml_float_t UrgentBurstFactorLuma[],
6082                                                                                         dml_float_t UrgentBurstFactorChroma[],
6083                                                                                         dml_float_t UrgentBurstFactorCursor[],
6084                                                                                         dml_float_t UrgentBurstFactorLumaPre[],
6085                                                                                         dml_float_t UrgentBurstFactorChromaPre[],
6086                                                                                         dml_float_t UrgentBurstFactorCursorPre[],
6087
6088                                                                                         // Output
6089                                                                                         dml_float_t *TotalBandwidth,
6090                                                                                         dml_float_t *TotalBandwidthNotIncludingMALLPrefetch,
6091                                                                                         dml_float_t *FractionOfUrgentBandwidth,
6092                                                                                         dml_bool_t *ImmediateFlipBandwidthSupport)
6093 {
6094         *TotalBandwidth = 0;
6095         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6096                 if (ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) {
6097
6098
6099
6100                         *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6101                                                                                                                 NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6102                                                                                                                 NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6103                 } else {
6104                         *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6105                                                                                                                 NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]) + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6106                                                                                                                 NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6107                 }
6108 #ifdef __DML_VBA_DEBUG__
6109                 dml_print("DML::%s: k = %u\n", __func__, k);
6110                 dml_print("DML::%s: ImmediateFlipRequirement = %u\n", __func__, ImmediateFlipRequirement[k]);
6111                 dml_print("DML::%s: TotalBandwidth = %f\n", __func__, *TotalBandwidth);
6112                 dml_print("DML::%s: NumberOfDPP = %u\n", __func__, NumberOfDPP[k]);
6113                 dml_print("DML::%s: prefetch_vmrow_bw = %f\n", __func__, prefetch_vmrow_bw[k]);
6114                 dml_print("DML::%s: final_flip_bw = %f\n", __func__, final_flip_bw[k]);
6115                 dml_print("DML::%s: ReadBandwidthLuma = %f\n", __func__, ReadBandwidthLuma[k]);
6116                 dml_print("DML::%s: UrgentBurstFactorLuma = %f\n", __func__, UrgentBurstFactorLuma[k]);
6117                 dml_print("DML::%s: ReadBandwidthChroma = %f\n", __func__, ReadBandwidthChroma[k]);
6118                 dml_print("DML::%s: UrgentBurstFactorChroma = %f\n", __func__, UrgentBurstFactorChroma[k]);
6119                 dml_print("DML::%s: cursor_bw = %f\n", __func__, cursor_bw[k]);
6120                 dml_print("DML::%s: UrgentBurstFactorCursor = %f\n", __func__, UrgentBurstFactorCursor[k]);
6121                 dml_print("DML::%s: PrefetchBandwidthLuma = %f\n", __func__, PrefetchBandwidthLuma[k]);
6122                 dml_print("DML::%s: UrgentBurstFactorLumaPre = %f\n", __func__, UrgentBurstFactorLumaPre[k]);
6123                 dml_print("DML::%s: PrefetchBandwidthChroma = %f\n", __func__, PrefetchBandwidthChroma[k]);
6124                 dml_print("DML::%s: UrgentBurstFactorChromaPre = %f\n", __func__, UrgentBurstFactorChromaPre[k]);
6125                 dml_print("DML::%s: cursor_bw_pre = %f\n", __func__, cursor_bw_pre[k]);
6126                 dml_print("DML::%s: UrgentBurstFactorCursorPre = %f\n", __func__, UrgentBurstFactorCursorPre[k]);
6127                 dml_print("DML::%s: meta_row_bandwidth = %f\n", __func__, meta_row_bandwidth[k]);
6128                 dml_print("DML::%s: dpte_row_bandwidth          = %f\n", __func__, dpte_row_bandwidth[k]);
6129 #endif
6130         }
6131
6132         *TotalBandwidthNotIncludingMALLPrefetch = 0;
6133         for (dml_uint_t k = 0; k < NumberOfActiveSurfaces; ++k) {
6134                 if (UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
6135                         if (ImmediateFlipRequirement[k] != dml_immediate_flip_not_required)
6136                                 *TotalBandwidthNotIncludingMALLPrefetch = *TotalBandwidthNotIncludingMALLPrefetch + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6137                                         NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6138                                         NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6139                                         + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6140                         else
6141                                 *TotalBandwidthNotIncludingMALLPrefetch = *TotalBandwidthNotIncludingMALLPrefetch + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6142                                         NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k])
6143                                         + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6144                                         NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k])
6145                                         + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6146                 }
6147         }
6148
6149         *ImmediateFlipBandwidthSupport = (*TotalBandwidth <= ReturnBW);
6150         *FractionOfUrgentBandwidth = *TotalBandwidth / ReturnBW;
6151 #ifdef __DML_VBA_DEBUG__
6152         dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
6153         dml_print("DML::%s: TotalBandwidth = %f\n", __func__, *TotalBandwidth);
6154         dml_print("DML::%s: ImmediateFlipBandwidthSupport = %u\n", __func__, *ImmediateFlipBandwidthSupport);
6155 #endif
6156 }
6157
6158 static dml_uint_t MicroSecToVertLines(dml_uint_t num_us, dml_uint_t h_total, dml_float_t pixel_clock)
6159 {
6160         dml_uint_t lines_time_in_ns = 1000.0 * (h_total * 1000.0) / (pixel_clock * 1000.0);
6161
6162         return dml_ceil(1000.0 * num_us / lines_time_in_ns, 1.0);
6163 }
6164
6165 /// @brief Calculate the maximum vstartup for mode support and mode programming consideration
6166 ///         Bounded by min of actual vblank and input vblank_nom, dont want vstartup/ready to start too early if actual vbllank is huge
6167 static dml_uint_t CalculateMaxVStartup(
6168                         dml_uint_t          plane_idx,
6169                         dml_bool_t          ptoi_supported,
6170                         dml_uint_t          vblank_nom_default_us,
6171                         struct dml_timing_cfg_st  *timing,
6172                         dml_float_t         write_back_delay_us)
6173 {
6174         dml_uint_t vblank_size = 0;
6175         dml_uint_t max_vstartup_lines = 0;
6176         const dml_uint_t max_allowed_vblank_nom = 1023;
6177
6178         dml_float_t line_time_us = (dml_float_t) timing->HTotal[plane_idx] / timing->PixelClock[plane_idx];
6179         dml_uint_t vblank_actual = timing->VTotal[plane_idx] - timing->VActive[plane_idx];
6180
6181         dml_uint_t vblank_nom_default_in_line = MicroSecToVertLines(vblank_nom_default_us, timing->HTotal[plane_idx],
6182                         timing->PixelClock[plane_idx]);
6183         dml_uint_t vblank_nom_input = (dml_uint_t)dml_min(vblank_actual, vblank_nom_default_in_line);
6184
6185         // vblank_nom should not be smaller than (VSync (VTotal - VActive - VFrontPorch) + 2)
6186         // + 2 is because
6187         // 1 -> VStartup_start should be 1 line before VSync
6188         // 1 -> always reserve 1 line between start of VBlank to VStartup signal
6189         dml_uint_t vblank_nom_vsync_capped = dml_max(vblank_nom_input,
6190                         timing->VTotal[plane_idx] - timing->VActive[plane_idx] - timing->VFrontPorch[plane_idx] + 2);
6191         dml_uint_t vblank_nom_max_allowed_capped = dml_min(vblank_nom_vsync_capped, max_allowed_vblank_nom);
6192         dml_uint_t vblank_avail = (vblank_nom_max_allowed_capped == 0) ?
6193                         vblank_nom_default_in_line : vblank_nom_max_allowed_capped;
6194
6195         vblank_size = (dml_uint_t) dml_min(vblank_actual, vblank_avail);
6196
6197    if (timing->Interlace[plane_idx] && !ptoi_supported)
6198                 max_vstartup_lines = (dml_uint_t) (dml_floor(vblank_size/2.0, 1.0));
6199         else
6200                 max_vstartup_lines = vblank_size - (dml_uint_t) dml_max(1.0, dml_ceil(write_back_delay_us/line_time_us, 1.0));
6201 #ifdef __DML_VBA_DEBUG__
6202         dml_print("DML::%s: plane_idx = %u\n", __func__, plane_idx);
6203         dml_print("DML::%s: VBlankNom = %u\n", __func__, timing->VBlankNom[plane_idx]);
6204         dml_print("DML::%s: vblank_nom_default_us = %u\n", __func__, vblank_nom_default_us);
6205         dml_print("DML::%s: line_time_us = %f\n", __func__, line_time_us);
6206         dml_print("DML::%s: vblank_actual = %u\n", __func__, vblank_actual);
6207         dml_print("DML::%s: vblank_avail = %u\n", __func__, vblank_avail);
6208         dml_print("DML::%s: max_vstartup_lines = %u\n", __func__, max_vstartup_lines);
6209 #endif
6210         return max_vstartup_lines;
6211 }
6212
6213 static void set_calculate_prefetch_schedule_params(struct display_mode_lib_st *mode_lib,
6214                                                    struct CalculatePrefetchSchedule_params_st *CalculatePrefetchSchedule_params,
6215                                                    dml_uint_t j,
6216                                                    dml_uint_t k)
6217 {
6218                                 CalculatePrefetchSchedule_params->DSCDelay = mode_lib->ms.DSCDelayPerState[k];
6219                                 CalculatePrefetchSchedule_params->EnhancedPrefetchScheduleAccelerationFinal = mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal;
6220                                 CalculatePrefetchSchedule_params->DPPCLKDelaySubtotalPlusCNVCFormater = mode_lib->ms.ip.dppclk_delay_subtotal + mode_lib->ms.ip.dppclk_delay_cnvc_formatter;
6221                                 CalculatePrefetchSchedule_params->DPPCLKDelaySCL = mode_lib->ms.ip.dppclk_delay_scl;
6222                                 CalculatePrefetchSchedule_params->DPPCLKDelaySCLLBOnly = mode_lib->ms.ip.dppclk_delay_scl_lb_only;
6223                                 CalculatePrefetchSchedule_params->DPPCLKDelayCNVCCursor = mode_lib->ms.ip.dppclk_delay_cnvc_cursor;
6224                                 CalculatePrefetchSchedule_params->DISPCLKDelaySubtotal = mode_lib->ms.ip.dispclk_delay_subtotal;
6225                                 CalculatePrefetchSchedule_params->DPP_RECOUT_WIDTH = (dml_uint_t)(mode_lib->ms.SwathWidthYThisState[k] / mode_lib->ms.cache_display_cfg.plane.HRatio[k]);
6226                                 CalculatePrefetchSchedule_params->OutputFormat = mode_lib->ms.cache_display_cfg.output.OutputFormat[k];
6227                                 CalculatePrefetchSchedule_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
6228                                 CalculatePrefetchSchedule_params->GPUVMPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
6229                                 CalculatePrefetchSchedule_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
6230                                 CalculatePrefetchSchedule_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
6231                                 CalculatePrefetchSchedule_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
6232                                 CalculatePrefetchSchedule_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024;
6233                                 CalculatePrefetchSchedule_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k];
6234                                 CalculatePrefetchSchedule_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
6235                                 CalculatePrefetchSchedule_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired[k];
6236                                 CalculatePrefetchSchedule_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes[k];
6237                                 CalculatePrefetchSchedule_params->UrgentLatency = mode_lib->ms.UrgLatency;
6238                                 CalculatePrefetchSchedule_params->UrgentExtraLatency = mode_lib->ms.ExtraLatency;
6239                                 CalculatePrefetchSchedule_params->TCalc = mode_lib->ms.TimeCalc;
6240                                 CalculatePrefetchSchedule_params->PDEAndMetaPTEBytesFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k];
6241                                 CalculatePrefetchSchedule_params->MetaRowByte = mode_lib->ms.MetaRowBytes[j][k];
6242                                 CalculatePrefetchSchedule_params->PixelPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRow[j][k];
6243                                 CalculatePrefetchSchedule_params->PrefetchSourceLinesY = mode_lib->ms.PrefetchLinesY[j][k];
6244                                 CalculatePrefetchSchedule_params->VInitPreFillY = mode_lib->ms.PrefillY[k];
6245                                 CalculatePrefetchSchedule_params->MaxNumSwathY = mode_lib->ms.MaxNumSwY[k];
6246                                 CalculatePrefetchSchedule_params->PrefetchSourceLinesC = mode_lib->ms.PrefetchLinesC[j][k];
6247                                 CalculatePrefetchSchedule_params->VInitPreFillC = mode_lib->ms.PrefillC[k];
6248                                 CalculatePrefetchSchedule_params->MaxNumSwathC = mode_lib->ms.MaxNumSwC[k];
6249                                 CalculatePrefetchSchedule_params->swath_width_luma_ub = mode_lib->ms.swath_width_luma_ub_this_state[k];
6250                                 CalculatePrefetchSchedule_params->swath_width_chroma_ub = mode_lib->ms.swath_width_chroma_ub_this_state[k];
6251                                 CalculatePrefetchSchedule_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState[k];
6252                                 CalculatePrefetchSchedule_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState[k];
6253                                 CalculatePrefetchSchedule_params->TWait = mode_lib->ms.TWait;
6254                                 CalculatePrefetchSchedule_params->DestinationLinesForPrefetch = &mode_lib->ms.LineTimesForPrefetch[k];
6255                                 CalculatePrefetchSchedule_params->DestinationLinesToRequestVMInVBlank = &mode_lib->ms.LinesForMetaPTE[k];
6256                                 CalculatePrefetchSchedule_params->DestinationLinesToRequestRowInVBlank = &mode_lib->ms.LinesForMetaAndDPTERow[k];
6257                                 CalculatePrefetchSchedule_params->VRatioPrefetchY = &mode_lib->ms.VRatioPreY[j][k];
6258                                 CalculatePrefetchSchedule_params->VRatioPrefetchC = &mode_lib->ms.VRatioPreC[j][k];
6259                                 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWLuma = &mode_lib->ms.RequiredPrefetchPixelDataBWLuma[k];
6260                                 CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWChroma = &mode_lib->ms.RequiredPrefetchPixelDataBWChroma[k];
6261                                 CalculatePrefetchSchedule_params->NotEnoughTimeForDynamicMetadata = &mode_lib->ms.support.NoTimeForDynamicMetadata[j][k];
6262                                 CalculatePrefetchSchedule_params->Tno_bw = &mode_lib->ms.Tno_bw[k];
6263 }
6264
6265 static void dml_prefetch_check(struct display_mode_lib_st *mode_lib)
6266 {
6267         struct dml_core_mode_support_locals_st *s = &mode_lib->scratch.dml_core_mode_support_locals;
6268         struct CalculatePrefetchSchedule_params_st *CalculatePrefetchSchedule_params = &mode_lib->scratch.CalculatePrefetchSchedule_params;
6269         struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *CalculateWatermarks_params = &mode_lib->scratch.CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params;
6270         struct DmlPipe *myPipe;
6271         dml_uint_t j, k;
6272
6273         for (j = 0; j < 2; ++j) {
6274                 mode_lib->ms.TimeCalc = 24 / mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
6275
6276                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6277                         mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
6278                         mode_lib->ms.swath_width_luma_ub_this_state[k] = mode_lib->ms.swath_width_luma_ub_all_states[j][k];
6279                         mode_lib->ms.swath_width_chroma_ub_this_state[k] = mode_lib->ms.swath_width_chroma_ub_all_states[j][k];
6280                         mode_lib->ms.SwathWidthYThisState[k] = mode_lib->ms.SwathWidthYAllStates[j][k];
6281                         mode_lib->ms.SwathWidthCThisState[k] = mode_lib->ms.SwathWidthCAllStates[j][k];
6282                         mode_lib->ms.SwathHeightYThisState[k] = mode_lib->ms.SwathHeightYAllStates[j][k];
6283                         mode_lib->ms.SwathHeightCThisState[k] = mode_lib->ms.SwathHeightCAllStates[j][k];
6284                         mode_lib->ms.UnboundedRequestEnabledThisState = mode_lib->ms.UnboundedRequestEnabledAllStates[j];
6285                         mode_lib->ms.CompressedBufferSizeInkByteThisState = mode_lib->ms.CompressedBufferSizeInkByteAllStates[j];
6286                         mode_lib->ms.DETBufferSizeInKByteThisState[k] = mode_lib->ms.DETBufferSizeInKByteAllStates[j][k];
6287                         mode_lib->ms.DETBufferSizeYThisState[k] = mode_lib->ms.DETBufferSizeYAllStates[j][k];
6288                         mode_lib->ms.DETBufferSizeCThisState[k] = mode_lib->ms.DETBufferSizeCAllStates[j][k];
6289                 }
6290
6291                 mode_lib->ms.support.VActiveBandwithSupport[j] = CalculateVActiveBandwithSupport(
6292                         mode_lib->ms.num_active_planes,
6293                         mode_lib->ms.ReturnBWPerState[j],
6294                         mode_lib->ms.NotUrgentLatencyHiding,
6295                         mode_lib->ms.ReadBandwidthLuma,
6296                         mode_lib->ms.ReadBandwidthChroma,
6297                         mode_lib->ms.cursor_bw,
6298                         mode_lib->ms.meta_row_bandwidth_this_state,
6299                         mode_lib->ms.dpte_row_bandwidth_this_state,
6300                         mode_lib->ms.NoOfDPPThisState,
6301                         mode_lib->ms.UrgentBurstFactorLuma,
6302                         mode_lib->ms.UrgentBurstFactorChroma,
6303                         mode_lib->ms.UrgentBurstFactorCursor);
6304
6305                 s->VMDataOnlyReturnBWPerState = dml_get_return_bw_mbps_vm_only(
6306                                                                                                                                         &mode_lib->ms.soc,
6307                                                                                                                                         mode_lib->ms.state.use_ideal_dram_bw_strobe,
6308                                                                                                                                         mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
6309                                                                                                                                         mode_lib->ms.DCFCLKState[j],
6310                                                                                                                                         mode_lib->ms.state.fabricclk_mhz,
6311                                                                                                                                         mode_lib->ms.state.dram_speed_mts);
6312
6313                 s->HostVMInefficiencyFactor = 1;
6314                 if (mode_lib->ms.cache_display_cfg.plane.GPUVMEnable && mode_lib->ms.cache_display_cfg.plane.HostVMEnable)
6315                         s->HostVMInefficiencyFactor = mode_lib->ms.ReturnBWPerState[j] / s->VMDataOnlyReturnBWPerState;
6316
6317                 mode_lib->ms.ExtraLatency = CalculateExtraLatency(
6318                                 mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles,
6319                                 s->ReorderingBytes,
6320                                 mode_lib->ms.DCFCLKState[j],
6321                                 mode_lib->ms.TotalNumberOfActiveDPP[j],
6322                                 mode_lib->ms.ip.pixel_chunk_size_kbytes,
6323                                 mode_lib->ms.TotalNumberOfDCCActiveDPP[j],
6324                                 mode_lib->ms.ip.meta_chunk_size_kbytes,
6325                                 mode_lib->ms.ReturnBWPerState[j],
6326                                 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
6327                                 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
6328                                 mode_lib->ms.num_active_planes,
6329                                 mode_lib->ms.NoOfDPPThisState,
6330                                 mode_lib->ms.dpte_group_bytes,
6331                                 s->HostVMInefficiencyFactor,
6332                                 mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024,
6333                                 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels);
6334
6335                 s->NextMaxVStartup = s->MaxVStartupAllPlanes[j];
6336                 s->MaxVStartup = 0;
6337                 s->AllPrefetchModeTested = true;
6338                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6339                         CalculatePrefetchMode(mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k], &s->MinPrefetchMode[k], &s->MaxPrefetchMode[k]);
6340                         s->NextPrefetchMode[k] = s->MinPrefetchMode[k];
6341                 }
6342
6343                 do {
6344                         s->MaxVStartup = s->NextMaxVStartup;
6345                         s->AllPrefetchModeTested = true;
6346
6347                         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6348                                 mode_lib->ms.PrefetchMode[k] = s->NextPrefetchMode[k];
6349                                 mode_lib->ms.TWait = CalculateTWait(
6350                                                                 mode_lib->ms.PrefetchMode[k],
6351                                                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
6352                                                                 mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
6353                                                                 mode_lib->ms.cache_display_cfg.timing.DRRDisplay[k],
6354                                                                 mode_lib->ms.state.dram_clock_change_latency_us,
6355                                                                 mode_lib->ms.state.fclk_change_latency_us,
6356                                                                 mode_lib->ms.UrgLatency,
6357                                                                 mode_lib->ms.state.sr_enter_plus_exit_time_us);
6358
6359                                 myPipe = &s->myPipe;
6360                                 myPipe->Dppclk = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
6361                                 myPipe->Dispclk = mode_lib->ms.RequiredDISPCLK[j];
6362                                 myPipe->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
6363                                 myPipe->DCFClkDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
6364                                 myPipe->DPPPerSurface = mode_lib->ms.NoOfDPP[j][k];
6365                                 myPipe->ScalerEnabled = mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k];
6366                                 myPipe->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
6367                                 myPipe->BlockWidth256BytesY = mode_lib->ms.Read256BlockWidthY[k];
6368                                 myPipe->BlockHeight256BytesY = mode_lib->ms.Read256BlockHeightY[k];
6369                                 myPipe->BlockWidth256BytesC = mode_lib->ms.Read256BlockWidthC[k];
6370                                 myPipe->BlockHeight256BytesC = mode_lib->ms.Read256BlockHeightC[k];
6371                                 myPipe->InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
6372                                 myPipe->NumberOfCursors = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k];
6373                                 myPipe->VBlank = mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k];
6374                                 myPipe->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
6375                                 myPipe->HActive = mode_lib->ms.cache_display_cfg.timing.HActive[k];
6376                                 myPipe->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
6377                                 myPipe->ODMMode = mode_lib->ms.ODMModePerState[k];
6378                                 myPipe->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
6379                                 myPipe->BytePerPixelY = mode_lib->ms.BytePerPixelY[k];
6380                                 myPipe->BytePerPixelC = mode_lib->ms.BytePerPixelC[k];
6381                                 myPipe->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
6382
6383 #ifdef __DML_VBA_DEBUG__
6384                                 dml_print("DML::%s: Calling CalculatePrefetchSchedule for j=%u, k=%u\n", __func__, j, k);
6385                                 dml_print("DML::%s: MaximumVStartup = %u\n", __func__, s->MaximumVStartup[j][k]);
6386                                 dml_print("DML::%s: MaxVStartup = %u\n", __func__, s->MaxVStartup);
6387                                 dml_print("DML::%s: NextPrefetchMode = %u\n", __func__, s->NextPrefetchMode[k]);
6388                                 dml_print("DML::%s: AllowForPStateChangeOrStutterInVBlank = %u\n", __func__, mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k]);
6389                                 dml_print("DML::%s: PrefetchMode = %u\n", __func__, mode_lib->ms.PrefetchMode[k]);
6390 #endif
6391
6392                                 CalculatePrefetchSchedule_params->HostVMInefficiencyFactor = s->HostVMInefficiencyFactor;
6393                                 CalculatePrefetchSchedule_params->myPipe = myPipe;
6394                                 CalculatePrefetchSchedule_params->VStartup = (dml_uint_t)(dml_min(s->MaxVStartup, s->MaximumVStartup[j][k]));
6395                                 CalculatePrefetchSchedule_params->MaxVStartup = s->MaximumVStartup[j][k];
6396                                 CalculatePrefetchSchedule_params->DSTXAfterScaler = &s->DSTXAfterScaler[k];
6397                                 CalculatePrefetchSchedule_params->DSTYAfterScaler = &s->DSTYAfterScaler[k];
6398                                 CalculatePrefetchSchedule_params->prefetch_vmrow_bw = &mode_lib->ms.prefetch_vmrow_bw[k];
6399                                 CalculatePrefetchSchedule_params->Tdmdl_vm = &s->dummy_single[0];
6400                                 CalculatePrefetchSchedule_params->Tdmdl = &s->dummy_single[1];
6401                                 CalculatePrefetchSchedule_params->TSetup = &s->dummy_single[2];
6402                                 CalculatePrefetchSchedule_params->VUpdateOffsetPix = &s->dummy_integer[0];
6403                                 CalculatePrefetchSchedule_params->VUpdateWidthPix = &s->dummy_integer[1];
6404                                 CalculatePrefetchSchedule_params->VReadyOffsetPix = &s->dummy_integer[2];
6405
6406                                 set_calculate_prefetch_schedule_params(mode_lib, CalculatePrefetchSchedule_params, j, k);
6407
6408                                 mode_lib->ms.support.NoTimeForPrefetch[j][k] =
6409                                                                 CalculatePrefetchSchedule(&mode_lib->scratch,
6410                                                                 CalculatePrefetchSchedule_params);
6411                         }
6412
6413                         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6414                                         CalculateUrgentBurstFactor(
6415                                                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
6416                                                         mode_lib->ms.swath_width_luma_ub_this_state[k],
6417                                                         mode_lib->ms.swath_width_chroma_ub_this_state[k],
6418                                                         mode_lib->ms.SwathHeightYThisState[k],
6419                                                         mode_lib->ms.SwathHeightCThisState[k],
6420                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6421                                                         mode_lib->ms.UrgLatency,
6422                                                         mode_lib->ms.ip.cursor_buffer_size,
6423                                                         mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
6424                                                         mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
6425                                                         mode_lib->ms.VRatioPreY[j][k],
6426                                                         mode_lib->ms.VRatioPreC[j][k],
6427                                                         mode_lib->ms.BytePerPixelInDETY[k],
6428                                                         mode_lib->ms.BytePerPixelInDETC[k],
6429                                                         mode_lib->ms.DETBufferSizeYThisState[k],
6430                                                         mode_lib->ms.DETBufferSizeCThisState[k],
6431                                                         /* Output */
6432                                                         &mode_lib->ms.UrgentBurstFactorCursorPre[k],
6433                                                         &mode_lib->ms.UrgentBurstFactorLumaPre[k],
6434                                                         &mode_lib->ms.UrgentBurstFactorChroma[k],
6435                                                         &mode_lib->ms.NotUrgentLatencyHidingPre[k]);
6436
6437                                         mode_lib->ms.cursor_bw_pre[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] *
6438                                                                                                         mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
6439                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.VRatioPreY[j][k];
6440                         }
6441
6442                         {
6443                         CalculatePrefetchBandwithSupport(
6444                                 mode_lib->ms.num_active_planes,
6445                                 mode_lib->ms.ReturnBWPerState[j],
6446                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
6447                                 mode_lib->ms.NotUrgentLatencyHidingPre,
6448                                 mode_lib->ms.ReadBandwidthLuma,
6449                                 mode_lib->ms.ReadBandwidthChroma,
6450                                 mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
6451                                 mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
6452                                 mode_lib->ms.cursor_bw,
6453                                 mode_lib->ms.meta_row_bandwidth_this_state,
6454                                 mode_lib->ms.dpte_row_bandwidth_this_state,
6455                                 mode_lib->ms.cursor_bw_pre,
6456                                 mode_lib->ms.prefetch_vmrow_bw,
6457                                 mode_lib->ms.NoOfDPPThisState,
6458                                 mode_lib->ms.UrgentBurstFactorLuma,
6459                                 mode_lib->ms.UrgentBurstFactorChroma,
6460                                 mode_lib->ms.UrgentBurstFactorCursor,
6461                                 mode_lib->ms.UrgentBurstFactorLumaPre,
6462                                 mode_lib->ms.UrgentBurstFactorChromaPre,
6463                                 mode_lib->ms.UrgentBurstFactorCursorPre,
6464
6465                                 /* output */
6466                                 &s->dummy_single[0], // dml_float_t *PrefetchBandwidth
6467                                 &s->dummy_single[1], // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
6468                                 &mode_lib->mp.FractionOfUrgentBandwidth, // dml_float_t *FractionOfUrgentBandwidth
6469                                 &mode_lib->ms.support.PrefetchSupported[j]);
6470                         }
6471
6472                         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6473                                 if (mode_lib->ms.LineTimesForPrefetch[k] < 2.0
6474                                         || mode_lib->ms.LinesForMetaPTE[k] >= 32.0
6475                                         || mode_lib->ms.LinesForMetaAndDPTERow[k] >= 16.0
6476                                         || mode_lib->ms.support.NoTimeForPrefetch[j][k] == true) {
6477                                                 mode_lib->ms.support.PrefetchSupported[j] = false;
6478                                 }
6479                         }
6480
6481                         mode_lib->ms.support.DynamicMetadataSupported[j] = true;
6482                         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6483                                 if (mode_lib->ms.support.NoTimeForDynamicMetadata[j][k] == true) {
6484                                         mode_lib->ms.support.DynamicMetadataSupported[j] = false;
6485                                 }
6486                         }
6487
6488                         mode_lib->ms.support.VRatioInPrefetchSupported[j] = true;
6489                         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6490                                 if (mode_lib->ms.support.NoTimeForPrefetch[j][k] == true ||
6491                                         mode_lib->ms.VRatioPreY[j][k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
6492                                         mode_lib->ms.VRatioPreC[j][k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
6493                                         ((s->MaxVStartup < s->MaximumVStartup[j][k] || mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal == 0) &&
6494                                                 (mode_lib->ms.VRatioPreY[j][k] > __DML_MAX_VRATIO_PRE__ || mode_lib->ms.VRatioPreC[j][k] > __DML_MAX_VRATIO_PRE__))) {
6495                                                         mode_lib->ms.support.VRatioInPrefetchSupported[j] = false;
6496                                 }
6497                         }
6498
6499                         s->AnyLinesForVMOrRowTooLarge = false;
6500                         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6501                                 if (mode_lib->ms.LinesForMetaAndDPTERow[k] >= 16 || mode_lib->ms.LinesForMetaPTE[k] >= 32) {
6502                                         s->AnyLinesForVMOrRowTooLarge = true;
6503                                 }
6504                         }
6505
6506                         if (mode_lib->ms.support.PrefetchSupported[j] == true && mode_lib->ms.support.VRatioInPrefetchSupported[j] == true) {
6507                                 mode_lib->ms.BandwidthAvailableForImmediateFlip = CalculateBandwidthAvailableForImmediateFlip(
6508                                                 mode_lib->ms.num_active_planes,
6509                                                 mode_lib->ms.ReturnBWPerState[j],
6510                                                 mode_lib->ms.ReadBandwidthLuma,
6511                                                 mode_lib->ms.ReadBandwidthChroma,
6512                                                 mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
6513                                                 mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
6514                                                 mode_lib->ms.cursor_bw,
6515                                                 mode_lib->ms.cursor_bw_pre,
6516                                                 mode_lib->ms.NoOfDPPThisState,
6517                                                 mode_lib->ms.UrgentBurstFactorLuma,
6518                                                 mode_lib->ms.UrgentBurstFactorChroma,
6519                                                 mode_lib->ms.UrgentBurstFactorCursor,
6520                                                 mode_lib->ms.UrgentBurstFactorLumaPre,
6521                                                 mode_lib->ms.UrgentBurstFactorChromaPre,
6522                                                 mode_lib->ms.UrgentBurstFactorCursorPre);
6523
6524                                 mode_lib->ms.TotImmediateFlipBytes = 0;
6525                                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6526                                         if (!(mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_not_required)) {
6527                                                 mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k] + mode_lib->ms.MetaRowBytes[j][k];
6528                                                 if (mode_lib->ms.use_one_row_for_frame_flip[j][k]) {
6529                                                         mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * (2 * mode_lib->ms.DPTEBytesPerRow[j][k]);
6530                                                 } else {
6531                                                         mode_lib->ms.TotImmediateFlipBytes = mode_lib->ms.TotImmediateFlipBytes + mode_lib->ms.NoOfDPP[j][k] * mode_lib->ms.DPTEBytesPerRow[j][k];
6532                                                 }
6533                                         }
6534                                 }
6535
6536                                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6537                                         CalculateFlipSchedule(
6538                                                 s->HostVMInefficiencyFactor,
6539                                                 mode_lib->ms.ExtraLatency,
6540                                                 mode_lib->ms.UrgLatency,
6541                                                 mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
6542                                                 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
6543                                                 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels,
6544                                                 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
6545                                                 mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024,
6546                                                 mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k],
6547                                                 mode_lib->ms.MetaRowBytes[j][k],
6548                                                 mode_lib->ms.DPTEBytesPerRow[j][k],
6549                                                 mode_lib->ms.BandwidthAvailableForImmediateFlip,
6550                                                 mode_lib->ms.TotImmediateFlipBytes,
6551                                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
6552                                                 (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]),
6553                                                 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
6554                                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
6555                                                 mode_lib->ms.Tno_bw[k],
6556                                                 mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
6557                                                 mode_lib->ms.dpte_row_height[k],
6558                                                 mode_lib->ms.meta_row_height[k],
6559                                                 mode_lib->ms.dpte_row_height_chroma[k],
6560                                                 mode_lib->ms.meta_row_height_chroma[k],
6561                                                 mode_lib->ms.use_one_row_for_frame_flip[j][k], // 24
6562
6563                                                 /* Output */
6564                                                 &mode_lib->ms.DestinationLinesToRequestVMInImmediateFlip[k],
6565                                                 &mode_lib->ms.DestinationLinesToRequestRowInImmediateFlip[k],
6566                                                 &mode_lib->ms.final_flip_bw[k],
6567                                                 &mode_lib->ms.ImmediateFlipSupportedForPipe[k]);
6568                                 }
6569
6570                                 {
6571                                 CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
6572                                                                                                         mode_lib->ms.ReturnBWPerState[j],
6573                                                                                                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
6574                                                                                                         mode_lib->ms.policy.ImmediateFlipRequirement,
6575                                                                                                         mode_lib->ms.final_flip_bw,
6576                                                                                                         mode_lib->ms.ReadBandwidthLuma,
6577                                                                                                         mode_lib->ms.ReadBandwidthChroma,
6578                                                                                                         mode_lib->ms.RequiredPrefetchPixelDataBWLuma,
6579                                                                                                         mode_lib->ms.RequiredPrefetchPixelDataBWChroma,
6580                                                                                                         mode_lib->ms.cursor_bw,
6581                                                                                                         mode_lib->ms.meta_row_bandwidth_this_state,
6582                                                                                                         mode_lib->ms.dpte_row_bandwidth_this_state,
6583                                                                                                         mode_lib->ms.cursor_bw_pre,
6584                                                                                                         mode_lib->ms.prefetch_vmrow_bw,
6585                                                                                                         mode_lib->ms.NoOfDPP[j], // VBA_ERROR DPPPerSurface is not assigned at this point, should use NoOfDpp here
6586                                                                                                         mode_lib->ms.UrgentBurstFactorLuma,
6587                                                                                                         mode_lib->ms.UrgentBurstFactorChroma,
6588                                                                                                         mode_lib->ms.UrgentBurstFactorCursor,
6589                                                                                                         mode_lib->ms.UrgentBurstFactorLumaPre,
6590                                                                                                         mode_lib->ms.UrgentBurstFactorChromaPre,
6591                                                                                                         mode_lib->ms.UrgentBurstFactorCursorPre,
6592
6593                                                                                                         /* output */
6594                                                                                                         &s->dummy_single[0], // dml_float_t *TotalBandwidth
6595                                                                                                         &s->dummy_single[1], // dml_float_t *TotalBandwidthNotIncludingMALLPrefetch
6596                                                                                                         &s->dummy_single[2], // dml_float_t *FractionOfUrgentBandwidth
6597                                                                                                         &mode_lib->ms.support.ImmediateFlipSupportedForState[j]); // dml_bool_t *ImmediateFlipBandwidthSupport
6598                                 }
6599
6600                                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6601                                         if (!(mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_not_required) && (mode_lib->ms.ImmediateFlipSupportedForPipe[k] == false))
6602                                                 mode_lib->ms.support.ImmediateFlipSupportedForState[j] = false;
6603                                 }
6604
6605                         } else { // if prefetch not support, assume iflip not supported
6606                                 mode_lib->ms.support.ImmediateFlipSupportedForState[j] = false;
6607                         }
6608
6609                         if (s->MaxVStartup <= __DML_VBA_MIN_VSTARTUP__ || s->AnyLinesForVMOrRowTooLarge == false) {
6610                                 s->NextMaxVStartup = s->MaxVStartupAllPlanes[j];
6611                                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6612                                         s->NextPrefetchMode[k] = s->NextPrefetchMode[k] + 1;
6613
6614                                         if (s->NextPrefetchMode[k] <= s->MaxPrefetchMode[k])
6615                                                 s->AllPrefetchModeTested = false;
6616                                 }
6617                         } else {
6618                                 s->NextMaxVStartup = s->NextMaxVStartup - 1;
6619                         }
6620                 } while (!((mode_lib->ms.support.PrefetchSupported[j] == true && mode_lib->ms.support.DynamicMetadataSupported[j] == true &&
6621                                         mode_lib->ms.support.VRatioInPrefetchSupported[j] == true &&
6622                                         // consider flip support is okay if when there is no hostvm and the user does't require a iflip OR the flip bw is ok
6623                                         // If there is hostvm, DCN needs to support iflip for invalidation
6624                                         ((s->ImmediateFlipRequiredFinal) || mode_lib->ms.support.ImmediateFlipSupportedForState[j] == true)) ||
6625                                         (s->NextMaxVStartup == s->MaxVStartupAllPlanes[j] && s->AllPrefetchModeTested)));
6626
6627                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6628                         mode_lib->ms.use_one_row_for_frame_this_state[k] = mode_lib->ms.use_one_row_for_frame[j][k];
6629                 }
6630
6631                 s->mSOCParameters.UrgentLatency = mode_lib->ms.UrgLatency;
6632                 s->mSOCParameters.ExtraLatency = mode_lib->ms.ExtraLatency;
6633                 s->mSOCParameters.WritebackLatency = mode_lib->ms.state.writeback_latency_us;
6634                 s->mSOCParameters.DRAMClockChangeLatency = mode_lib->ms.state.dram_clock_change_latency_us;
6635                 s->mSOCParameters.FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
6636                 s->mSOCParameters.SRExitTime = mode_lib->ms.state.sr_exit_time_us;
6637                 s->mSOCParameters.SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
6638                 s->mSOCParameters.SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
6639                 s->mSOCParameters.SREnterPlusExitZ8Time = mode_lib->ms.state.sr_enter_plus_exit_z8_time_us;
6640                 s->mSOCParameters.USRRetrainingLatency = mode_lib->ms.state.usr_retraining_latency_us;
6641                 s->mSOCParameters.SMNLatency = mode_lib->ms.soc.smn_latency_us;
6642
6643                 CalculateWatermarks_params->USRRetrainingRequiredFinal = mode_lib->ms.policy.USRRetrainingRequiredFinal;
6644                 CalculateWatermarks_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
6645                 CalculateWatermarks_params->PrefetchMode = mode_lib->ms.PrefetchMode;
6646                 CalculateWatermarks_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
6647                 CalculateWatermarks_params->MaxLineBufferLines = mode_lib->ms.ip.max_line_buffer_lines;
6648                 CalculateWatermarks_params->LineBufferSize = mode_lib->ms.ip.line_buffer_size_bits;
6649                 CalculateWatermarks_params->WritebackInterfaceBufferSize = mode_lib->ms.ip.writeback_interface_buffer_size_kbytes;
6650                 CalculateWatermarks_params->DCFCLK = mode_lib->ms.DCFCLKState[j];
6651                 CalculateWatermarks_params->ReturnBW = mode_lib->ms.ReturnBWPerState[j];
6652                 CalculateWatermarks_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
6653                 CalculateWatermarks_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
6654                 CalculateWatermarks_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
6655                 CalculateWatermarks_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
6656                 CalculateWatermarks_params->meta_row_height = mode_lib->ms.meta_row_height;
6657                 CalculateWatermarks_params->meta_row_height_chroma = mode_lib->ms.meta_row_height_chroma;
6658                 CalculateWatermarks_params->mmSOCParameters = s->mSOCParameters;
6659                 CalculateWatermarks_params->WritebackChunkSize = mode_lib->ms.ip.writeback_chunk_size_kbytes;
6660                 CalculateWatermarks_params->SOCCLK = mode_lib->ms.state.socclk_mhz;
6661                 CalculateWatermarks_params->DCFClkDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep[j];
6662                 CalculateWatermarks_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeYThisState;
6663                 CalculateWatermarks_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeCThisState;
6664                 CalculateWatermarks_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState;
6665                 CalculateWatermarks_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState;
6666                 CalculateWatermarks_params->LBBitPerPixel = mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel;
6667                 CalculateWatermarks_params->SwathWidthY = mode_lib->ms.SwathWidthYThisState;
6668                 CalculateWatermarks_params->SwathWidthC = mode_lib->ms.SwathWidthCThisState;
6669                 CalculateWatermarks_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
6670                 CalculateWatermarks_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
6671                 CalculateWatermarks_params->VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps;
6672                 CalculateWatermarks_params->VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma;
6673                 CalculateWatermarks_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
6674                 CalculateWatermarks_params->VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma;
6675                 CalculateWatermarks_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
6676                 CalculateWatermarks_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
6677                 CalculateWatermarks_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
6678                 CalculateWatermarks_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
6679                 CalculateWatermarks_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
6680                 CalculateWatermarks_params->DPPPerSurface = mode_lib->ms.NoOfDPPThisState;
6681                 CalculateWatermarks_params->BytePerPixelDETY = mode_lib->ms.BytePerPixelInDETY;
6682                 CalculateWatermarks_params->BytePerPixelDETC = mode_lib->ms.BytePerPixelInDETC;
6683                 CalculateWatermarks_params->DSTXAfterScaler = s->DSTXAfterScaler;
6684                 CalculateWatermarks_params->DSTYAfterScaler = s->DSTYAfterScaler;
6685                 CalculateWatermarks_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
6686                 CalculateWatermarks_params->WritebackPixelFormat = mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat;
6687                 CalculateWatermarks_params->WritebackDestinationWidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth;
6688                 CalculateWatermarks_params->WritebackDestinationHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight;
6689                 CalculateWatermarks_params->WritebackSourceHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight;
6690                 CalculateWatermarks_params->UnboundedRequestEnabled = mode_lib->ms.UnboundedRequestEnabledThisState;
6691                 CalculateWatermarks_params->CompressedBufferSizeInkByte = mode_lib->ms.CompressedBufferSizeInkByteThisState;
6692
6693                 // Output
6694                 CalculateWatermarks_params->Watermark = &s->dummy_watermark; // Watermarks *Watermark
6695                 CalculateWatermarks_params->DRAMClockChangeSupport = &mode_lib->ms.support.DRAMClockChangeSupport[j];
6696                 CalculateWatermarks_params->MaxActiveDRAMClockChangeLatencySupported = &s->dummy_single_array[0]; // dml_float_t *MaxActiveDRAMClockChangeLatencySupported[]
6697                 CalculateWatermarks_params->SubViewportLinesNeededInMALL = &mode_lib->ms.SubViewportLinesNeededInMALL[j]; // dml_uint_t SubViewportLinesNeededInMALL[]
6698                 CalculateWatermarks_params->FCLKChangeSupport = &mode_lib->ms.support.FCLKChangeSupport[j];
6699                 CalculateWatermarks_params->MaxActiveFCLKChangeLatencySupported = &s->dummy_single[0]; // dml_float_t *MaxActiveFCLKChangeLatencySupported
6700                 CalculateWatermarks_params->USRRetrainingSupport = &mode_lib->ms.support.USRRetrainingSupport[j];
6701                 CalculateWatermarks_params->ActiveDRAMClockChangeLatencyMargin = mode_lib->ms.support.ActiveDRAMClockChangeLatencyMargin;
6702
6703                 CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(&mode_lib->scratch,
6704                         CalculateWatermarks_params);
6705
6706         } // for j
6707 }
6708
6709 /// @brief The Mode Support function.
6710 dml_bool_t dml_core_mode_support(struct display_mode_lib_st *mode_lib)
6711 {
6712         struct dml_core_mode_support_locals_st *s = &mode_lib->scratch.dml_core_mode_support_locals;
6713         struct UseMinimumDCFCLK_params_st *UseMinimumDCFCLK_params = &mode_lib->scratch.UseMinimumDCFCLK_params;
6714         struct CalculateSwathAndDETConfiguration_params_st *CalculateSwathAndDETConfiguration_params = &mode_lib->scratch.CalculateSwathAndDETConfiguration_params;
6715         struct CalculateVMRowAndSwath_params_st *CalculateVMRowAndSwath_params = &mode_lib->scratch.CalculateVMRowAndSwath_params;
6716
6717         dml_uint_t j, k, m;
6718
6719         mode_lib->ms.num_active_planes = dml_get_num_active_planes(&mode_lib->ms.cache_display_cfg);
6720         dml_print("DML::%s: num_active_planes = %u\n", __func__, mode_lib->ms.num_active_planes);
6721
6722         CalculateMaxDETAndMinCompressedBufferSize(
6723                                                                 mode_lib->ms.ip.config_return_buffer_size_in_kbytes,
6724                                                                 mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes,
6725                                                                 mode_lib->ms.ip.rob_buffer_size_kbytes,
6726                                                                 mode_lib->ms.ip.max_num_dpp,
6727                                                                 mode_lib->ms.policy.NomDETInKByteOverrideEnable,   // VBA_DELTA
6728                                                                 mode_lib->ms.policy.NomDETInKByteOverrideValue,    // VBA_DELTA
6729
6730                                                                 /* Output */
6731                                                                 &mode_lib->ms.MaxTotalDETInKByte,
6732                                                                 &mode_lib->ms.NomDETInKByte,
6733                                                                 &mode_lib->ms.MinCompressedBufferSizeInKByte);
6734
6735         PixelClockAdjustmentForProgressiveToInterlaceUnit(&mode_lib->ms.cache_display_cfg, mode_lib->ms.ip.ptoi_supported);
6736
6737
6738         /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
6739
6740         /*Scale Ratio, taps Support Check*/
6741         mode_lib->ms.support.ScaleRatioAndTapsSupport = true;
6742         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6743                 if (mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k] == false
6744                                 && ((mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
6745                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
6746                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
6747                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
6748                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8
6749                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
6750                                                 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha)
6751                                                 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] != 1.0
6752                                                 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] != 1.0
6753                                                 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] != 1.0
6754                                                 || mode_lib->ms.cache_display_cfg.plane.VTaps[k] != 1.0)) {
6755                         mode_lib->ms.support.ScaleRatioAndTapsSupport = false;
6756                 } else if (mode_lib->ms.cache_display_cfg.plane.VTaps[k] < 1.0 || mode_lib->ms.cache_display_cfg.plane.VTaps[k] > 8.0
6757                                 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] < 1.0 || mode_lib->ms.cache_display_cfg.plane.HTaps[k] > 8.0
6758                                 || (mode_lib->ms.cache_display_cfg.plane.HTaps[k] > 1.0 && (mode_lib->ms.cache_display_cfg.plane.HTaps[k] % 2) == 1)
6759                                 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] > mode_lib->ms.ip.max_hscl_ratio
6760                                 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] > mode_lib->ms.ip.max_vscl_ratio
6761                                 || mode_lib->ms.cache_display_cfg.plane.HRatio[k] > mode_lib->ms.cache_display_cfg.plane.HTaps[k]
6762                                 || mode_lib->ms.cache_display_cfg.plane.VRatio[k] > mode_lib->ms.cache_display_cfg.plane.VTaps[k]
6763                                 || (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
6764                                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
6765                                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
6766                                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
6767                                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8
6768                                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
6769                                         && (mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k] < 1 || mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k] > 8 || mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] < 1 || mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] > 8 ||
6770                                                 (mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] > 1 && mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] % 2 == 1) ||
6771                                         mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k] > mode_lib->ms.ip.max_hscl_ratio ||
6772                                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k] > mode_lib->ms.ip.max_vscl_ratio ||
6773                                         mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k] > mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k] ||
6774                                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k] > mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k]))) {
6775                         mode_lib->ms.support.ScaleRatioAndTapsSupport = false;
6776                 }
6777         }
6778
6779         /*Source Format, Pixel Format and Scan Support Check*/
6780         mode_lib->ms.support.SourceFormatPixelAndScanSupport = true;
6781         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6782                         if (mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear && (!(!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k])) || mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true)) {
6783                         mode_lib->ms.support.SourceFormatPixelAndScanSupport = false;
6784                 }
6785         }
6786
6787         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6788                 CalculateBytePerPixelAndBlockSizes(
6789                                                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
6790                                                                 mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
6791
6792                                                                 /* Output */
6793                                                                 &mode_lib->ms.BytePerPixelY[k],
6794                                                                 &mode_lib->ms.BytePerPixelC[k],
6795                                                                 &mode_lib->ms.BytePerPixelInDETY[k],
6796                                                                 &mode_lib->ms.BytePerPixelInDETC[k],
6797                                                                 &mode_lib->ms.Read256BlockHeightY[k],
6798                                                                 &mode_lib->ms.Read256BlockHeightC[k],
6799                                                                 &mode_lib->ms.Read256BlockWidthY[k],
6800                                                                 &mode_lib->ms.Read256BlockWidthC[k],
6801                                                                 &mode_lib->ms.MacroTileHeightY[k],
6802                                                                 &mode_lib->ms.MacroTileHeightC[k],
6803                                                                 &mode_lib->ms.MacroTileWidthY[k],
6804                                                                 &mode_lib->ms.MacroTileWidthC[k]);
6805         }
6806
6807         /*Bandwidth Support Check*/
6808         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6809                 if (!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k])) {
6810                         mode_lib->ms.SwathWidthYSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportWidth[k];
6811                         mode_lib->ms.SwathWidthCSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma[k];
6812                 } else {
6813                         mode_lib->ms.SwathWidthYSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
6814                         mode_lib->ms.SwathWidthCSingleDPP[k] = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
6815                 }
6816         }
6817         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6818                 mode_lib->ms.ReadBandwidthLuma[k] = mode_lib->ms.SwathWidthYSingleDPP[k] * dml_ceil(mode_lib->ms.BytePerPixelInDETY[k], 1.0) / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
6819                 mode_lib->ms.ReadBandwidthChroma[k] = mode_lib->ms.SwathWidthYSingleDPP[k] / 2 * dml_ceil(mode_lib->ms.BytePerPixelInDETC[k], 2.0) / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k] / 2.0;
6820         }
6821         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6822                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true
6823                                 && mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k] == dml_444_64) {
6824                         mode_lib->ms.WriteBandwidth[k] = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k]
6825                                         * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k]
6826                                         / (mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k]
6827                                                         * mode_lib->ms.cache_display_cfg.timing.HTotal[k]
6828                                                         / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 8.0;
6829                 } else if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6830                         mode_lib->ms.WriteBandwidth[k] = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k]
6831                                         * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k]
6832                                         / (mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k]
6833                                                         * mode_lib->ms.cache_display_cfg.timing.HTotal[k]
6834                                                         / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 4.0;
6835                 } else {
6836                         mode_lib->ms.WriteBandwidth[k] = 0.0;
6837                 }
6838         }
6839
6840         /*Writeback Latency support check*/
6841         mode_lib->ms.support.WritebackLatencySupport = true;
6842         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6843                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true &&
6844                         (mode_lib->ms.WriteBandwidth[k] > mode_lib->ms.ip.writeback_interface_buffer_size_kbytes * 1024 / mode_lib->ms.state.writeback_latency_us)) {
6845                         mode_lib->ms.support.WritebackLatencySupport = false;
6846                 }
6847         }
6848
6849         /*Writeback Mode Support Check*/
6850         s->TotalNumberOfActiveWriteback = 0;
6851         for (k = 0; k <= (dml_uint_t) mode_lib->ms.num_active_planes - 1; k++) {
6852                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6853                         s->TotalNumberOfActiveWriteback = s->TotalNumberOfActiveWriteback + 1;
6854                 }
6855    }
6856
6857         mode_lib->ms.support.EnoughWritebackUnits = 1;
6858         if (s->TotalNumberOfActiveWriteback > (dml_uint_t) mode_lib->ms.ip.max_num_wb) {
6859                 mode_lib->ms.support.EnoughWritebackUnits = false;
6860         }
6861
6862         /*Writeback Scale Ratio and Taps Support Check*/
6863         mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = true;
6864         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6865                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
6866                         if (mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] > mode_lib->ms.ip.writeback_max_hscl_ratio
6867                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] > mode_lib->ms.ip.writeback_max_vscl_ratio
6868                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] < mode_lib->ms.ip.writeback_min_hscl_ratio
6869                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] < mode_lib->ms.ip.writeback_min_vscl_ratio
6870                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] > (dml_uint_t) mode_lib->ms.ip.writeback_max_hscl_taps
6871                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k] > (dml_uint_t) mode_lib->ms.ip.writeback_max_vscl_taps
6872                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k] > (dml_uint_t) mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k]
6873                                 || mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k] > (dml_uint_t) mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k]
6874                                 || (mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] > 2.0 && ((mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k] % 2) == 1))) {
6875                                 mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = false;
6876                         }
6877                         if (2.0 * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * (mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k] - 1) * 57 > mode_lib->ms.ip.writeback_line_buffer_buffer_size) {
6878                                 mode_lib->ms.support.WritebackScaleRatioAndTapsSupport = false;
6879                         }
6880                 }
6881         }
6882
6883         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6884                 CalculateSinglePipeDPPCLKAndSCLThroughput(
6885                                 mode_lib->ms.cache_display_cfg.plane.HRatio[k],
6886                                 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k],
6887                                 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
6888                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
6889                                 mode_lib->ms.ip.max_dchub_pscl_bw_pix_per_clk,
6890                                 mode_lib->ms.ip.max_pscl_lb_bw_pix_per_clk,
6891                                 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
6892                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
6893                                 mode_lib->ms.cache_display_cfg.plane.HTaps[k],
6894                                 mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k],
6895                                 mode_lib->ms.cache_display_cfg.plane.VTaps[k],
6896                                 mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k],
6897                                 /* Output */
6898                                 &mode_lib->ms.PSCL_FACTOR[k],
6899                                 &mode_lib->ms.PSCL_FACTOR_CHROMA[k],
6900                                 &mode_lib->ms.MinDPPCLKUsingSingleDPP[k]);
6901         }
6902
6903         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
6904                 if (mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear) {
6905                         s->MaximumSwathWidthSupportLuma = 8192;
6906                 } else if (!dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelC[k] > 0 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha) {
6907                         s->MaximumSwathWidthSupportLuma = 7680;
6908                 } else if (dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelC[k] > 0 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe_alpha) {
6909                         s->MaximumSwathWidthSupportLuma = 4320;
6910                 } else if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_rgbe_alpha) {
6911                         s->MaximumSwathWidthSupportLuma = 3840;
6912                 } else if (dml_is_vertical_rotation(mode_lib->ms.cache_display_cfg.plane.SourceScan[k]) && mode_lib->ms.BytePerPixelY[k] == 8 && mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
6913                         s->MaximumSwathWidthSupportLuma = 3072;
6914                 } else {
6915                         s->MaximumSwathWidthSupportLuma = 6144;
6916                 }
6917
6918        if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_8 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_10 || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_12) {
6919                         s->MaximumSwathWidthSupportChroma = (dml_uint_t)(s->MaximumSwathWidthSupportLuma / 2.0);
6920                 } else {
6921                         s->MaximumSwathWidthSupportChroma = s->MaximumSwathWidthSupportLuma;
6922        }
6923                 mode_lib->ms.MaximumSwathWidthInLineBufferLuma = mode_lib->ms.ip.line_buffer_size_bits * dml_max(mode_lib->ms.cache_display_cfg.plane.HRatio[k], 1.0) / mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel[k] /
6924                                                                                                                         (mode_lib->ms.cache_display_cfg.plane.VTaps[k] + dml_max(dml_ceil(mode_lib->ms.cache_display_cfg.plane.VRatio[k], 1.0) - 2, 0.0));
6925                 if (mode_lib->ms.BytePerPixelC[k] == 0.0) {
6926                         mode_lib->ms.MaximumSwathWidthInLineBufferChroma = 0;
6927                 } else {
6928                         mode_lib->ms.MaximumSwathWidthInLineBufferChroma =
6929                                                         mode_lib->ms.ip.line_buffer_size_bits
6930                                                                         * dml_max(mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k], 1.0)
6931                                                                         / mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel[k]
6932                                                                         / (mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k]
6933                                                                         + dml_max(dml_ceil(mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k], 1.0) - 2, 0.0));
6934                 }
6935                 mode_lib->ms.MaximumSwathWidthLuma[k] = dml_min(s->MaximumSwathWidthSupportLuma, mode_lib->ms.MaximumSwathWidthInLineBufferLuma);
6936                 mode_lib->ms.MaximumSwathWidthChroma[k] = dml_min(s->MaximumSwathWidthSupportChroma, mode_lib->ms.MaximumSwathWidthInLineBufferChroma);
6937         }
6938
6939         /*Number Of DSC Slices*/
6940         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
6941                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
6942                         if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 4800) {
6943                                 mode_lib->ms.support.NumberOfDSCSlices[k] = (dml_uint_t)(dml_ceil(mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 600, 4));
6944                         } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 2400) {
6945                                 mode_lib->ms.support.NumberOfDSCSlices[k] = 8;
6946                         } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 1200) {
6947                                 mode_lib->ms.support.NumberOfDSCSlices[k] = 4;
6948                         } else if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] > 340) {
6949                                 mode_lib->ms.support.NumberOfDSCSlices[k] = 2;
6950                         } else {
6951                                 mode_lib->ms.support.NumberOfDSCSlices[k] = 1;
6952                         }
6953                 } else {
6954                         mode_lib->ms.support.NumberOfDSCSlices[k] = 0;
6955                 }
6956         }
6957
6958         CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
6959         CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
6960         CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
6961         CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
6962         CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
6963         CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
6964         CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
6965         CalculateSwathAndDETConfiguration_params->ForceSingleDPP = 1;
6966         CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
6967         CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
6968         CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
6969         CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
6970         CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
6971         CalculateSwathAndDETConfiguration_params->Output = mode_lib->ms.cache_display_cfg.output.OutputEncoder;
6972         CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
6973         CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
6974         CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = mode_lib->ms.MaximumSwathWidthLuma;
6975         CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = mode_lib->ms.MaximumSwathWidthChroma;
6976         CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
6977         CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
6978         CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
6979         CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
6980         CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
6981         CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
6982         CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
6983         CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
6984         CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
6985         CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
6986         CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
6987         CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
6988         CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
6989         CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
6990         CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = mode_lib->ms.Read256BlockHeightY;
6991         CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = mode_lib->ms.Read256BlockHeightC;
6992         CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = mode_lib->ms.Read256BlockWidthY;
6993         CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = mode_lib->ms.Read256BlockWidthC;
6994         CalculateSwathAndDETConfiguration_params->ODMMode = s->dummy_odm_mode;
6995         CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
6996         CalculateSwathAndDETConfiguration_params->BytePerPixY = mode_lib->ms.BytePerPixelY;
6997         CalculateSwathAndDETConfiguration_params->BytePerPixC = mode_lib->ms.BytePerPixelC;
6998         CalculateSwathAndDETConfiguration_params->BytePerPixDETY = mode_lib->ms.BytePerPixelInDETY;
6999         CalculateSwathAndDETConfiguration_params->BytePerPixDETC = mode_lib->ms.BytePerPixelInDETC;
7000         CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
7001         CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
7002         CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
7003         CalculateSwathAndDETConfiguration_params->DPPPerSurface = s->dummy_integer_array[0];
7004         CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = s->dummy_integer_array[1];
7005         CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = s->dummy_integer_array[2];
7006         CalculateSwathAndDETConfiguration_params->SwathWidth = s->dummy_integer_array[3];
7007         CalculateSwathAndDETConfiguration_params->SwathWidthChroma = s->dummy_integer_array[4];
7008         CalculateSwathAndDETConfiguration_params->SwathHeightY = s->dummy_integer_array[5];
7009         CalculateSwathAndDETConfiguration_params->SwathHeightC = s->dummy_integer_array[6];
7010         CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = s->dummy_integer_array[7];
7011         CalculateSwathAndDETConfiguration_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeY;
7012         CalculateSwathAndDETConfiguration_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeC;
7013         CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &s->dummy_boolean[0];
7014         CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &s->dummy_integer[2];
7015         CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &s->dummy_integer[1];
7016         CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &s->dummy_integer[0];
7017         CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = mode_lib->ms.SingleDPPViewportSizeSupportPerSurface;
7018         CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &s->dummy_boolean[1];
7019
7020         CalculateSwathAndDETConfiguration(&mode_lib->scratch,
7021         CalculateSwathAndDETConfiguration_params); /* dml_bool_t *ViewportSizeSupport */
7022
7023         s->MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
7024         s->MPCCombineMethodAsPossible = false;
7025         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7026                 if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_as_needed_for_pstate_and_voltage)
7027                         s->MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
7028                 if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_as_possible)
7029                         s->MPCCombineMethodAsPossible = true;
7030         }
7031         mode_lib->ms.support.MPCCombineMethodIncompatible = s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && s->MPCCombineMethodAsPossible;
7032
7033         for (j = 0; j < 2; j++) {
7034                 mode_lib->ms.TotalNumberOfActiveDPP[j] = 0;
7035                 mode_lib->ms.support.TotalAvailablePipesSupport[j] = true;
7036
7037                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7038                         CalculateODMMode(
7039                                         mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit,
7040                                         mode_lib->ms.cache_display_cfg.timing.HActive[k],
7041                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
7042                                         mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
7043                                         mode_lib->ms.policy.ODMUse[k],
7044                                         mode_lib->ms.state.dispclk_mhz,
7045                                         mode_lib->ms.max_state.dispclk_mhz,
7046                                         false, // DSCEnable
7047                                         mode_lib->ms.TotalNumberOfActiveDPP[j],
7048                                         mode_lib->ms.ip.max_num_dpp,
7049                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7050                                         mode_lib->ms.soc.dcn_downspread_percent,
7051                                         mode_lib->ms.ip.dispclk_ramp_margin_percent,
7052                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
7053
7054                                         /* Output */
7055                                         &s->TotalAvailablePipesSupportNoDSC,
7056                                         &s->NumberOfDPPNoDSC,
7057                                         &s->ODMModeNoDSC,
7058                                         &s->RequiredDISPCLKPerSurfaceNoDSC);
7059
7060                         CalculateODMMode(
7061                                         mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit,
7062                                         mode_lib->ms.cache_display_cfg.timing.HActive[k],
7063                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
7064                                         mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
7065                                         mode_lib->ms.policy.ODMUse[k],
7066                                         mode_lib->ms.state.dispclk_mhz,
7067                                         mode_lib->ms.max_state.dispclk_mhz,
7068                                         true, // DSCEnable
7069                                         mode_lib->ms.TotalNumberOfActiveDPP[j],
7070                                         mode_lib->ms.ip.max_num_dpp,
7071                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7072                                         mode_lib->ms.soc.dcn_downspread_percent,
7073                                         mode_lib->ms.ip.dispclk_ramp_margin_percent,
7074                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
7075
7076                                         /* Output */
7077                                         &s->TotalAvailablePipesSupportDSC,
7078                                         &s->NumberOfDPPDSC,
7079                                         &s->ODMModeDSC,
7080                                         &s->RequiredDISPCLKPerSurfaceDSC);
7081
7082                         CalculateOutputLink(
7083                                         mode_lib->ms.state.phyclk_mhz,
7084                                         mode_lib->ms.state.phyclk_d18_mhz,
7085                                         mode_lib->ms.state.phyclk_d32_mhz,
7086                                         mode_lib->ms.soc.phy_downspread_percent,
7087                                         (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k),
7088                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
7089                                         mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
7090                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k],
7091                                         mode_lib->ms.cache_display_cfg.timing.HActive[k],
7092                                         mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k],
7093                                         mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k],
7094                                         mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
7095                                         mode_lib->ms.support.NumberOfDSCSlices[k],
7096                                         mode_lib->ms.cache_display_cfg.output.AudioSampleRate[k],
7097                                         mode_lib->ms.cache_display_cfg.output.AudioSampleLayout[k],
7098                                         s->ODMModeNoDSC,
7099                                         s->ODMModeDSC,
7100                                         mode_lib->ms.cache_display_cfg.output.DSCEnable[k],
7101                                         mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k],
7102                                         mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k],
7103
7104                                         /* Output */
7105                                         &mode_lib->ms.RequiresDSC[k],
7106                                         &mode_lib->ms.RequiresFEC[k],
7107                                         &mode_lib->ms.OutputBppPerState[k],
7108                                         &mode_lib->ms.OutputTypePerState[k], // VBA_DELTA, VBA uses a string to represent type and rate, but DML uses enum, don't want to rely on strng
7109                                         &mode_lib->ms.OutputRatePerState[k],
7110                                         &mode_lib->ms.RequiredSlots[k]);
7111
7112                         if (mode_lib->ms.RequiresDSC[k] == false) {
7113                                 mode_lib->ms.ODMModePerState[k] = s->ODMModeNoDSC;
7114                                 mode_lib->ms.RequiredDISPCLKPerSurface[j][k] = s->RequiredDISPCLKPerSurfaceNoDSC;
7115                                 if (!s->TotalAvailablePipesSupportNoDSC)
7116                                         mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
7117                                 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + s->NumberOfDPPNoDSC;
7118                         } else {
7119                                 mode_lib->ms.ODMModePerState[k] = s->ODMModeDSC;
7120                                 mode_lib->ms.RequiredDISPCLKPerSurface[j][k] = s->RequiredDISPCLKPerSurfaceDSC;
7121                                 if (!s->TotalAvailablePipesSupportDSC)
7122                                         mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
7123                                 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + s->NumberOfDPPDSC;
7124                         }
7125                 }
7126
7127                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7128                         if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
7129                                 mode_lib->ms.MPCCombine[j][k] = false;
7130                                 mode_lib->ms.NoOfDPP[j][k] = 4;
7131                         } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
7132                                 mode_lib->ms.MPCCombine[j][k] = false;
7133                                 mode_lib->ms.NoOfDPP[j][k] = 2;
7134                         } else if (mode_lib->ms.policy.MPCCombineUse[k] == dml_mpc_disabled) {
7135                                 mode_lib->ms.MPCCombine[j][k] = false;
7136                                 mode_lib->ms.NoOfDPP[j][k] = 1;
7137                         } else if (RoundToDFSGranularity(mode_lib->ms.MinDPPCLKUsingSingleDPP[k] * (1 + mode_lib->ms.soc.dcn_downspread_percent / 100),
7138                                                                                         1, mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz) <= mode_lib->ms.state.dppclk_mhz &&
7139                                                                                         mode_lib->ms.SingleDPPViewportSizeSupportPerSurface[k] == true) {
7140                                 mode_lib->ms.MPCCombine[j][k] = false;
7141                                 mode_lib->ms.NoOfDPP[j][k] = 1;
7142                         } else if (mode_lib->ms.TotalNumberOfActiveDPP[j] < (dml_uint_t) mode_lib->ms.ip.max_num_dpp) {
7143                                 mode_lib->ms.MPCCombine[j][k] = true;
7144                                 mode_lib->ms.NoOfDPP[j][k] = 2;
7145                                 mode_lib->ms.TotalNumberOfActiveDPP[j] = (dml_uint_t) mode_lib->ms.TotalNumberOfActiveDPP[j] + 1;
7146                         } else {
7147                                 mode_lib->ms.MPCCombine[j][k] = false;
7148                                 mode_lib->ms.NoOfDPP[j][k] = 1;
7149                                 mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
7150                         }
7151                 }
7152
7153                 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = 0;
7154                 s->NoChromaOrLinear = true;
7155                 for (k = 0; k < (dml_uint_t) mode_lib->ms.num_active_planes; ++k) {
7156                         if (mode_lib->ms.NoOfDPP[j][k] == 1)
7157                                 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] + 1;
7158                         if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_8
7159                                         || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_10
7160                                         || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_420_12
7161                                         || mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] == dml_rgbe_alpha
7162                                         || mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k] == dml_sw_linear) {
7163                                 s->NoChromaOrLinear = false;
7164                         }
7165                 }
7166
7167                 if (j == 1 && !UnboundedRequest(mode_lib->ms.policy.UseUnboundedRequesting,
7168                                 mode_lib->ms.TotalNumberOfActiveDPP[j], s->NoChromaOrLinear,
7169                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[0])) {
7170                         while (!(mode_lib->ms.TotalNumberOfActiveDPP[j] >= (dml_uint_t) mode_lib->ms.ip.max_num_dpp || mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] == 0)) {
7171                                 s->BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
7172                                 s->NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;
7173                                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7174                                         if (mode_lib->ms.policy.MPCCombineUse[k] != dml_mpc_disabled && mode_lib->ms.policy.MPCCombineUse[k] != dml_mpc_as_needed_for_voltage &&
7175                                                 mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k] > s->BWOfNonCombinedSurfaceOfMaximumBandwidth &&
7176                                                 (mode_lib->ms.ODMModePerState[k] != dml_odm_mode_combine_2to1 && mode_lib->ms.ODMModePerState[k] != dml_odm_mode_combine_4to1) &&
7177                                                 mode_lib->ms.MPCCombine[j][k] == false) {
7178                                                 s->BWOfNonCombinedSurfaceOfMaximumBandwidth = mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k];
7179                                                 s->NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
7180                                         }
7181                                 }
7182                                 mode_lib->ms.MPCCombine[j][s->NumberOfNonCombinedSurfaceOfMaximumBandwidth] = true;
7183                                 mode_lib->ms.NoOfDPP[j][s->NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
7184                                 mode_lib->ms.TotalNumberOfActiveDPP[j] = mode_lib->ms.TotalNumberOfActiveDPP[j] + 1;
7185                                 mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] = mode_lib->ms.TotalNumberOfSingleDPPSurfaces[j] - 1;
7186                         }
7187                 }
7188
7189                 //DISPCLK/DPPCLK
7190                 mode_lib->ms.WritebackRequiredDISPCLK = 0;
7191                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7192                         if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k]) {
7193                                 mode_lib->ms.WritebackRequiredDISPCLK = dml_max(mode_lib->ms.WritebackRequiredDISPCLK,
7194                                                                                                                                         CalculateWriteBackDISPCLK(mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
7195                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7196                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
7197                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
7198                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k],
7199                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
7200                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackSourceWidth[k],
7201                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
7202                                                                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k],
7203                                                                                                                                                                                         mode_lib->ms.ip.writeback_line_buffer_buffer_size,
7204                                                                                                                                                                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz));
7205                         }
7206                 }
7207
7208                  mode_lib->ms.RequiredDISPCLK[j] = mode_lib->ms.WritebackRequiredDISPCLK;
7209                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7210                         mode_lib->ms.RequiredDISPCLK[j] = dml_max(mode_lib->ms.RequiredDISPCLK[j], mode_lib->ms.RequiredDISPCLKPerSurface[j][k]);
7211                 }
7212
7213                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7214                         mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
7215                 }
7216
7217                 CalculateDPPCLK(mode_lib->ms.num_active_planes,
7218                                         mode_lib->ms.soc.dcn_downspread_percent,
7219                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
7220                                         mode_lib->ms.MinDPPCLKUsingSingleDPP,
7221                                         mode_lib->ms.NoOfDPPThisState,
7222                                         /* Output */
7223                                         &mode_lib->ms.GlobalDPPCLK,
7224                                         mode_lib->ms.RequiredDPPCLKThisState);
7225
7226                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7227                         mode_lib->ms.RequiredDPPCLKPerSurface[j][k] = mode_lib->ms.RequiredDPPCLKThisState[k];
7228                 }
7229
7230                 mode_lib->ms.support.DISPCLK_DPPCLK_Support[j] = !((mode_lib->ms.RequiredDISPCLK[j] > mode_lib->ms.state.dispclk_mhz) || (mode_lib->ms.GlobalDPPCLK > mode_lib->ms.state.dppclk_mhz));
7231
7232                 if (mode_lib->ms.TotalNumberOfActiveDPP[j] > (dml_uint_t) mode_lib->ms.ip.max_num_dpp) {
7233                         mode_lib->ms.support.TotalAvailablePipesSupport[j] = false;
7234                 }
7235         } // j
7236
7237         /* Total Available OTG, HDMIFRL, DP Support Check */
7238         s->TotalNumberOfActiveOTG = 0;
7239         s->TotalNumberOfActiveHDMIFRL = 0;
7240         s->TotalNumberOfActiveDP2p0 = 0;
7241         s->TotalNumberOfActiveDP2p0Outputs = 0;
7242
7243         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7244                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
7245                         s->TotalNumberOfActiveOTG = s->TotalNumberOfActiveOTG + 1;
7246                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)
7247                                 s->TotalNumberOfActiveHDMIFRL = s->TotalNumberOfActiveHDMIFRL + 1;
7248                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0) {
7249                                 s->TotalNumberOfActiveDP2p0 = s->TotalNumberOfActiveDP2p0 + 1;
7250                                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k || mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == false) {
7251                                         s->TotalNumberOfActiveDP2p0Outputs = s->TotalNumberOfActiveDP2p0Outputs + 1;
7252                                 }
7253                         }
7254                 }
7255         }
7256
7257         mode_lib->ms.support.NumberOfOTGSupport      = (s->TotalNumberOfActiveOTG <= (dml_uint_t) mode_lib->ms.ip.max_num_otg);
7258         mode_lib->ms.support.NumberOfHDMIFRLSupport  = (s->TotalNumberOfActiveHDMIFRL <= (dml_uint_t) mode_lib->ms.ip.max_num_hdmi_frl_outputs);
7259         mode_lib->ms.support.NumberOfDP2p0Support    = (s->TotalNumberOfActiveDP2p0 <= (dml_uint_t) mode_lib->ms.ip.max_num_dp2p0_streams && s->TotalNumberOfActiveDP2p0Outputs <= (dml_uint_t) mode_lib->ms.ip.max_num_dp2p0_outputs);
7260
7261         /* Display IO and DSC Support Check */
7262         mode_lib->ms.support.NonsupportedDSCInputBPC = false;
7263         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7264                 if (mode_lib->ms.cache_display_cfg.output.OutputDisabled[k] == false &&
7265                         !(mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 12.0
7266                                 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 10.0
7267                                 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] == 8.0
7268                                 || mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k] > (dml_uint_t) mode_lib->ms.ip.maximum_dsc_bits_per_component
7269                                 )) {
7270                         mode_lib->ms.support.NonsupportedDSCInputBPC = true;
7271                 }
7272         }
7273
7274         mode_lib->ms.support.ExceededMultistreamSlots = false;
7275         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7276                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k) {
7277                         s->TotalSlots = mode_lib->ms.RequiredSlots[k];
7278                         for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
7279                                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[j] == k)
7280                                         s->TotalSlots = s->TotalSlots + mode_lib->ms.RequiredSlots[j];
7281                         }
7282                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp && s->TotalSlots > 63)
7283                                 mode_lib->ms.support.ExceededMultistreamSlots = true;
7284                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 && s->TotalSlots > 64)
7285                                 mode_lib->ms.support.ExceededMultistreamSlots = true;
7286                 }
7287         }
7288         mode_lib->ms.support.LinkCapacitySupport = true;
7289         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7290                 if (mode_lib->ms.cache_display_cfg.output.OutputDisabled[k] == false &&
7291                         mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
7292                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) && mode_lib->ms.OutputBppPerState[k] == 0) {
7293                         mode_lib->ms.support.LinkCapacitySupport = false;
7294                 }
7295         }
7296
7297         mode_lib->ms.support.P2IWith420 = false;
7298         mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP = false;
7299         mode_lib->ms.support.DSC422NativeNotSupported = false;
7300         mode_lib->ms.support.LinkRateDoesNotMatchDPVersion = false;
7301         mode_lib->ms.support.LinkRateForMultistreamNotIndicated = false;
7302         mode_lib->ms.support.BPPForMultistreamNotIndicated = false;
7303         mode_lib->ms.support.MultistreamWithHDMIOreDP = false;
7304         mode_lib->ms.support.MSOOrODMSplitWithNonDPLink = false;
7305         mode_lib->ms.support.NotEnoughLanesForMSO = false;
7306
7307         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7308                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
7309                                                                                                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)) {
7310                         if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420 && mode_lib->ms.cache_display_cfg.timing.Interlace[k] == 1 && mode_lib->ms.ip.ptoi_supported == true)
7311                                 mode_lib->ms.support.P2IWith420 = true;
7312
7313                         if (mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable_if_necessary && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] != 0)
7314                                 mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP = true;
7315                         if ((mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable || mode_lib->ms.cache_display_cfg.output.DSCEnable[k] == dml_dsc_enable_if_necessary) && mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 && !mode_lib->ms.ip.dsc422_native_support)
7316                                 mode_lib->ms.support.DSC422NativeNotSupported = true;
7317
7318                         if (((mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr2 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_hbr3) &&
7319                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp && mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_edp) ||
7320                                         ((mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr10 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr13p5 || mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_uhbr20) &&
7321                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp2p0))
7322                                 mode_lib->ms.support.LinkRateDoesNotMatchDPVersion = true;
7323
7324                         if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1) {
7325                                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k && mode_lib->ms.cache_display_cfg.output.OutputLinkDPRate[k] == dml_dp_rate_na)
7326                                         mode_lib->ms.support.LinkRateForMultistreamNotIndicated = true;
7327                                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] == 0)
7328                                         mode_lib->ms.support.BPPForMultistreamNotIndicated = true;
7329                                 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
7330                                         if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == j && mode_lib->ms.cache_display_cfg.output.ForcedOutputLinkBPP[k] == 0)
7331                                                 mode_lib->ms.support.BPPForMultistreamNotIndicated = true;
7332                                 }
7333                         }
7334
7335                         if ((mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)) {
7336                                 if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1 && mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == k)
7337                                         mode_lib->ms.support.MultistreamWithHDMIOreDP = true;
7338                                 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
7339                                         if (mode_lib->ms.cache_display_cfg.output.OutputMultistreamEn[k] == 1 && mode_lib->ms.cache_display_cfg.output.OutputMultistreamId[k] == j)
7340                                                 mode_lib->ms.support.MultistreamWithHDMIOreDP = true;
7341                                 }
7342                         }
7343                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] != dml_dp && (mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_split_1to2 ||
7344                                 mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to2 || mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to4))
7345                                 mode_lib->ms.support.MSOOrODMSplitWithNonDPLink = true;
7346
7347                         if ((mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to2 && mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k] < 2) ||
7348                                 (mode_lib->ms.policy.ODMUse[k] == dml_odm_use_policy_mso_1to4 && mode_lib->ms.cache_display_cfg.output.OutputLinkDPLanes[k] < 4))
7349                                 mode_lib->ms.support.NotEnoughLanesForMSO = true;
7350                 }
7351         }
7352
7353         mode_lib->ms.support.DTBCLKRequiredMoreThanSupported = false;
7354         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7355                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k &&
7356                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl &&
7357                                 RequiredDTBCLK(
7358                                                         mode_lib->ms.RequiresDSC[k],
7359                                                         mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k],
7360                                                         mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
7361                                                         mode_lib->ms.OutputBppPerState[k],
7362                                                         mode_lib->ms.support.NumberOfDSCSlices[k],
7363                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k],
7364                                                         mode_lib->ms.cache_display_cfg.timing.HActive[k],
7365                                                         mode_lib->ms.cache_display_cfg.output.AudioSampleRate[k],
7366                                                         mode_lib->ms.cache_display_cfg.output.AudioSampleLayout[k]) > mode_lib->ms.state.dtbclk_mhz) {
7367                                                                 mode_lib->ms.support.DTBCLKRequiredMoreThanSupported = true;
7368                                                         }
7369         }
7370
7371         mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK = true;
7372         mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK = true;
7373         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7374                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1 && mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi) {
7375                         mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK = false;
7376                 }
7377                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k && mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1 && (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp ||
7378                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmi)) {
7379                         mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK = false;
7380                 }
7381         }
7382
7383         mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = false;
7384         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7385                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
7386                         if (mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp ||
7387                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_dp2p0 ||
7388                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_edp ||
7389                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) {
7390                                 if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420) {
7391                                         s->DSCFormatFactor = 2;
7392                                 } else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_444) {
7393                                         s->DSCFormatFactor = 1;
7394                                 } else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl) {
7395                                         s->DSCFormatFactor = 2;
7396                                 } else {
7397                                         s->DSCFormatFactor = 1;
7398                                 }
7399 #ifdef __DML_VBA_DEBUG__
7400                                 dml_print("DML::%s: k=%u, RequiresDSC = %u\n",  __func__, k, mode_lib->ms.RequiresDSC[k]);
7401 #endif
7402                                 if (mode_lib->ms.RequiresDSC[k] == true) {
7403                                         if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
7404                                                 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 12.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
7405 #ifdef __DML_VBA_DEBUG__
7406                                                         dml_print("DML::%s: k=%u, PixelClockBackEnd     = %f\n",  __func__, k, mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
7407                                                         dml_print("DML::%s: k=%u, DSCCLKPerState        = %f\n",  __func__, k, mode_lib->ms.state.dscclk_mhz);
7408                                                         dml_print("DML::%s: k=%u, DSCFormatFactor       = %u\n",  __func__, k, s->DSCFormatFactor);
7409 #endif
7410                                                         mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
7411                                                 }
7412                                         } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
7413                                                 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 6.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
7414                                                         mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
7415                                                 }
7416                                         } else {
7417                                                 if (mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 3.0 / (dml_float_t)s->DSCFormatFactor > (1.0 - mode_lib->ms.soc.dcn_downspread_percent / 100.0) * mode_lib->ms.state.dscclk_mhz) {
7418                                                         mode_lib->ms.support.DSCCLKRequiredMoreThanSupported = true;
7419                                                 }
7420                                         }
7421                                 }
7422                         }
7423                 }
7424         }
7425 #ifdef __DML_VBA_DEBUG__
7426         dml_print("DML::%s: DSCCLKRequiredMoreThanSupported = %u\n",  __func__, mode_lib->ms.support.DSCCLKRequiredMoreThanSupported);
7427 #endif
7428
7429         /* Check DSC Unit and Slices Support */
7430         mode_lib->ms.support.NotEnoughDSCUnits = false;
7431         mode_lib->ms.support.NotEnoughDSCSlices = false;
7432         s->TotalDSCUnitsRequired = 0;
7433         mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = true;
7434         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7435                 if (mode_lib->ms.RequiresDSC[k] == true) {
7436                         if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_4to1) {
7437                                 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > 4 * (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
7438                                         mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
7439                                 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 4;
7440                                 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 16)
7441                                         mode_lib->ms.support.NotEnoughDSCSlices = true;
7442                         } else if (mode_lib->ms.ODMModePerState[k] == dml_odm_mode_combine_2to1) {
7443                                 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > 2 * (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
7444                                         mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
7445                                 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 2;
7446                                 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 8)
7447                                         mode_lib->ms.support.NotEnoughDSCSlices = true;
7448                         } else {
7449                                 if (mode_lib->ms.cache_display_cfg.timing.HActive[k] > (dml_uint_t) mode_lib->ms.ip.maximum_pixels_per_line_per_dsc_unit)
7450                                         mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport = false;
7451                                 s->TotalDSCUnitsRequired = s->TotalDSCUnitsRequired + 1;
7452                                 if (mode_lib->ms.support.NumberOfDSCSlices[k] > 4)
7453                                         mode_lib->ms.support.NotEnoughDSCSlices = true;
7454                         }
7455                 }
7456         }
7457    if (s->TotalDSCUnitsRequired > (dml_uint_t) mode_lib->ms.ip.num_dsc) {
7458                 mode_lib->ms.support.NotEnoughDSCUnits = true;
7459         }
7460
7461         /*DSC Delay per state*/
7462         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7463                 mode_lib->ms.DSCDelayPerState[k] = DSCDelayRequirement(mode_lib->ms.RequiresDSC[k],
7464                                                                                                         mode_lib->ms.ODMModePerState[k],
7465                                                                                                         mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
7466                                                                                                         mode_lib->ms.OutputBppPerState[k],
7467                                                                                                         mode_lib->ms.cache_display_cfg.timing.HActive[k],
7468                                                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k],
7469                                                                                                         mode_lib->ms.support.NumberOfDSCSlices[k],
7470                                                                                                         mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
7471                                                                                                         mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
7472                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7473                                                                                                         mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
7474         }
7475
7476         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7477                 for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
7478                         for (j = 0; j <= mode_lib->ms.num_active_planes - 1; j++) {
7479                                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == m && mode_lib->ms.RequiresDSC[m] == true) {
7480                                         mode_lib->ms.DSCDelayPerState[k] = mode_lib->ms.DSCDelayPerState[m];
7481                                 }
7482                         }
7483                 }
7484         }
7485
7486         //Calculate Swath, DET Configuration, DCFCLKDeepSleep
7487         //
7488         for (j = 0; j < 2; ++j) {
7489                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7490                         mode_lib->ms.RequiredDPPCLKThisState[k] = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
7491                         mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
7492                         mode_lib->ms.ODMModeThisState[k] = mode_lib->ms.ODMModePerState[k];
7493                 }
7494
7495                 CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
7496                 CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7497                 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
7498                 CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
7499                 CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
7500                 CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
7501                 CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
7502                 CalculateSwathAndDETConfiguration_params->ForceSingleDPP = false;
7503                 CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7504                 CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
7505                 CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
7506                 CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
7507                 CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
7508                 CalculateSwathAndDETConfiguration_params->Output = mode_lib->ms.cache_display_cfg.output.OutputEncoder;
7509                 CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
7510                 CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
7511                 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = mode_lib->ms.MaximumSwathWidthLuma;
7512                 CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = mode_lib->ms.MaximumSwathWidthChroma;
7513                 CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
7514                 CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
7515                 CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
7516                 CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
7517                 CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
7518                 CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
7519                 CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
7520                 CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
7521                 CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
7522                 CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
7523                 CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
7524                 CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
7525                 CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
7526                 CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
7527                 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = mode_lib->ms.Read256BlockHeightY;
7528                 CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = mode_lib->ms.Read256BlockHeightC;
7529                 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = mode_lib->ms.Read256BlockWidthY;
7530                 CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = mode_lib->ms.Read256BlockWidthC;
7531                 CalculateSwathAndDETConfiguration_params->ODMMode = mode_lib->ms.ODMModeThisState;
7532                 CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
7533                 CalculateSwathAndDETConfiguration_params->BytePerPixY = mode_lib->ms.BytePerPixelY;
7534                 CalculateSwathAndDETConfiguration_params->BytePerPixC = mode_lib->ms.BytePerPixelC;
7535                 CalculateSwathAndDETConfiguration_params->BytePerPixDETY = mode_lib->ms.BytePerPixelInDETY;
7536                 CalculateSwathAndDETConfiguration_params->BytePerPixDETC = mode_lib->ms.BytePerPixelInDETC;
7537                 CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
7538                 CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
7539                 CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
7540                 CalculateSwathAndDETConfiguration_params->DPPPerSurface = mode_lib->ms.NoOfDPPThisState;
7541                 CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = mode_lib->ms.swath_width_luma_ub_this_state;
7542                 CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = mode_lib->ms.swath_width_chroma_ub_this_state;
7543                 CalculateSwathAndDETConfiguration_params->SwathWidth = mode_lib->ms.SwathWidthYThisState;
7544                 CalculateSwathAndDETConfiguration_params->SwathWidthChroma = mode_lib->ms.SwathWidthCThisState;
7545                 CalculateSwathAndDETConfiguration_params->SwathHeightY = mode_lib->ms.SwathHeightYThisState;
7546                 CalculateSwathAndDETConfiguration_params->SwathHeightC = mode_lib->ms.SwathHeightCThisState;
7547                 CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = mode_lib->ms.DETBufferSizeInKByteThisState;
7548                 CalculateSwathAndDETConfiguration_params->DETBufferSizeY = mode_lib->ms.DETBufferSizeYThisState;
7549                 CalculateSwathAndDETConfiguration_params->DETBufferSizeC = mode_lib->ms.DETBufferSizeCThisState;
7550                 CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &mode_lib->ms.UnboundedRequestEnabledThisState;
7551                 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &s->dummy_integer[2];
7552                 CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &s->dummy_integer[1];
7553                 CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &mode_lib->ms.CompressedBufferSizeInkByteThisState;
7554                 CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = s->dummy_boolean_array[0];
7555                 CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &mode_lib->ms.support.ViewportSizeSupport[j];
7556
7557                 CalculateSwathAndDETConfiguration(&mode_lib->scratch,
7558                 CalculateSwathAndDETConfiguration_params);
7559
7560                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7561                         mode_lib->ms.swath_width_luma_ub_all_states[j][k] = mode_lib->ms.swath_width_luma_ub_this_state[k];
7562                         mode_lib->ms.swath_width_chroma_ub_all_states[j][k] = mode_lib->ms.swath_width_chroma_ub_this_state[k];
7563                         mode_lib->ms.SwathWidthYAllStates[j][k] = mode_lib->ms.SwathWidthYThisState[k];
7564                         mode_lib->ms.SwathWidthCAllStates[j][k] = mode_lib->ms.SwathWidthCThisState[k];
7565                         mode_lib->ms.SwathHeightYAllStates[j][k] = mode_lib->ms.SwathHeightYThisState[k];
7566                         mode_lib->ms.SwathHeightCAllStates[j][k] = mode_lib->ms.SwathHeightCThisState[k];
7567                         mode_lib->ms.UnboundedRequestEnabledAllStates[j] = mode_lib->ms.UnboundedRequestEnabledThisState;
7568                         mode_lib->ms.CompressedBufferSizeInkByteAllStates[j] = mode_lib->ms.CompressedBufferSizeInkByteThisState;
7569                         mode_lib->ms.DETBufferSizeInKByteAllStates[j][k] = mode_lib->ms.DETBufferSizeInKByteThisState[k];
7570                         mode_lib->ms.DETBufferSizeYAllStates[j][k] = mode_lib->ms.DETBufferSizeYThisState[k];
7571                         mode_lib->ms.DETBufferSizeCAllStates[j][k] = mode_lib->ms.DETBufferSizeCThisState[k];
7572                 }
7573         }
7574
7575         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7576                 mode_lib->ms.cursor_bw[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
7577         }
7578
7579         CalculateSurfaceSizeInMall(
7580                         mode_lib->ms.num_active_planes,
7581                         mode_lib->ms.soc.mall_allocated_for_dcn_mbytes,
7582                         mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen,
7583                         mode_lib->ms.cache_display_cfg.surface.DCCEnable,
7584                         mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
7585                         mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
7586                         mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
7587                         mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
7588                         mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
7589                         mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
7590                         mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
7591                         mode_lib->ms.BytePerPixelY,
7592                         mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma,
7593                         mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma,
7594                         mode_lib->ms.BytePerPixelC,
7595                         mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
7596                         mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
7597                         mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
7598                         mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
7599                         mode_lib->ms.Read256BlockWidthY,
7600                         mode_lib->ms.Read256BlockWidthC,
7601                         mode_lib->ms.Read256BlockHeightY,
7602                         mode_lib->ms.Read256BlockHeightC,
7603                         mode_lib->ms.MacroTileWidthY,
7604                         mode_lib->ms.MacroTileWidthC,
7605                         mode_lib->ms.MacroTileHeightY,
7606                         mode_lib->ms.MacroTileHeightC,
7607
7608                         /* Output */
7609                         mode_lib->ms.SurfaceSizeInMALL,
7610                         &mode_lib->ms.support.ExceededMALLSize);
7611
7612         for (j = 0; j < 2; j++) {
7613                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7614                         mode_lib->ms.swath_width_luma_ub_this_state[k] = mode_lib->ms.swath_width_luma_ub_all_states[j][k];
7615                         mode_lib->ms.swath_width_chroma_ub_this_state[k] = mode_lib->ms.swath_width_chroma_ub_all_states[j][k];
7616                         mode_lib->ms.SwathWidthYThisState[k] = mode_lib->ms.SwathWidthYAllStates[j][k];
7617                         mode_lib->ms.SwathWidthCThisState[k] = mode_lib->ms.SwathWidthCAllStates[j][k];
7618                         mode_lib->ms.SwathHeightYThisState[k] = mode_lib->ms.SwathHeightYAllStates[j][k];
7619                         mode_lib->ms.SwathHeightCThisState[k] = mode_lib->ms.SwathHeightCAllStates[j][k];
7620                         mode_lib->ms.DETBufferSizeInKByteThisState[k] = mode_lib->ms.DETBufferSizeInKByteAllStates[j][k];
7621                         mode_lib->ms.DETBufferSizeYThisState[k] = mode_lib->ms.DETBufferSizeYAllStates[j][k];
7622                         mode_lib->ms.DETBufferSizeCThisState[k] = mode_lib->ms.DETBufferSizeCAllStates[j][k];
7623                         mode_lib->ms.RequiredDPPCLKThisState[k] = mode_lib->ms.RequiredDPPCLKPerSurface[j][k];
7624                         mode_lib->ms.NoOfDPPThisState[k] = mode_lib->ms.NoOfDPP[j][k];
7625                 }
7626
7627                 mode_lib->ms.TotalNumberOfDCCActiveDPP[j] = 0;
7628                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7629                         if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
7630                                 mode_lib->ms.TotalNumberOfDCCActiveDPP[j] = mode_lib->ms.TotalNumberOfDCCActiveDPP[j] + mode_lib->ms.NoOfDPP[j][k];
7631                         }
7632                 }
7633
7634                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7635                         s->SurfParameters[k].PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
7636                         s->SurfParameters[k].DPPPerSurface = mode_lib->ms.NoOfDPP[j][k];
7637                         s->SurfParameters[k].SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
7638                         s->SurfParameters[k].ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
7639                         s->SurfParameters[k].ViewportHeightChroma = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
7640                         s->SurfParameters[k].BlockWidth256BytesY = mode_lib->ms.Read256BlockWidthY[k];
7641                         s->SurfParameters[k].BlockHeight256BytesY = mode_lib->ms.Read256BlockHeightY[k];
7642                         s->SurfParameters[k].BlockWidth256BytesC = mode_lib->ms.Read256BlockWidthC[k];
7643                         s->SurfParameters[k].BlockHeight256BytesC = mode_lib->ms.Read256BlockHeightC[k];
7644                         s->SurfParameters[k].BlockWidthY = mode_lib->ms.MacroTileWidthY[k];
7645                         s->SurfParameters[k].BlockHeightY = mode_lib->ms.MacroTileHeightY[k];
7646                         s->SurfParameters[k].BlockWidthC = mode_lib->ms.MacroTileWidthC[k];
7647                         s->SurfParameters[k].BlockHeightC = mode_lib->ms.MacroTileHeightC[k];
7648                         s->SurfParameters[k].InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
7649                         s->SurfParameters[k].HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
7650                         s->SurfParameters[k].DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
7651                         s->SurfParameters[k].SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
7652                         s->SurfParameters[k].SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k];
7653                         s->SurfParameters[k].BytePerPixelY = mode_lib->ms.BytePerPixelY[k];
7654                         s->SurfParameters[k].BytePerPixelC = mode_lib->ms.BytePerPixelC[k];
7655                         s->SurfParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
7656                         s->SurfParameters[k].VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio[k];
7657                         s->SurfParameters[k].VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
7658                         s->SurfParameters[k].VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps[k];
7659                         s->SurfParameters[k].VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k];
7660                         s->SurfParameters[k].PitchY = mode_lib->ms.cache_display_cfg.surface.PitchY[k];
7661                         s->SurfParameters[k].DCCMetaPitchY = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
7662                         s->SurfParameters[k].PitchC = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
7663                         s->SurfParameters[k].DCCMetaPitchC = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
7664                         s->SurfParameters[k].ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary[k];
7665                         s->SurfParameters[k].ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart[k];
7666                         s->SurfParameters[k].ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart[k];
7667                         s->SurfParameters[k].ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC[k];
7668                         s->SurfParameters[k].ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC[k];
7669                         s->SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->ms.cache_display_cfg.plane.ForceOneRowForFrame[k];
7670                         s->SurfParameters[k].SwathHeightY = mode_lib->ms.SwathHeightYThisState[k];
7671                         s->SurfParameters[k].SwathHeightC = mode_lib->ms.SwathHeightCThisState[k];
7672                 }
7673
7674                 CalculateVMRowAndSwath_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7675                 CalculateVMRowAndSwath_params->myPipe = s->SurfParameters;
7676                 CalculateVMRowAndSwath_params->SurfaceSizeInMALL = mode_lib->ms.SurfaceSizeInMALL;
7677                 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsLuma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_luma;
7678                 CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsChroma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_chroma;
7679                 CalculateVMRowAndSwath_params->DCCMetaBufferSizeBytes = mode_lib->ms.ip.dcc_meta_buffer_size_bytes;
7680                 CalculateVMRowAndSwath_params->UseMALLForStaticScreen = mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen;
7681                 CalculateVMRowAndSwath_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7682                 CalculateVMRowAndSwath_params->MALLAllocatedForDCN = mode_lib->ms.soc.mall_allocated_for_dcn_mbytes;
7683                 CalculateVMRowAndSwath_params->SwathWidthY = mode_lib->ms.SwathWidthYThisState;
7684                 CalculateVMRowAndSwath_params->SwathWidthC = mode_lib->ms.SwathWidthCThisState;
7685                 CalculateVMRowAndSwath_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
7686                 CalculateVMRowAndSwath_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
7687                 CalculateVMRowAndSwath_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
7688                 CalculateVMRowAndSwath_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
7689                 CalculateVMRowAndSwath_params->GPUVMMinPageSizeKBytes = mode_lib->ms.cache_display_cfg.plane.GPUVMMinPageSizeKBytes;
7690                 CalculateVMRowAndSwath_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024;
7691                 CalculateVMRowAndSwath_params->PTEBufferModeOverrideEn = mode_lib->ms.cache_display_cfg.plane.PTEBufferModeOverrideEn;
7692                 CalculateVMRowAndSwath_params->PTEBufferModeOverrideVal = mode_lib->ms.cache_display_cfg.plane.PTEBufferMode;
7693                 CalculateVMRowAndSwath_params->PTEBufferSizeNotExceeded = mode_lib->ms.PTEBufferSizeNotExceededPerState;
7694                 CalculateVMRowAndSwath_params->DCCMetaBufferSizeNotExceeded = mode_lib->ms.DCCMetaBufferSizeNotExceededPerState;
7695                 CalculateVMRowAndSwath_params->dpte_row_width_luma_ub = s->dummy_integer_array[0];
7696                 CalculateVMRowAndSwath_params->dpte_row_width_chroma_ub = s->dummy_integer_array[1];
7697                 CalculateVMRowAndSwath_params->dpte_row_height_luma = mode_lib->ms.dpte_row_height;
7698                 CalculateVMRowAndSwath_params->dpte_row_height_chroma = mode_lib->ms.dpte_row_height_chroma;
7699                 CalculateVMRowAndSwath_params->dpte_row_height_linear_luma = s->dummy_integer_array[2]; // VBA_DELTA
7700                 CalculateVMRowAndSwath_params->dpte_row_height_linear_chroma = s->dummy_integer_array[3]; // VBA_DELTA
7701                 CalculateVMRowAndSwath_params->meta_req_width = s->dummy_integer_array[4];
7702                 CalculateVMRowAndSwath_params->meta_req_width_chroma = s->dummy_integer_array[5];
7703                 CalculateVMRowAndSwath_params->meta_req_height = s->dummy_integer_array[6];
7704                 CalculateVMRowAndSwath_params->meta_req_height_chroma = s->dummy_integer_array[7];
7705                 CalculateVMRowAndSwath_params->meta_row_width = s->dummy_integer_array[8];
7706                 CalculateVMRowAndSwath_params->meta_row_width_chroma = s->dummy_integer_array[9];
7707                 CalculateVMRowAndSwath_params->meta_row_height = mode_lib->ms.meta_row_height;
7708                 CalculateVMRowAndSwath_params->meta_row_height_chroma = mode_lib->ms.meta_row_height_chroma;
7709                 CalculateVMRowAndSwath_params->vm_group_bytes = s->dummy_integer_array[10];
7710                 CalculateVMRowAndSwath_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
7711                 CalculateVMRowAndSwath_params->PixelPTEReqWidthY = s->dummy_integer_array[11];
7712                 CalculateVMRowAndSwath_params->PixelPTEReqHeightY = s->dummy_integer_array[12];
7713                 CalculateVMRowAndSwath_params->PTERequestSizeY = s->dummy_integer_array[13];
7714                 CalculateVMRowAndSwath_params->PixelPTEReqWidthC = s->dummy_integer_array[14];
7715                 CalculateVMRowAndSwath_params->PixelPTEReqHeightC = s->dummy_integer_array[15];
7716                 CalculateVMRowAndSwath_params->PTERequestSizeC = s->dummy_integer_array[16];
7717                 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_l = s->dummy_integer_array[17];
7718                 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_l = s->dummy_integer_array[18];
7719                 CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_c = s->dummy_integer_array[19];
7720                 CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_c = s->dummy_integer_array[20];
7721                 CalculateVMRowAndSwath_params->PrefetchSourceLinesY = mode_lib->ms.PrefetchLinesYThisState;
7722                 CalculateVMRowAndSwath_params->PrefetchSourceLinesC = mode_lib->ms.PrefetchLinesCThisState;
7723                 CalculateVMRowAndSwath_params->VInitPreFillY = mode_lib->ms.PrefillY;
7724                 CalculateVMRowAndSwath_params->VInitPreFillC = mode_lib->ms.PrefillC;
7725                 CalculateVMRowAndSwath_params->MaxNumSwathY = mode_lib->ms.MaxNumSwY;
7726                 CalculateVMRowAndSwath_params->MaxNumSwathC = mode_lib->ms.MaxNumSwC;
7727                 CalculateVMRowAndSwath_params->meta_row_bw = mode_lib->ms.meta_row_bandwidth_this_state;
7728                 CalculateVMRowAndSwath_params->dpte_row_bw = mode_lib->ms.dpte_row_bandwidth_this_state;
7729                 CalculateVMRowAndSwath_params->PixelPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRowThisState;
7730                 CalculateVMRowAndSwath_params->PDEAndMetaPTEBytesFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrameThisState;
7731                 CalculateVMRowAndSwath_params->MetaRowByte = mode_lib->ms.MetaRowBytesThisState;
7732                 CalculateVMRowAndSwath_params->use_one_row_for_frame = mode_lib->ms.use_one_row_for_frame_this_state;
7733                 CalculateVMRowAndSwath_params->use_one_row_for_frame_flip = mode_lib->ms.use_one_row_for_frame_flip_this_state;
7734                 CalculateVMRowAndSwath_params->UsesMALLForStaticScreen = s->dummy_boolean_array[0];
7735                 CalculateVMRowAndSwath_params->PTE_BUFFER_MODE = s->dummy_boolean_array[1];
7736                 CalculateVMRowAndSwath_params->BIGK_FRAGMENT_SIZE = s->dummy_integer_array[21];
7737
7738                 CalculateVMRowAndSwath(&mode_lib->scratch,
7739                         CalculateVMRowAndSwath_params);
7740
7741                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7742                         mode_lib->ms.PrefetchLinesY[j][k] = mode_lib->ms.PrefetchLinesYThisState[k];
7743                         mode_lib->ms.PrefetchLinesC[j][k] = mode_lib->ms.PrefetchLinesCThisState[k];
7744                         mode_lib->ms.meta_row_bandwidth[j][k] = mode_lib->ms.meta_row_bandwidth_this_state[k];
7745                         mode_lib->ms.dpte_row_bandwidth[j][k] = mode_lib->ms.dpte_row_bandwidth_this_state[k];
7746                         mode_lib->ms.DPTEBytesPerRow[j][k] = mode_lib->ms.DPTEBytesPerRowThisState[k];
7747                         mode_lib->ms.PDEAndMetaPTEBytesPerFrame[j][k] = mode_lib->ms.PDEAndMetaPTEBytesPerFrameThisState[k];
7748                         mode_lib->ms.MetaRowBytes[j][k] = mode_lib->ms.MetaRowBytesThisState[k];
7749                         mode_lib->ms.use_one_row_for_frame[j][k] = mode_lib->ms.use_one_row_for_frame_this_state[k];
7750                         mode_lib->ms.use_one_row_for_frame_flip[j][k] = mode_lib->ms.use_one_row_for_frame_flip_this_state[k];
7751                 }
7752
7753                 mode_lib->ms.support.PTEBufferSizeNotExceeded[j] = true;
7754
7755                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7756                         if (mode_lib->ms.PTEBufferSizeNotExceededPerState[k] == false)
7757                                 mode_lib->ms.support.PTEBufferSizeNotExceeded[j] = false;
7758 #ifdef __DML_VBA_DEBUG__
7759                         dml_print("DML::%s: j=%u k=%u, PTEBufferSizeNotExceededPerState[%u] = %u\n",  __func__, j, k, k, mode_lib->ms.PTEBufferSizeNotExceededPerState[k]);
7760 #endif
7761                 }
7762 #ifdef __DML_VBA_DEBUG__
7763                 dml_print("DML::%s: PTEBufferSizeNotExceeded[%u] = %u\n",  __func__, j, mode_lib->ms.support.PTEBufferSizeNotExceeded[j]);
7764 #endif
7765
7766                 mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] = true;
7767                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7768                         if (mode_lib->ms.DCCMetaBufferSizeNotExceededPerState[k] == false)
7769                                 mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] = false;
7770                 }
7771
7772                 mode_lib->ms.UrgLatency = CalculateUrgentLatency(mode_lib->ms.state.urgent_latency_pixel_data_only_us,
7773                                                                                                         mode_lib->ms.state.urgent_latency_pixel_mixed_with_vm_data_us,
7774                                                                                                         mode_lib->ms.state.urgent_latency_vm_data_only_us,
7775                                                                                                         mode_lib->ms.soc.do_urgent_latency_adjustment,
7776                                                                                                         mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_component_us,
7777                                                                                                         mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_reference_mhz,
7778                                                                                                         mode_lib->ms.state.fabricclk_mhz);
7779
7780                 /* Getter functions work at mp interface so copy the urgent latency to mp*/
7781                 mode_lib->mp.UrgentLatency = mode_lib->ms.UrgLatency;
7782
7783                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7784                         CalculateUrgentBurstFactor(
7785                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
7786                                 mode_lib->ms.swath_width_luma_ub_this_state[k],
7787                                 mode_lib->ms.swath_width_chroma_ub_this_state[k],
7788                                 mode_lib->ms.SwathHeightYThisState[k],
7789                                 mode_lib->ms.SwathHeightCThisState[k],
7790                                 (dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
7791                                 mode_lib->ms.UrgLatency,
7792                                 mode_lib->ms.ip.cursor_buffer_size,
7793                                 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
7794                                 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
7795                                 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
7796                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
7797                                 mode_lib->ms.BytePerPixelInDETY[k],
7798                                 mode_lib->ms.BytePerPixelInDETC[k],
7799                                 mode_lib->ms.DETBufferSizeYThisState[k],
7800                                 mode_lib->ms.DETBufferSizeCThisState[k],
7801                                 /* Output */
7802                                 &mode_lib->ms.UrgentBurstFactorCursor[k],
7803                                 &mode_lib->ms.UrgentBurstFactorLuma[k],
7804                                 &mode_lib->ms.UrgentBurstFactorChroma[k],
7805                                 &mode_lib->ms.NotUrgentLatencyHiding[k]);
7806                 }
7807
7808                 CalculateDCFCLKDeepSleep(
7809                                 mode_lib->ms.num_active_planes,
7810                                 mode_lib->ms.BytePerPixelY,
7811                                 mode_lib->ms.BytePerPixelC,
7812                                 mode_lib->ms.cache_display_cfg.plane.VRatio,
7813                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
7814                                 mode_lib->ms.SwathWidthYThisState,
7815                                 mode_lib->ms.SwathWidthCThisState,
7816                                 mode_lib->ms.NoOfDPPThisState,
7817                                 mode_lib->ms.cache_display_cfg.plane.HRatio,
7818                                 mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
7819                                 mode_lib->ms.cache_display_cfg.timing.PixelClock,
7820                                 mode_lib->ms.PSCL_FACTOR,
7821                                 mode_lib->ms.PSCL_FACTOR_CHROMA,
7822                                 mode_lib->ms.RequiredDPPCLKThisState,
7823                                 mode_lib->ms.ReadBandwidthLuma,
7824                                 mode_lib->ms.ReadBandwidthChroma,
7825                                 mode_lib->ms.soc.return_bus_width_bytes,
7826
7827                                 /* Output */
7828                                 &mode_lib->ms.ProjectedDCFCLKDeepSleep[j]);
7829         }
7830
7831         //Calculate Return BW
7832         for (j = 0; j < 2; ++j) {
7833                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7834                         if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
7835                                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
7836                                         mode_lib->ms.WritebackDelayTime[k] = mode_lib->ms.state.writeback_latency_us + CalculateWriteBackDelay(
7837                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
7838                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
7839                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
7840                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
7841                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
7842                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k],
7843                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k],
7844                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / mode_lib->ms.RequiredDISPCLK[j];
7845                                 } else {
7846                                         mode_lib->ms.WritebackDelayTime[k] = 0.0;
7847                                 }
7848                                 for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
7849                                         if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[m] == k && mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[m] == true) {
7850                                                 mode_lib->ms.WritebackDelayTime[k] = dml_max(mode_lib->ms.WritebackDelayTime[k],
7851                                                                                         mode_lib->ms.state.writeback_latency_us + CalculateWriteBackDelay(
7852                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[m],
7853                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[m],
7854                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[m],
7855                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[m],
7856                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[m],
7857                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[m],
7858                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[m],
7859                                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[m]) / mode_lib->ms.RequiredDISPCLK[j]);
7860                                         }
7861                                 }
7862                         }
7863                 }
7864                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7865                         for (m = 0; m <= mode_lib->ms.num_active_planes - 1; m++) {
7866                                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == m) {
7867                                         mode_lib->ms.WritebackDelayTime[k] = mode_lib->ms.WritebackDelayTime[m];
7868                                 }
7869                         }
7870                 }
7871        s->MaxVStartupAllPlanes[j] = 0;  // max vstartup among all planes
7872
7873                 for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
7874                         s->MaximumVStartup[j][k] = CalculateMaxVStartup(k,
7875                                                                                                                 mode_lib->ms.ip.ptoi_supported,
7876                                                                                                                 mode_lib->ms.ip.vblank_nom_default_us,
7877                                                                                                                 &mode_lib->ms.cache_display_cfg.timing,
7878                                                                                                                 mode_lib->ms.WritebackDelayTime[k]);
7879
7880                         s->MaxVStartupAllPlanes[j] = (dml_uint_t)(dml_max(s->MaxVStartupAllPlanes[j], s->MaximumVStartup[j][k]));
7881 #ifdef __DML_VBA_DEBUG__
7882                         dml_print("DML::%s: k=%u, MaxVStartupAllPlanes[%u] = %u\n", __func__, k, j, s->MaxVStartupAllPlanes[j]);
7883                         dml_print("DML::%s: k=%u, MaximumVStartup[%u][%u] = %u\n", __func__, k, j, k, s->MaximumVStartup[j][k]);
7884 #endif
7885                 }
7886         }
7887
7888         s->ReorderingBytes = (dml_uint_t)(mode_lib->ms.soc.num_chans * dml_max3(mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_only_bytes,
7889                                                                                                                                 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes,
7890                                                                                                                                 mode_lib->ms.soc.urgent_out_of_order_return_per_channel_vm_only_bytes));
7891
7892         for (j = 0; j < 2; ++j) {
7893                 mode_lib->ms.DCFCLKState[j] = mode_lib->ms.state.dcfclk_mhz;
7894         }
7895
7896         /* Immediate Flip and MALL parameters */
7897         s->ImmediateFlipRequiredFinal = false;
7898         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7899                 s->ImmediateFlipRequiredFinal = s->ImmediateFlipRequiredFinal || (mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
7900         }
7901
7902         mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
7903         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7904                 mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified ||
7905                                                                                                                                                                                         ((mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_required) &&
7906                                                                                                                                                                                         (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required));
7907         }
7908         mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified && s->ImmediateFlipRequiredFinal;
7909
7910         mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
7911         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7912                 mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
7913                                                                                 mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe || ((mode_lib->ms.cache_display_cfg.plane.HostVMEnable == true || mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) &&
7914                                                                                 (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame || mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe));
7915         }
7916
7917         mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
7918         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7919                 mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen = mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen ||
7920                                                                                                                                 ((mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_enable || mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_optimize) && (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe)) ||
7921                                                                                                                                 ((mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_disable || mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen[k] == dml_use_mall_static_screen_optimize) && (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame));
7922         }
7923
7924         s->FullFrameMALLPStateMethod = false;
7925         s->SubViewportMALLPStateMethod = false;
7926         s->PhantomPipeMALLPStateMethod = false;
7927         s->SubViewportMALLRefreshGreaterThan120Hz = false;
7928         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
7929                 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_full_frame)
7930                         s->FullFrameMALLPStateMethod = true;
7931                 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_sub_viewport) {
7932                         s->SubViewportMALLPStateMethod = true;
7933                         if (mode_lib->ms.cache_display_cfg.timing.RefreshRate[k] > 120)
7934                                 s->SubViewportMALLRefreshGreaterThan120Hz = true;
7935                 }
7936                 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] == dml_use_mall_pstate_change_phantom_pipe)
7937                         s->PhantomPipeMALLPStateMethod = true;
7938         }
7939         mode_lib->ms.support.InvalidCombinationOfMALLUseForPState = (s->SubViewportMALLPStateMethod != s->PhantomPipeMALLPStateMethod)
7940         || (s->SubViewportMALLPStateMethod && s->FullFrameMALLPStateMethod) || s->SubViewportMALLRefreshGreaterThan120Hz;
7941
7942     if (mode_lib->ms.policy.UseMinimumRequiredDCFCLK == true) {
7943                 UseMinimumDCFCLK_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
7944                 UseMinimumDCFCLK_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
7945                 UseMinimumDCFCLK_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
7946                 UseMinimumDCFCLK_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
7947                 UseMinimumDCFCLK_params->MaxPrefetchMode = dml_prefetch_support_stutter;
7948                 UseMinimumDCFCLK_params->DRAMClockChangeLatencyFinal = mode_lib->ms.state.dram_clock_change_latency_us;
7949                 UseMinimumDCFCLK_params->FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
7950                 UseMinimumDCFCLK_params->SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
7951                 UseMinimumDCFCLK_params->ReturnBusWidth = mode_lib->ms.soc.return_bus_width_bytes;
7952                 UseMinimumDCFCLK_params->RoundTripPingLatencyCycles = mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles;
7953                 UseMinimumDCFCLK_params->ReorderingBytes = s->ReorderingBytes;
7954                 UseMinimumDCFCLK_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
7955                 UseMinimumDCFCLK_params->MetaChunkSize = mode_lib->ms.ip.meta_chunk_size_kbytes;
7956                 UseMinimumDCFCLK_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
7957                 UseMinimumDCFCLK_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
7958                 UseMinimumDCFCLK_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
7959                 UseMinimumDCFCLK_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
7960                 UseMinimumDCFCLK_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024;
7961                 UseMinimumDCFCLK_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
7962                 UseMinimumDCFCLK_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
7963                 UseMinimumDCFCLK_params->ImmediateFlipRequirement = s->ImmediateFlipRequiredFinal;
7964                 UseMinimumDCFCLK_params->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
7965                 UseMinimumDCFCLK_params->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation = mode_lib->ms.soc.max_avg_sdp_bw_use_normal_percent;
7966                 UseMinimumDCFCLK_params->PercentOfIdealSDPPortBWReceivedAfterUrgLatency = mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent;
7967                 UseMinimumDCFCLK_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
7968                 UseMinimumDCFCLK_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
7969                 UseMinimumDCFCLK_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes;
7970                 UseMinimumDCFCLK_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired;
7971                 UseMinimumDCFCLK_params->Interlace = mode_lib->ms.cache_display_cfg.timing.Interlace;
7972                 UseMinimumDCFCLK_params->RequiredDPPCLKPerSurface = mode_lib->ms.RequiredDPPCLKPerSurface;
7973                 UseMinimumDCFCLK_params->RequiredDISPCLK = mode_lib->ms.RequiredDISPCLK;
7974                 UseMinimumDCFCLK_params->UrgLatency = mode_lib->ms.UrgLatency;
7975                 UseMinimumDCFCLK_params->NoOfDPP = mode_lib->ms.NoOfDPP;
7976                 UseMinimumDCFCLK_params->ProjectedDCFCLKDeepSleep = mode_lib->ms.ProjectedDCFCLKDeepSleep;
7977                 UseMinimumDCFCLK_params->MaximumVStartup = s->MaximumVStartup;
7978                 UseMinimumDCFCLK_params->TotalNumberOfActiveDPP = mode_lib->ms.TotalNumberOfActiveDPP;
7979                 UseMinimumDCFCLK_params->TotalNumberOfDCCActiveDPP = mode_lib->ms.TotalNumberOfDCCActiveDPP;
7980                 UseMinimumDCFCLK_params->dpte_group_bytes = mode_lib->ms.dpte_group_bytes;
7981                 UseMinimumDCFCLK_params->PrefetchLinesY = mode_lib->ms.PrefetchLinesY;
7982                 UseMinimumDCFCLK_params->PrefetchLinesC = mode_lib->ms.PrefetchLinesC;
7983                 UseMinimumDCFCLK_params->swath_width_luma_ub_all_states = mode_lib->ms.swath_width_luma_ub_all_states;
7984                 UseMinimumDCFCLK_params->swath_width_chroma_ub_all_states = mode_lib->ms.swath_width_chroma_ub_all_states;
7985                 UseMinimumDCFCLK_params->BytePerPixelY = mode_lib->ms.BytePerPixelY;
7986                 UseMinimumDCFCLK_params->BytePerPixelC = mode_lib->ms.BytePerPixelC;
7987                 UseMinimumDCFCLK_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
7988                 UseMinimumDCFCLK_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
7989                 UseMinimumDCFCLK_params->PDEAndMetaPTEBytesPerFrame = mode_lib->ms.PDEAndMetaPTEBytesPerFrame;
7990                 UseMinimumDCFCLK_params->DPTEBytesPerRow = mode_lib->ms.DPTEBytesPerRow;
7991                 UseMinimumDCFCLK_params->MetaRowBytes = mode_lib->ms.MetaRowBytes;
7992                 UseMinimumDCFCLK_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable;
7993                 UseMinimumDCFCLK_params->ReadBandwidthLuma = mode_lib->ms.ReadBandwidthLuma;
7994                 UseMinimumDCFCLK_params->ReadBandwidthChroma = mode_lib->ms.ReadBandwidthChroma;
7995                 UseMinimumDCFCLK_params->DCFCLKPerState = mode_lib->ms.state.dcfclk_mhz;
7996                 UseMinimumDCFCLK_params->DCFCLKState = mode_lib->ms.DCFCLKState;
7997
7998                 UseMinimumDCFCLK(&mode_lib->scratch,
7999                 UseMinimumDCFCLK_params);
8000
8001          } // UseMinimumRequiredDCFCLK == true
8002
8003         for (j = 0; j < 2; ++j) {
8004                 mode_lib->ms.ReturnBWPerState[j] = dml_get_return_bw_mbps(&mode_lib->ms.soc, mode_lib->ms.state.use_ideal_dram_bw_strobe,
8005                                                                                                                                 mode_lib->ms.cache_display_cfg.plane.HostVMEnable, mode_lib->ms.DCFCLKState[j], mode_lib->ms.state.fabricclk_mhz,
8006                                                                                                                                 mode_lib->ms.state.dram_speed_mts);
8007                 mode_lib->ms.ReturnDRAMBWPerState[j] = dml_get_return_dram_bw_mbps(&mode_lib->ms.soc, mode_lib->ms.state.use_ideal_dram_bw_strobe,
8008                                                                                                                                 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8009                                                                                                                                 mode_lib->ms.state.dram_speed_mts);
8010         }
8011
8012         //Re-ordering Buffer Support Check
8013         for (j = 0; j < 2; ++j) {
8014                 if ((mode_lib->ms.ip.rob_buffer_size_kbytes - mode_lib->ms.ip.pixel_chunk_size_kbytes) * 1024 / mode_lib->ms.ReturnBWPerState[j] >
8015                         (mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles + 32) / mode_lib->ms.DCFCLKState[j] + s->ReorderingBytes / mode_lib->ms.ReturnBWPerState[j]) {
8016                         mode_lib->ms.support.ROBSupport[j] = true;
8017                 } else {
8018                         mode_lib->ms.support.ROBSupport[j] = false;
8019                 }
8020                 dml_print("DML::%s: DEBUG ROBSupport[%u] = %u (%u)\n",  __func__, j, mode_lib->ms.support.ROBSupport[j], __LINE__);
8021         }
8022
8023         //Vertical Active BW support check
8024         s->MaxTotalVActiveRDBandwidth = 0;
8025         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8026                 s->MaxTotalVActiveRDBandwidth = s->MaxTotalVActiveRDBandwidth + mode_lib->ms.ReadBandwidthLuma[k] + mode_lib->ms.ReadBandwidthChroma[k];
8027         }
8028
8029         for (j = 0; j < 2; ++j) {
8030                 mode_lib->ms.support.MaxTotalVerticalActiveAvailableBandwidth[j] = dml_min3(mode_lib->ms.soc.return_bus_width_bytes * mode_lib->ms.DCFCLKState[j] * mode_lib->ms.soc.max_avg_sdp_bw_use_normal_percent / 100.0,
8031                                                                                                                                         mode_lib->ms.state.fabricclk_mhz * mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes * mode_lib->ms.soc.max_avg_fabric_bw_use_normal_percent / 100.0,
8032                                                                                                                                         mode_lib->ms.state.dram_speed_mts * mode_lib->ms.soc.num_chans * mode_lib->ms.soc.dram_channel_width_bytes *
8033                                                                                                                                         ((mode_lib->ms.state.use_ideal_dram_bw_strobe && !mode_lib->ms.cache_display_cfg.plane.HostVMEnable) ?
8034                                                                                                                                         mode_lib->ms.soc.max_avg_dram_bw_use_normal_strobe_percent : mode_lib->ms.soc.max_avg_dram_bw_use_normal_percent) / 100.0);
8035
8036                 if (s->MaxTotalVActiveRDBandwidth <= mode_lib->ms.support.MaxTotalVerticalActiveAvailableBandwidth[j]) {
8037                         mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] = true;
8038                 } else {
8039                         mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] = false;
8040                 }
8041         }
8042
8043         /* Prefetch Check */
8044         dml_prefetch_check(mode_lib);
8045
8046         // End of Prefetch Check
8047         dml_print("DML::%s: Done prefetch calculation\n", __func__);
8048
8049         /*Cursor Support Check*/
8050         mode_lib->ms.support.CursorSupport = true;
8051         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8052                 if (mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] > 0.0) {
8053                         if (mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] == 64 && mode_lib->ms.ip.cursor_64bpp_support == false) {
8054                                 mode_lib->ms.support.CursorSupport = false;
8055                         }
8056                 }
8057         }
8058
8059         /*Valid Pitch Check*/
8060         mode_lib->ms.support.PitchSupport = true;
8061         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8062                 mode_lib->ms.support.AlignedYPitch[k] = dml_ceil(
8063                                 dml_max(mode_lib->ms.cache_display_cfg.surface.PitchY[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k]),
8064                                 mode_lib->ms.MacroTileWidthY[k]);
8065                 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
8066                         mode_lib->ms.support.AlignedDCCMetaPitchY[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k]), 64.0 * mode_lib->ms.Read256BlockWidthY[k]);
8067                 } else {
8068                         mode_lib->ms.support.AlignedDCCMetaPitchY[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
8069                 }
8070                 if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64
8071                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32
8072                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16
8073                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_16
8074                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe
8075                         && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_mono_8) {
8076                         mode_lib->ms.support.AlignedCPitch[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.PitchC[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k]), mode_lib->ms.MacroTileWidthC[k]);
8077                         if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k] == true) {
8078                                 mode_lib->ms.support.AlignedDCCMetaPitchC[k] = dml_ceil(dml_max(mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k], mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k]), 64.0 * mode_lib->ms.Read256BlockWidthC[k]);
8079                         } else {
8080                                 mode_lib->ms.support.AlignedDCCMetaPitchC[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8081                         }
8082                 } else {
8083                         mode_lib->ms.support.AlignedCPitch[k] = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
8084                         mode_lib->ms.support.AlignedDCCMetaPitchC[k] = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8085                 }
8086                 if (mode_lib->ms.support.AlignedYPitch[k] > mode_lib->ms.cache_display_cfg.surface.PitchY[k] || mode_lib->ms.support.AlignedCPitch[k] > mode_lib->ms.cache_display_cfg.surface.PitchC[k] ||
8087                         mode_lib->ms.support.AlignedDCCMetaPitchY[k] > mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k] || mode_lib->ms.support.AlignedDCCMetaPitchC[k] > mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k]) {
8088                         mode_lib->ms.support.PitchSupport = false;
8089                 }
8090         }
8091
8092         mode_lib->ms.support.ViewportExceedsSurface = false;
8093         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8094                 if (mode_lib->ms.cache_display_cfg.plane.ViewportWidth[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k] || mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY[k]) {
8095                         mode_lib->ms.support.ViewportExceedsSurface = true;
8096                         if (mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_64 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_32 &&
8097                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_16 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_444_8 && mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k] != dml_rgbe) {
8098                                 if (mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k] || mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k] > mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC[k]) {
8099                                         mode_lib->ms.support.ViewportExceedsSurface = true;
8100                                 }
8101                         }
8102                 }
8103         }
8104
8105         /*Mode Support, Voltage State and SOC Configuration*/
8106         for (j = 0; j < 2; j++) { // j iterator is for the combine mode off or on
8107                 dml_print("DML::%s: checking support for j=%u\n", __func__, j);
8108                 dml_print("DML::%s: state_idx=%0d max_state_idx=%0d\n", __func__, mode_lib->ms.state_idx, mode_lib->ms.max_state_idx);
8109
8110                 s->is_max_pwr_state = (mode_lib->ms.max_state_idx == mode_lib->ms.state_idx);
8111                 s->is_max_dram_pwr_state = (mode_lib->ms.max_state.dram_speed_mts == mode_lib->ms.state.dram_speed_mts);
8112
8113                 s->dram_clock_change_support = (!mode_lib->ms.policy.DRAMClockChangeRequirementFinal ||
8114                                                                                         (s->is_max_dram_pwr_state && mode_lib->policy.AssumeModeSupportAtMaxPwrStateEvenDRAMClockChangeNotSupported) ||
8115                                                                                         mode_lib->ms.support.DRAMClockChangeSupport[j] != dml_dram_clock_change_unsupported);
8116                 s->f_clock_change_support = (!mode_lib->ms.policy.FCLKChangeRequirementFinal ||
8117                                                                                         (s->is_max_pwr_state && mode_lib->policy.AssumeModeSupportAtMaxPwrStateEvenFClockChangeNotSupported) ||
8118                                                                                         mode_lib->ms.support.FCLKChangeSupport[j] != dml_fclock_change_unsupported);
8119
8120                 if (mode_lib->ms.support.ScaleRatioAndTapsSupport == true
8121                         && mode_lib->ms.support.SourceFormatPixelAndScanSupport == true
8122                         && mode_lib->ms.support.ViewportSizeSupport[j] == true
8123                         && !mode_lib->ms.support.LinkRateDoesNotMatchDPVersion
8124                         && !mode_lib->ms.support.LinkRateForMultistreamNotIndicated
8125                         && !mode_lib->ms.support.BPPForMultistreamNotIndicated
8126                         && !mode_lib->ms.support.MultistreamWithHDMIOreDP
8127                         && !mode_lib->ms.support.ExceededMultistreamSlots
8128                         && !mode_lib->ms.support.MSOOrODMSplitWithNonDPLink
8129                         && !mode_lib->ms.support.NotEnoughLanesForMSO
8130                         && mode_lib->ms.support.LinkCapacitySupport == true
8131                         && !mode_lib->ms.support.P2IWith420
8132                         && !mode_lib->ms.support.DSCOnlyIfNecessaryWithBPP
8133                         && !mode_lib->ms.support.DSC422NativeNotSupported
8134                         && !mode_lib->ms.support.MPCCombineMethodIncompatible
8135                         && mode_lib->ms.support.ODMCombineTwoToOneSupportCheckOK == true
8136                         && mode_lib->ms.support.ODMCombineFourToOneSupportCheckOK == true
8137                         && mode_lib->ms.support.NotEnoughDSCUnits == false
8138                         && !mode_lib->ms.support.NotEnoughDSCSlices
8139                         && !mode_lib->ms.support.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
8140                         && !mode_lib->ms.support.InvalidCombinationOfMALLUseForPStateAndStaticScreen
8141                         && mode_lib->ms.support.DSCCLKRequiredMoreThanSupported == false
8142                         && mode_lib->ms.support.PixelsPerLinePerDSCUnitSupport
8143                         && mode_lib->ms.support.DTBCLKRequiredMoreThanSupported == false
8144                         && !mode_lib->ms.support.InvalidCombinationOfMALLUseForPState
8145                         && !mode_lib->ms.support.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
8146                         && mode_lib->ms.support.ROBSupport[j] == true
8147                         && mode_lib->ms.support.DISPCLK_DPPCLK_Support[j] == true
8148                         && mode_lib->ms.support.TotalAvailablePipesSupport[j] == true
8149                         && mode_lib->ms.support.NumberOfOTGSupport == true
8150                         && mode_lib->ms.support.NumberOfHDMIFRLSupport == true
8151                         && mode_lib->ms.support.NumberOfDP2p0Support == true
8152                         && mode_lib->ms.support.EnoughWritebackUnits == true
8153                         && mode_lib->ms.support.WritebackLatencySupport == true
8154                         && mode_lib->ms.support.WritebackScaleRatioAndTapsSupport == true
8155                         && mode_lib->ms.support.CursorSupport == true
8156                         && mode_lib->ms.support.PitchSupport == true
8157                         && mode_lib->ms.support.ViewportExceedsSurface == false
8158                         && mode_lib->ms.support.PrefetchSupported[j] == true
8159                         && mode_lib->ms.support.VActiveBandwithSupport[j] == true
8160                         && mode_lib->ms.support.DynamicMetadataSupported[j] == true
8161                         && mode_lib->ms.support.TotalVerticalActiveBandwidthSupport[j] == true
8162                         && mode_lib->ms.support.VRatioInPrefetchSupported[j] == true
8163                         && mode_lib->ms.support.PTEBufferSizeNotExceeded[j] == true
8164                         && mode_lib->ms.support.DCCMetaBufferSizeNotExceeded[j] == true
8165                         && mode_lib->ms.support.NonsupportedDSCInputBPC == false
8166                         && !mode_lib->ms.support.ExceededMALLSize
8167                         && ((mode_lib->ms.cache_display_cfg.plane.HostVMEnable == false && !s->ImmediateFlipRequiredFinal) || mode_lib->ms.support.ImmediateFlipSupportedForState[j])
8168                         && s->dram_clock_change_support == true
8169                         && s->f_clock_change_support == true
8170                         && (!mode_lib->ms.policy.USRRetrainingRequiredFinal || mode_lib->ms.support.USRRetrainingSupport[j])) {
8171                         dml_print("DML::%s: mode is supported\n", __func__);
8172                         mode_lib->ms.support.ModeSupport[j] = true;
8173                 } else {
8174                         dml_print("DML::%s: mode is NOT supported\n", __func__);
8175                         mode_lib->ms.support.ModeSupport[j] = false;
8176                         dml_print_mode_support(mode_lib, j);
8177                 }
8178         }
8179
8180         mode_lib->ms.support.MaximumMPCCombine = 0;
8181         mode_lib->ms.support.ModeIsSupported = 0;
8182         if (mode_lib->ms.support.ModeSupport[0] == true || mode_lib->ms.support.ModeSupport[1] == true) {  // if the mode is supported by either no combine or mpccombine
8183                 mode_lib->ms.support.ModeIsSupported = mode_lib->ms.support.ModeSupport[0] == true || mode_lib->ms.support.ModeSupport[1] == true;
8184
8185                 // Determine if MPC combine is necessary, depends on if using MPC combine will help dram clock change or fclk change, etc.
8186                 if ((mode_lib->ms.support.ModeSupport[0] == false && mode_lib->ms.support.ModeSupport[1] == true) || s->MPCCombineMethodAsPossible ||
8187                         (s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && mode_lib->ms.policy.DRAMClockChangeRequirementFinal &&
8188                         (((mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vactive_w_mall_sub_vp) &&
8189                         !(mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive || mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_vactive_w_mall_sub_vp)) ||
8190                         ((mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr
8191                 || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_w_mall_full_frame || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr_w_mall_full_frame
8192                 || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_w_mall_sub_vp || mode_lib->ms.support.DRAMClockChangeSupport[1] == dml_dram_clock_change_vblank_drr_w_mall_sub_vp
8193                 ) &&
8194                                 mode_lib->ms.support.DRAMClockChangeSupport[0] == dml_dram_clock_change_unsupported)))
8195                         || (s->MPCCombineMethodAsNeededForPStateChangeAndVoltage && mode_lib->ms.policy.FCLKChangeRequirementFinal &&
8196                                 ((mode_lib->ms.support.FCLKChangeSupport[1] == dml_fclock_change_vactive && mode_lib->ms.support.FCLKChangeSupport[0] != dml_fclock_change_vactive) ||
8197                                 (mode_lib->ms.support.FCLKChangeSupport[1] == dml_fclock_change_vblank && mode_lib->ms.support.FCLKChangeSupport[0] == dml_fclock_change_unsupported)))) {
8198                         mode_lib->ms.support.MaximumMPCCombine = 1;
8199                 } else {
8200                         mode_lib->ms.support.MaximumMPCCombine = 0;
8201                 }
8202         }
8203
8204         // Since now the mode_support work on 1 particular power state, so there is only 1 state idx (index 0).
8205         mode_lib->ms.support.ImmediateFlipSupport          = mode_lib->ms.support.ImmediateFlipSupportedForState[mode_lib->ms.support.MaximumMPCCombine];   // Consider flip support if max combine support imm flip
8206         mode_lib->ms.support.UnboundedRequestEnabled       = mode_lib->ms.UnboundedRequestEnabledAllStates[mode_lib->ms.support.MaximumMPCCombine];         // Not used, informational
8207         mode_lib->ms.support.CompressedBufferSizeInkByte   = mode_lib->ms.CompressedBufferSizeInkByteAllStates[mode_lib->ms.support.MaximumMPCCombine];     // Not used, informational
8208
8209         dml_print("DML::%s: ModeIsSupported                = %u\n", __func__, mode_lib->ms.support.ModeIsSupported);
8210         dml_print("DML::%s: MaximumMPCCombine              = %u\n", __func__, mode_lib->ms.support.MaximumMPCCombine);
8211         dml_print("DML::%s: ImmediateFlipSupport           = %u\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
8212         dml_print("DML::%s: UnboundedRequestEnabled        = %u\n", __func__, mode_lib->ms.support.UnboundedRequestEnabled);
8213         dml_print("DML::%s: CompressedBufferSizeInkByte    = %u\n", __func__, mode_lib->ms.support.CompressedBufferSizeInkByte);
8214
8215         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8216                 mode_lib->ms.support.MPCCombineEnable[k]   = mode_lib->ms.MPCCombine[mode_lib->ms.support.MaximumMPCCombine][k];
8217                 mode_lib->ms.support.DPPPerSurface[k]      = mode_lib->ms.NoOfDPP[mode_lib->ms.support.MaximumMPCCombine][k];
8218                 mode_lib->ms.SwathHeightY[k]               = mode_lib->ms.SwathHeightYAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8219                 mode_lib->ms.SwathHeightC[k]               = mode_lib->ms.SwathHeightCAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8220                 mode_lib->ms.DETBufferSizeInKByte[k]       = mode_lib->ms.DETBufferSizeInKByteAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8221                 mode_lib->ms.DETBufferSizeY[k]             = mode_lib->ms.DETBufferSizeYAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8222                 mode_lib->ms.DETBufferSizeC[k]             = mode_lib->ms.DETBufferSizeCAllStates[mode_lib->ms.support.MaximumMPCCombine][k];
8223         }
8224
8225         mode_lib->ms.DRAMSpeed     = mode_lib->ms.state.dram_speed_mts;
8226         mode_lib->ms.FabricClock   = mode_lib->ms.state.fabricclk_mhz;
8227         mode_lib->ms.SOCCLK        = mode_lib->ms.state.socclk_mhz;
8228         mode_lib->ms.DCFCLK        = mode_lib->ms.DCFCLKState[mode_lib->ms.support.MaximumMPCCombine];
8229         mode_lib->ms.ReturnBW      = mode_lib->ms.ReturnBWPerState[mode_lib->ms.support.MaximumMPCCombine];
8230         mode_lib->ms.ReturnDRAMBW  = mode_lib->ms.ReturnDRAMBWPerState[mode_lib->ms.support.MaximumMPCCombine];
8231
8232         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8233                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8234                         mode_lib->ms.support.ODMMode[k] = mode_lib->ms.ODMModePerState[k];
8235                 } else {
8236                         mode_lib->ms.support.ODMMode[k] = dml_odm_mode_bypass;
8237                 }
8238
8239                 mode_lib->ms.support.DSCEnabled[k] = mode_lib->ms.RequiresDSC[k];
8240                 mode_lib->ms.support.FECEnabled[k] = mode_lib->ms.RequiresFEC[k];
8241                 mode_lib->ms.support.OutputBpp[k] = mode_lib->ms.OutputBppPerState[k];
8242                 mode_lib->ms.support.OutputType[k] = mode_lib->ms.OutputTypePerState[k];
8243                 mode_lib->ms.support.OutputRate[k] = mode_lib->ms.OutputRatePerState[k];
8244                 mode_lib->ms.support.SubViewportLinesNeededInMALL[k] = mode_lib->ms.SubViewportLinesNeededInMALL[k];
8245         }
8246
8247         return mode_lib->ms.support.ModeIsSupported;
8248 } // dml_core_mode_support
8249
8250 /// @brief This function calculates some parameters thats are needed ahead of the mode programming function all
8251 void dml_core_mode_support_partial(struct display_mode_lib_st *mode_lib)
8252 {
8253         CalculateMaxDETAndMinCompressedBufferSize(
8254                                                                 mode_lib->ms.ip.config_return_buffer_size_in_kbytes,
8255                                                                 mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes,
8256                                                                 mode_lib->ms.ip.rob_buffer_size_kbytes,
8257                                                                 mode_lib->ms.ip.max_num_dpp,
8258                                                                 mode_lib->ms.policy.NomDETInKByteOverrideEnable,
8259                                                                 mode_lib->ms.policy.NomDETInKByteOverrideValue,
8260
8261                                                                 /* Output */
8262                                                                 &mode_lib->ms.MaxTotalDETInKByte,
8263                                                                 &mode_lib->ms.NomDETInKByte,
8264                                                                 &mode_lib->ms.MinCompressedBufferSizeInKByte);
8265
8266         PixelClockAdjustmentForProgressiveToInterlaceUnit(&mode_lib->ms.cache_display_cfg, mode_lib->ms.ip.ptoi_supported);
8267
8268         mode_lib->ms.ReturnBW = dml_get_return_bw_mbps(&mode_lib->ms.soc,
8269                                                                                                         mode_lib->ms.state.use_ideal_dram_bw_strobe,
8270                                                                                                         mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8271                                                                                                         mode_lib->ms.DCFCLK,
8272                                                                                                         mode_lib->ms.FabricClock,
8273                                                                                                         mode_lib->ms.DRAMSpeed);
8274         dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->ms.ReturnBW);
8275
8276 } // dml_core_mode_support_partial
8277
8278 /// @brief This is the mode programming function. It is assumed the display cfg is support at the given power state
8279 void dml_core_mode_programming(struct display_mode_lib_st *mode_lib, const struct dml_clk_cfg_st *clk_cfg)
8280 {
8281         struct dml_core_mode_programming_locals_st *s = &mode_lib->scratch.dml_core_mode_programming_locals;
8282         struct CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params_st *CalculateWatermarks_params = &mode_lib->scratch.CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport_params;
8283         struct CalculateVMRowAndSwath_params_st *CalculateVMRowAndSwath_params = &mode_lib->scratch.CalculateVMRowAndSwath_params;
8284         struct CalculateSwathAndDETConfiguration_params_st *CalculateSwathAndDETConfiguration_params = &mode_lib->scratch.CalculateSwathAndDETConfiguration_params;
8285         struct CalculateStutterEfficiency_params_st *CalculateStutterEfficiency_params = &mode_lib->scratch.CalculateStutterEfficiency_params;
8286         struct CalculatePrefetchSchedule_params_st *CalculatePrefetchSchedule_params = &mode_lib->scratch.CalculatePrefetchSchedule_params;
8287
8288         struct mode_program_st   *locals    = &mode_lib->mp;
8289         struct DmlPipe *myPipe;
8290         dml_uint_t j = 0, k = 0;
8291         dml_float_t TWait;
8292         dml_bool_t isInterlaceTiming;
8293
8294         mode_lib->ms.num_active_planes = dml_get_num_active_planes(&mode_lib->ms.cache_display_cfg);
8295         mode_lib->mp.num_active_pipes = dml_get_num_active_pipes(&mode_lib->ms.cache_display_cfg);
8296         dml_calc_pipe_plane_mapping(&mode_lib->ms.cache_display_cfg.hw, mode_lib->mp.pipe_plane);
8297
8298 #ifdef __DML_VBA_DEBUG__
8299         dml_print("DML::%s: --- START --- \n",  __func__);
8300         dml_print("DML::%s: num_active_planes = %u\n", __func__, mode_lib->ms.num_active_planes);
8301         dml_print("DML::%s: num_active_pipes = %u\n", __func__, mode_lib->mp.num_active_pipes);
8302 #endif
8303
8304         s->DSCFormatFactor          = 0;
8305
8306         // Unlike dppclk and dispclk which can be calculated in mode_programming
8307         // DCFCLK is calculated in mode_support (which is the state bbox dcfclk or min dcfclk if min dcfclk option is used in mode support calculation)
8308         if (clk_cfg->dcfclk_option != dml_use_override_freq)
8309                 locals->Dcfclk = mode_lib->ms.DCFCLK;
8310         else
8311                 locals->Dcfclk = clk_cfg->dcfclk_freq_mhz;
8312
8313 #ifdef __DML_VBA_DEBUG__
8314         dml_print_dml_policy(&mode_lib->ms.policy);
8315         dml_print_soc_state_bounding_box(&mode_lib->ms.state);
8316         dml_print_soc_bounding_box(&mode_lib->ms.soc);
8317         dml_print_clk_cfg(clk_cfg);
8318
8319         dml_print("DML::%s: ImmediateFlipSupport = %u\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
8320         dml_print("DML::%s: Using DCFCLK = %f\n", __func__, locals->Dcfclk);
8321         dml_print("DML::%s: Using SOCCLK = %f\n", __func__, mode_lib->ms.SOCCLK);
8322 #endif
8323
8324         locals->WritebackDISPCLK = 0.0;
8325         locals->GlobalDPPCLK = 0.0;
8326
8327         // DISPCLK and DPPCLK Calculation
8328         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8329                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k]) {
8330                         locals->WritebackDISPCLK =
8331                                         dml_max(
8332                                                         locals->WritebackDISPCLK,
8333                                                         CalculateWriteBackDISPCLK(
8334                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
8335                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8336                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
8337                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
8338                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHTaps[k],
8339                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
8340                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackSourceWidth[k],
8341                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
8342                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k],
8343                                                                         mode_lib->ms.ip.writeback_line_buffer_buffer_size,
8344                                                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz));
8345                 }
8346         }
8347
8348         locals->Dispclk_calculated = locals->WritebackDISPCLK;
8349
8350         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8351                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8352                                 locals->Dispclk_calculated = dml_max(locals->Dispclk_calculated, CalculateRequiredDispclk(
8353                                                                                                                                                                         mode_lib->ms.cache_display_cfg.hw.ODMMode[k],
8354                                                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8355                                                                                                                                                                         mode_lib->ms.soc.dcn_downspread_percent,
8356                                                                                                                                                                         mode_lib->ms.ip.dispclk_ramp_margin_percent,
8357                                                                                                                                                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
8358                                                                                                                                                                         mode_lib->ms.max_state.dispclk_mhz));
8359                 }
8360         }
8361         if (clk_cfg->dispclk_option == dml_use_required_freq)
8362                 locals->Dispclk = locals->Dispclk_calculated;
8363         else if (clk_cfg->dispclk_option == dml_use_override_freq)
8364                 locals->Dispclk = clk_cfg->dispclk_freq_mhz;
8365         else
8366                 locals->Dispclk = mode_lib->ms.state.dispclk_mhz;
8367 #ifdef __DML_VBA_DEBUG__
8368          dml_print("DML::%s: Using Dispclk = %f\n", __func__, locals->Dispclk);
8369 #endif
8370
8371         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8372                 CalculateSinglePipeDPPCLKAndSCLThroughput(
8373                                 mode_lib->ms.cache_display_cfg.plane.HRatio[k],
8374                                 mode_lib->ms.cache_display_cfg.plane.HRatioChroma[k],
8375                                 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
8376                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
8377                                 mode_lib->ms.ip.max_dchub_pscl_bw_pix_per_clk,
8378                                 mode_lib->ms.ip.max_pscl_lb_bw_pix_per_clk,
8379                                 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8380                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
8381                                 mode_lib->ms.cache_display_cfg.plane.HTaps[k],
8382                                 mode_lib->ms.cache_display_cfg.plane.HTapsChroma[k],
8383                                 mode_lib->ms.cache_display_cfg.plane.VTaps[k],
8384                                 mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k],
8385
8386                                 /* Output */
8387                                 &locals->PSCL_THROUGHPUT[k],
8388                                 &locals->PSCL_THROUGHPUT_CHROMA[k],
8389                                 &locals->DPPCLKUsingSingleDPP[k]);
8390         }
8391
8392         CalculateDPPCLK(mode_lib->ms.num_active_planes,
8393                                         mode_lib->ms.soc.dcn_downspread_percent,
8394                                         mode_lib->ms.soc.dispclk_dppclk_vco_speed_mhz,
8395                                         locals->DPPCLKUsingSingleDPP,
8396                                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8397                                         /* Output */
8398                                         &locals->GlobalDPPCLK,
8399                                         locals->Dppclk_calculated);
8400
8401         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8402                 if (clk_cfg->dppclk_option[k] == dml_use_required_freq)
8403                         locals->Dppclk[k] = locals->Dppclk_calculated[k];
8404                 else if (clk_cfg->dppclk_option[k] == dml_use_override_freq)
8405                         locals->Dppclk[k] = clk_cfg->dppclk_freq_mhz[k];
8406                 else
8407                         locals->Dppclk[k] = mode_lib->ms.state.dppclk_mhz;
8408 #ifdef __DML_VBA_DEBUG__
8409                 dml_print("DML::%s: Using Dppclk[%0d] = %f\n", __func__, k, locals->Dppclk[k]);
8410 #endif
8411         }
8412
8413         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8414                 CalculateBytePerPixelAndBlockSizes(
8415                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
8416                                 mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
8417
8418                                 /* Output */
8419                                 &locals->BytePerPixelY[k],
8420                                 &locals->BytePerPixelC[k],
8421                                 &locals->BytePerPixelDETY[k],
8422                                 &locals->BytePerPixelDETC[k],
8423                                 &locals->BlockHeight256BytesY[k],
8424                                 &locals->BlockHeight256BytesC[k],
8425                                 &locals->BlockWidth256BytesY[k],
8426                                 &locals->BlockWidth256BytesC[k],
8427                                 &locals->BlockHeightY[k],
8428                                 &locals->BlockHeightC[k],
8429                                 &locals->BlockWidthY[k],
8430                                 &locals->BlockWidthC[k]);
8431         }
8432
8433
8434         dml_print("DML::%s: %u\n", __func__, __LINE__);
8435         CalculateSwathWidth(
8436                 false,  // ForceSingleDPP
8437                 mode_lib->ms.num_active_planes,
8438                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat,
8439                 mode_lib->ms.cache_display_cfg.plane.SourceScan,
8440                 mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
8441                 mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
8442                 mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
8443                 mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
8444                 mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
8445                 mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
8446                 mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
8447                 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
8448                 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
8449                 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
8450                 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
8451                 mode_lib->ms.cache_display_cfg.hw.ODMMode,
8452                 locals->BytePerPixelY,
8453                 locals->BytePerPixelC,
8454                 locals->BlockHeight256BytesY,
8455                 locals->BlockHeight256BytesC,
8456                 locals->BlockWidth256BytesY,
8457                 locals->BlockWidth256BytesC,
8458                 mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming,
8459                 mode_lib->ms.cache_display_cfg.timing.HActive,
8460                 mode_lib->ms.cache_display_cfg.plane.HRatio,
8461                 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8462
8463                 /* Output */
8464                 locals->SwathWidthSingleDPPY,
8465                 locals->SwathWidthSingleDPPC,
8466                 locals->SwathWidthY,
8467                 locals->SwathWidthC,
8468                 s->dummy_integer_array[0], // dml_uint_t MaximumSwathHeightY[]
8469                 s->dummy_integer_array[1], // dml_uint_t MaximumSwathHeightC[]
8470                 locals->swath_width_luma_ub,
8471                 locals->swath_width_chroma_ub);
8472
8473         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8474                 locals->ReadBandwidthSurfaceLuma[k] = locals->SwathWidthSingleDPPY[k] * locals->BytePerPixelY[k] / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8475                 locals->ReadBandwidthSurfaceChroma[k] = locals->SwathWidthSingleDPPC[k] * locals->BytePerPixelC[k] / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
8476                 dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
8477                 dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
8478         }
8479
8480         CalculateSwathAndDETConfiguration_params->DETSizeOverride = mode_lib->ms.cache_display_cfg.plane.DETSizeOverride;
8481         CalculateSwathAndDETConfiguration_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
8482         CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSizeInKByte = mode_lib->ms.ip.config_return_buffer_size_in_kbytes;
8483         CalculateSwathAndDETConfiguration_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
8484         CalculateSwathAndDETConfiguration_params->MaxTotalDETInKByte = mode_lib->ms.MaxTotalDETInKByte;
8485         CalculateSwathAndDETConfiguration_params->MinCompressedBufferSizeInKByte = mode_lib->ms.MinCompressedBufferSizeInKByte;
8486         CalculateSwathAndDETConfiguration_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
8487         CalculateSwathAndDETConfiguration_params->ForceSingleDPP = false;
8488         CalculateSwathAndDETConfiguration_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
8489         CalculateSwathAndDETConfiguration_params->nomDETInKByte = mode_lib->ms.NomDETInKByte;
8490         CalculateSwathAndDETConfiguration_params->UseUnboundedRequestingFinal = mode_lib->ms.policy.UseUnboundedRequesting;
8491         CalculateSwathAndDETConfiguration_params->ConfigReturnBufferSegmentSizeInkByte = mode_lib->ms.ip.config_return_buffer_segment_size_in_kbytes;
8492         CalculateSwathAndDETConfiguration_params->CompressedBufferSegmentSizeInkByteFinal = mode_lib->ms.ip.compressed_buffer_segment_size_in_kbytes;
8493         CalculateSwathAndDETConfiguration_params->Output = s->dummy_output_encoder_array;
8494         CalculateSwathAndDETConfiguration_params->ReadBandwidthLuma = locals->ReadBandwidthSurfaceLuma;
8495         CalculateSwathAndDETConfiguration_params->ReadBandwidthChroma = locals->ReadBandwidthSurfaceChroma;
8496         CalculateSwathAndDETConfiguration_params->MaximumSwathWidthLuma = s->dummy_single_array[0];
8497         CalculateSwathAndDETConfiguration_params->MaximumSwathWidthChroma = s->dummy_single_array[1];
8498         CalculateSwathAndDETConfiguration_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
8499         CalculateSwathAndDETConfiguration_params->ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary;
8500         CalculateSwathAndDETConfiguration_params->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat;
8501         CalculateSwathAndDETConfiguration_params->SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling;
8502         CalculateSwathAndDETConfiguration_params->ViewportWidth = mode_lib->ms.cache_display_cfg.plane.ViewportWidth;
8503         CalculateSwathAndDETConfiguration_params->ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight;
8504         CalculateSwathAndDETConfiguration_params->ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart;
8505         CalculateSwathAndDETConfiguration_params->ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart;
8506         CalculateSwathAndDETConfiguration_params->ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC;
8507         CalculateSwathAndDETConfiguration_params->ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC;
8508         CalculateSwathAndDETConfiguration_params->SurfaceWidthY = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY;
8509         CalculateSwathAndDETConfiguration_params->SurfaceWidthC = mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC;
8510         CalculateSwathAndDETConfiguration_params->SurfaceHeightY = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY;
8511         CalculateSwathAndDETConfiguration_params->SurfaceHeightC = mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC;
8512         CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightY = locals->BlockHeight256BytesY;
8513         CalculateSwathAndDETConfiguration_params->Read256BytesBlockHeightC = locals->BlockHeight256BytesC;
8514         CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthY = locals->BlockWidth256BytesY;
8515         CalculateSwathAndDETConfiguration_params->Read256BytesBlockWidthC = locals->BlockWidth256BytesC;
8516         CalculateSwathAndDETConfiguration_params->ODMMode = mode_lib->ms.cache_display_cfg.hw.ODMMode;
8517         CalculateSwathAndDETConfiguration_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
8518         CalculateSwathAndDETConfiguration_params->BytePerPixY = locals->BytePerPixelY;
8519         CalculateSwathAndDETConfiguration_params->BytePerPixC = locals->BytePerPixelC;
8520         CalculateSwathAndDETConfiguration_params->BytePerPixDETY = locals->BytePerPixelDETY;
8521         CalculateSwathAndDETConfiguration_params->BytePerPixDETC = locals->BytePerPixelDETC;
8522         CalculateSwathAndDETConfiguration_params->HActive = mode_lib->ms.cache_display_cfg.timing.HActive;
8523         CalculateSwathAndDETConfiguration_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
8524         CalculateSwathAndDETConfiguration_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
8525         CalculateSwathAndDETConfiguration_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
8526         CalculateSwathAndDETConfiguration_params->swath_width_luma_ub = s->dummy_long_array[0];
8527         CalculateSwathAndDETConfiguration_params->swath_width_chroma_ub = s->dummy_long_array[1];
8528         CalculateSwathAndDETConfiguration_params->SwathWidth = s->dummy_long_array[2];
8529         CalculateSwathAndDETConfiguration_params->SwathWidthChroma = s->dummy_long_array[3];
8530         CalculateSwathAndDETConfiguration_params->SwathHeightY = locals->SwathHeightY;
8531         CalculateSwathAndDETConfiguration_params->SwathHeightC = locals->SwathHeightC;
8532         CalculateSwathAndDETConfiguration_params->DETBufferSizeInKByte = locals->DETBufferSizeInKByte;
8533         CalculateSwathAndDETConfiguration_params->DETBufferSizeY = locals->DETBufferSizeY;
8534         CalculateSwathAndDETConfiguration_params->DETBufferSizeC = locals->DETBufferSizeC;
8535         CalculateSwathAndDETConfiguration_params->UnboundedRequestEnabled = &locals->UnboundedRequestEnabled;
8536         CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_64b = &locals->compbuf_reserved_space_64b;
8537         CalculateSwathAndDETConfiguration_params->compbuf_reserved_space_zs = &locals->compbuf_reserved_space_zs;
8538         CalculateSwathAndDETConfiguration_params->CompressedBufferSizeInkByte = &locals->CompressedBufferSizeInkByte;
8539         CalculateSwathAndDETConfiguration_params->ViewportSizeSupportPerSurface = &s->dummy_boolean_array[0][0];
8540         CalculateSwathAndDETConfiguration_params->ViewportSizeSupport = &s->dummy_boolean[0];
8541
8542         // VBA_DELTA
8543         // Calculate DET size, swath height here. In VBA, they are calculated in mode check stage
8544         CalculateSwathAndDETConfiguration(&mode_lib->scratch,
8545                 CalculateSwathAndDETConfiguration_params);
8546
8547         // DCFCLK Deep Sleep
8548         CalculateDCFCLKDeepSleep(
8549                         mode_lib->ms.num_active_planes,
8550                         locals->BytePerPixelY,
8551                         locals->BytePerPixelC,
8552                         mode_lib->ms.cache_display_cfg.plane.VRatio,
8553                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
8554                         locals->SwathWidthY,
8555                         locals->SwathWidthC,
8556                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8557                         mode_lib->ms.cache_display_cfg.plane.HRatio,
8558                         mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
8559                         mode_lib->ms.cache_display_cfg.timing.PixelClock,
8560                         locals->PSCL_THROUGHPUT,
8561                         locals->PSCL_THROUGHPUT_CHROMA,
8562                         locals->Dppclk,
8563                         locals->ReadBandwidthSurfaceLuma,
8564                         locals->ReadBandwidthSurfaceChroma,
8565                         mode_lib->ms.soc.return_bus_width_bytes,
8566
8567                         /* Output */
8568                         &locals->DCFCLKDeepSleep);
8569
8570         // DSCCLK
8571         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8572                 if ((mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] != k) || !mode_lib->ms.cache_display_cfg.hw.DSCEnabled[k]) {
8573                         locals->DSCCLK_calculated[k] = 0.0;
8574                 } else {
8575                         if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_420)
8576                                 s->DSCFormatFactor = 2;
8577                         else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_444)
8578                                 s->DSCFormatFactor = 1;
8579                         else if (mode_lib->ms.cache_display_cfg.output.OutputFormat[k] == dml_n422 || mode_lib->ms.cache_display_cfg.output.OutputEncoder[k] == dml_hdmifrl)
8580                                 s->DSCFormatFactor = 2;
8581                         else
8582                                 s->DSCFormatFactor = 1;
8583                         if (mode_lib->ms.cache_display_cfg.hw.ODMMode[k] == dml_odm_mode_combine_4to1)
8584                                 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 12 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8585                         else if (mode_lib->ms.cache_display_cfg.hw.ODMMode[k] == dml_odm_mode_combine_2to1)
8586                                 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 6 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8587                         else
8588                                 locals->DSCCLK_calculated[k] = mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k] / 3 / s->DSCFormatFactor / (1 - mode_lib->ms.soc.dcn_downspread_percent / 100);
8589                 }
8590         }
8591
8592         // DSC Delay
8593         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8594                 locals->DSCDelay[k] = DSCDelayRequirement(mode_lib->ms.cache_display_cfg.hw.DSCEnabled[k],
8595                                                                                                 mode_lib->ms.cache_display_cfg.hw.ODMMode[k],
8596                                                                                                 mode_lib->ms.cache_display_cfg.output.DSCInputBitPerComponent[k],
8597                                                                                                 mode_lib->ms.cache_display_cfg.output.OutputBpp[k],
8598                                                                                                 mode_lib->ms.cache_display_cfg.timing.HActive[k],
8599                                                                                                 mode_lib->ms.cache_display_cfg.timing.HTotal[k],
8600                                                                                                 mode_lib->ms.cache_display_cfg.hw.NumberOfDSCSlices[k],
8601                                                                                                 mode_lib->ms.cache_display_cfg.output.OutputFormat[k],
8602                                                                                                 mode_lib->ms.cache_display_cfg.output.OutputEncoder[k],
8603                                                                                                 mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8604                                                                                                 mode_lib->ms.cache_display_cfg.output.PixelClockBackEnd[k]);
8605         }
8606
8607         for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8608                 for (j = 0; j < mode_lib->ms.num_active_planes; ++j) // NumberOfSurfaces
8609                         if (j != k && mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == j && mode_lib->ms.cache_display_cfg.hw.DSCEnabled[j])
8610                                 locals->DSCDelay[k] = locals->DSCDelay[j];
8611
8612         // Prefetch
8613         CalculateSurfaceSizeInMall(
8614                 mode_lib->ms.num_active_planes,
8615                 mode_lib->ms.soc.mall_allocated_for_dcn_mbytes,
8616                 mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen,
8617                 mode_lib->ms.cache_display_cfg.surface.DCCEnable,
8618                 mode_lib->ms.cache_display_cfg.plane.ViewportStationary,
8619                 mode_lib->ms.cache_display_cfg.plane.ViewportXStart,
8620                 mode_lib->ms.cache_display_cfg.plane.ViewportYStart,
8621                 mode_lib->ms.cache_display_cfg.plane.ViewportXStartC,
8622                 mode_lib->ms.cache_display_cfg.plane.ViewportYStartC,
8623                 mode_lib->ms.cache_display_cfg.plane.ViewportWidth,
8624                 mode_lib->ms.cache_display_cfg.plane.ViewportHeight,
8625                 locals->BytePerPixelY,
8626                 mode_lib->ms.cache_display_cfg.plane.ViewportWidthChroma,
8627                 mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma,
8628                 locals->BytePerPixelC,
8629                 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY,
8630                 mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC,
8631                 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY,
8632                 mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC,
8633                 locals->BlockWidth256BytesY,
8634                 locals->BlockWidth256BytesC,
8635                 locals->BlockHeight256BytesY,
8636                 locals->BlockHeight256BytesC,
8637                 locals->BlockWidthY,
8638                 locals->BlockWidthC,
8639                 locals->BlockHeightY,
8640                 locals->BlockHeightC,
8641
8642                 /* Output */
8643                 locals->SurfaceSizeInTheMALL,
8644                 &s->dummy_boolean[0]); /* dml_bool_t *ExceededMALLSize */
8645
8646         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8647                 s->SurfaceParameters[k].PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
8648                 s->SurfaceParameters[k].DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8649                 s->SurfaceParameters[k].SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
8650                 s->SurfaceParameters[k].ViewportHeight = mode_lib->ms.cache_display_cfg.plane.ViewportHeight[k];
8651                 s->SurfaceParameters[k].ViewportHeightChroma = mode_lib->ms.cache_display_cfg.plane.ViewportHeightChroma[k];
8652                 s->SurfaceParameters[k].BlockWidth256BytesY = locals->BlockWidth256BytesY[k];
8653                 s->SurfaceParameters[k].BlockHeight256BytesY = locals->BlockHeight256BytesY[k];
8654                 s->SurfaceParameters[k].BlockWidth256BytesC = locals->BlockWidth256BytesC[k];
8655                 s->SurfaceParameters[k].BlockHeight256BytesC = locals->BlockHeight256BytesC[k];
8656                 s->SurfaceParameters[k].BlockWidthY = locals->BlockWidthY[k];
8657                 s->SurfaceParameters[k].BlockHeightY = locals->BlockHeightY[k];
8658                 s->SurfaceParameters[k].BlockWidthC = locals->BlockWidthC[k];
8659                 s->SurfaceParameters[k].BlockHeightC = locals->BlockHeightC[k];
8660                 s->SurfaceParameters[k].InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
8661                 s->SurfaceParameters[k].HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
8662                 s->SurfaceParameters[k].DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
8663                 s->SurfaceParameters[k].SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
8664                 s->SurfaceParameters[k].SurfaceTiling = mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k];
8665                 s->SurfaceParameters[k].BytePerPixelY = locals->BytePerPixelY[k];
8666                 s->SurfaceParameters[k].BytePerPixelC = locals->BytePerPixelC[k];
8667                 s->SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
8668                 s->SurfaceParameters[k].VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8669                 s->SurfaceParameters[k].VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k];
8670                 s->SurfaceParameters[k].VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps[k];
8671                 s->SurfaceParameters[k].VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma[k];
8672                 s->SurfaceParameters[k].PitchY = mode_lib->ms.cache_display_cfg.surface.PitchY[k];
8673                 s->SurfaceParameters[k].DCCMetaPitchY = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchY[k];
8674                 s->SurfaceParameters[k].PitchC = mode_lib->ms.cache_display_cfg.surface.PitchC[k];
8675                 s->SurfaceParameters[k].DCCMetaPitchC = mode_lib->ms.cache_display_cfg.surface.DCCMetaPitchC[k];
8676                 s->SurfaceParameters[k].ViewportStationary = mode_lib->ms.cache_display_cfg.plane.ViewportStationary[k];
8677                 s->SurfaceParameters[k].ViewportXStart = mode_lib->ms.cache_display_cfg.plane.ViewportXStart[k];
8678                 s->SurfaceParameters[k].ViewportYStart = mode_lib->ms.cache_display_cfg.plane.ViewportYStart[k];
8679                 s->SurfaceParameters[k].ViewportXStartC = mode_lib->ms.cache_display_cfg.plane.ViewportXStartC[k];
8680                 s->SurfaceParameters[k].ViewportYStartC = mode_lib->ms.cache_display_cfg.plane.ViewportYStartC[k];
8681                 s->SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->ms.cache_display_cfg.plane.ForceOneRowForFrame[k];
8682                 s->SurfaceParameters[k].SwathHeightY = locals->SwathHeightY[k];
8683                 s->SurfaceParameters[k].SwathHeightC = locals->SwathHeightC[k];
8684         }
8685
8686         CalculateVMRowAndSwath_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
8687         CalculateVMRowAndSwath_params->myPipe = s->SurfaceParameters;
8688         CalculateVMRowAndSwath_params->SurfaceSizeInMALL = locals->SurfaceSizeInTheMALL;
8689         CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsLuma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_luma;
8690         CalculateVMRowAndSwath_params->PTEBufferSizeInRequestsChroma = mode_lib->ms.ip.dpte_buffer_size_in_pte_reqs_chroma;
8691         CalculateVMRowAndSwath_params->DCCMetaBufferSizeBytes = mode_lib->ms.ip.dcc_meta_buffer_size_bytes;
8692         CalculateVMRowAndSwath_params->UseMALLForStaticScreen = mode_lib->ms.cache_display_cfg.plane.UseMALLForStaticScreen;
8693         CalculateVMRowAndSwath_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
8694         CalculateVMRowAndSwath_params->MALLAllocatedForDCN = mode_lib->ms.soc.mall_allocated_for_dcn_mbytes;
8695         CalculateVMRowAndSwath_params->SwathWidthY = locals->SwathWidthY;
8696         CalculateVMRowAndSwath_params->SwathWidthC = locals->SwathWidthC;
8697         CalculateVMRowAndSwath_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
8698         CalculateVMRowAndSwath_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
8699         CalculateVMRowAndSwath_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
8700         CalculateVMRowAndSwath_params->GPUVMMaxPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
8701         CalculateVMRowAndSwath_params->GPUVMMinPageSizeKBytes = mode_lib->ms.cache_display_cfg.plane.GPUVMMinPageSizeKBytes;
8702         CalculateVMRowAndSwath_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024;
8703         CalculateVMRowAndSwath_params->PTEBufferModeOverrideEn = mode_lib->ms.cache_display_cfg.plane.PTEBufferModeOverrideEn;
8704         CalculateVMRowAndSwath_params->PTEBufferModeOverrideVal = mode_lib->ms.cache_display_cfg.plane.PTEBufferMode;
8705         CalculateVMRowAndSwath_params->PTEBufferSizeNotExceeded = s->dummy_boolean_array[0];
8706         CalculateVMRowAndSwath_params->DCCMetaBufferSizeNotExceeded = s->dummy_boolean_array[1];
8707         CalculateVMRowAndSwath_params->dpte_row_width_luma_ub = locals->dpte_row_width_luma_ub;
8708         CalculateVMRowAndSwath_params->dpte_row_width_chroma_ub = locals->dpte_row_width_chroma_ub;
8709         CalculateVMRowAndSwath_params->dpte_row_height_luma = locals->dpte_row_height;
8710         CalculateVMRowAndSwath_params->dpte_row_height_chroma = locals->dpte_row_height_chroma;
8711         CalculateVMRowAndSwath_params->dpte_row_height_linear_luma = locals->dpte_row_height_linear;
8712         CalculateVMRowAndSwath_params->dpte_row_height_linear_chroma = locals->dpte_row_height_linear_chroma;
8713         CalculateVMRowAndSwath_params->meta_req_width = locals->meta_req_width;
8714         CalculateVMRowAndSwath_params->meta_req_width_chroma = locals->meta_req_width_chroma;
8715         CalculateVMRowAndSwath_params->meta_req_height = locals->meta_req_height;
8716         CalculateVMRowAndSwath_params->meta_req_height_chroma = locals->meta_req_height_chroma;
8717         CalculateVMRowAndSwath_params->meta_row_width = locals->meta_row_width;
8718         CalculateVMRowAndSwath_params->meta_row_width_chroma = locals->meta_row_width_chroma;
8719         CalculateVMRowAndSwath_params->meta_row_height = locals->meta_row_height;
8720         CalculateVMRowAndSwath_params->meta_row_height_chroma = locals->meta_row_height_chroma;
8721         CalculateVMRowAndSwath_params->vm_group_bytes = locals->vm_group_bytes;
8722         CalculateVMRowAndSwath_params->dpte_group_bytes = locals->dpte_group_bytes;
8723         CalculateVMRowAndSwath_params->PixelPTEReqWidthY = locals->PixelPTEReqWidthY;
8724         CalculateVMRowAndSwath_params->PixelPTEReqHeightY = locals->PixelPTEReqHeightY;
8725         CalculateVMRowAndSwath_params->PTERequestSizeY = locals->PTERequestSizeY;
8726         CalculateVMRowAndSwath_params->PixelPTEReqWidthC = locals->PixelPTEReqWidthC;
8727         CalculateVMRowAndSwath_params->PixelPTEReqHeightC = locals->PixelPTEReqHeightC;
8728         CalculateVMRowAndSwath_params->PTERequestSizeC = locals->PTERequestSizeC;
8729         CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_l = locals->dpde0_bytes_per_frame_ub_l;
8730         CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_l = locals->meta_pte_bytes_per_frame_ub_l;
8731         CalculateVMRowAndSwath_params->dpde0_bytes_per_frame_ub_c = locals->dpde0_bytes_per_frame_ub_c;
8732         CalculateVMRowAndSwath_params->meta_pte_bytes_per_frame_ub_c = locals->meta_pte_bytes_per_frame_ub_c;
8733         CalculateVMRowAndSwath_params->PrefetchSourceLinesY = locals->PrefetchSourceLinesY;
8734         CalculateVMRowAndSwath_params->PrefetchSourceLinesC = locals->PrefetchSourceLinesC;
8735         CalculateVMRowAndSwath_params->VInitPreFillY = locals->VInitPreFillY;
8736         CalculateVMRowAndSwath_params->VInitPreFillC = locals->VInitPreFillC;
8737         CalculateVMRowAndSwath_params->MaxNumSwathY = locals->MaxNumSwathY;
8738         CalculateVMRowAndSwath_params->MaxNumSwathC = locals->MaxNumSwathC;
8739         CalculateVMRowAndSwath_params->meta_row_bw = locals->meta_row_bw;
8740         CalculateVMRowAndSwath_params->dpte_row_bw = locals->dpte_row_bw;
8741         CalculateVMRowAndSwath_params->PixelPTEBytesPerRow = locals->PixelPTEBytesPerRow;
8742         CalculateVMRowAndSwath_params->PDEAndMetaPTEBytesFrame = locals->PDEAndMetaPTEBytesFrame;
8743         CalculateVMRowAndSwath_params->MetaRowByte = locals->MetaRowByte;
8744         CalculateVMRowAndSwath_params->use_one_row_for_frame = locals->use_one_row_for_frame;
8745         CalculateVMRowAndSwath_params->use_one_row_for_frame_flip = locals->use_one_row_for_frame_flip;
8746         CalculateVMRowAndSwath_params->UsesMALLForStaticScreen = locals->UsesMALLForStaticScreen;
8747         CalculateVMRowAndSwath_params->PTE_BUFFER_MODE = locals->PTE_BUFFER_MODE;
8748         CalculateVMRowAndSwath_params->BIGK_FRAGMENT_SIZE = locals->BIGK_FRAGMENT_SIZE;
8749
8750         CalculateVMRowAndSwath(&mode_lib->scratch,
8751         CalculateVMRowAndSwath_params);
8752
8753         s->ReorderBytes = (dml_uint_t)(mode_lib->ms.soc.num_chans * dml_max3(
8754                         mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_only_bytes,
8755                         mode_lib->ms.soc.urgent_out_of_order_return_per_channel_pixel_and_vm_bytes,
8756                         mode_lib->ms.soc.urgent_out_of_order_return_per_channel_vm_only_bytes));
8757
8758         s->VMDataOnlyReturnBW = dml_get_return_bw_mbps_vm_only(&mode_lib->ms.soc,
8759                                                                                                                                         mode_lib->ms.state.use_ideal_dram_bw_strobe,
8760                                                                                                                                         mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8761                                                                                                                                         locals->Dcfclk,
8762                                                                                                                                         mode_lib->ms.FabricClock,
8763                                                                                                                                         mode_lib->ms.DRAMSpeed);
8764
8765 #ifdef __DML_VBA_DEBUG__
8766         dml_print("DML::%s: locals->Dcfclk = %f\n", __func__, locals->Dcfclk);
8767         dml_print("DML::%s: mode_lib->ms.soc.return_bus_width_bytes = %u\n", __func__, mode_lib->ms.soc.return_bus_width_bytes);
8768         dml_print("DML::%s: mode_lib->ms.FabricClock = %f\n", __func__, mode_lib->ms.FabricClock);
8769         dml_print("DML::%s: mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes = %u\n", __func__, mode_lib->ms.soc.fabric_datapath_to_dcn_data_return_bytes);
8770         dml_print("DML::%s: mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent = %f\n", __func__, mode_lib->ms.soc.pct_ideal_sdp_bw_after_urgent);
8771         dml_print("DML::%s: mode_lib->ms.DRAMSpeed = %f\n", __func__, mode_lib->ms.DRAMSpeed);
8772         dml_print("DML::%s: mode_lib->ms.soc.num_chans = %u\n", __func__, mode_lib->ms.soc.num_chans);
8773         dml_print("DML::%s: mode_lib->ms.soc.dram_channel_width_bytes = %u\n", __func__, mode_lib->ms.soc.dram_channel_width_bytes);
8774         dml_print("DML::%s: mode_lib->ms.state_idx = %u\n", __func__, mode_lib->ms.state_idx);
8775         dml_print("DML::%s: mode_lib->ms.max_state_idx = %u\n", __func__, mode_lib->ms.max_state_idx);
8776         dml_print("DML::%s: mode_lib->ms.state.use_ideal_dram_bw_strobe = %u\n", __func__, mode_lib->ms.state.use_ideal_dram_bw_strobe);
8777         dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, s->VMDataOnlyReturnBW);
8778         dml_print("DML::%s: ReturnBW = %f\n",  __func__, mode_lib->ms.ReturnBW);
8779 #endif
8780
8781         s->HostVMInefficiencyFactor = 1.0;
8782         if (mode_lib->ms.cache_display_cfg.plane.GPUVMEnable && mode_lib->ms.cache_display_cfg.plane.HostVMEnable)
8783                 s->HostVMInefficiencyFactor = mode_lib->ms.ReturnBW / s->VMDataOnlyReturnBW;
8784
8785         s->TotalDCCActiveDPP = 0;
8786         s->TotalActiveDPP = 0;
8787         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8788                 s->TotalActiveDPP = s->TotalActiveDPP + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8789                 if (mode_lib->ms.cache_display_cfg.surface.DCCEnable[k])
8790                         s->TotalDCCActiveDPP = s->TotalDCCActiveDPP + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8791         }
8792
8793         locals->UrgentExtraLatency = CalculateExtraLatency(
8794                         mode_lib->ms.soc.round_trip_ping_latency_dcfclk_cycles,
8795                         s->ReorderBytes,
8796                         locals->Dcfclk,
8797                         s->TotalActiveDPP,
8798                         mode_lib->ms.ip.pixel_chunk_size_kbytes,
8799                         s->TotalDCCActiveDPP,
8800                         mode_lib->ms.ip.meta_chunk_size_kbytes,
8801                         mode_lib->ms.ReturnBW,
8802                         mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
8803                         mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
8804                         mode_lib->ms.num_active_planes,
8805                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
8806                         locals->dpte_group_bytes,
8807                         s->HostVMInefficiencyFactor,
8808                         mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024,
8809                         mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels);
8810
8811         locals->TCalc = 24.0 / locals->DCFCLKDeepSleep;
8812
8813         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8814                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == k) {
8815                         if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
8816                                 locals->WritebackDelay[k] =
8817                                                 mode_lib->ms.state.writeback_latency_us
8818                                                                 + CalculateWriteBackDelay(
8819                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k],
8820                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[k],
8821                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[k],
8822                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[k],
8823                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k],
8824                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k],
8825                                                                                 mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k],
8826                                                                                 mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / locals->Dispclk;
8827                         } else
8828                                 locals->WritebackDelay[k] = 0;
8829                         for (j = 0; j < mode_lib->ms.num_active_planes; ++j) {
8830                                 if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[j] == k
8831                                                 && mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[j] == true) {
8832                                         locals->WritebackDelay[k] =
8833                                                         dml_max(
8834                                                                         locals->WritebackDelay[k],
8835                                                                         mode_lib->ms.state.writeback_latency_us
8836                                                                                         + CalculateWriteBackDelay(
8837                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[j],
8838                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackHRatio[j],
8839                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVRatio[j],
8840                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackVTaps[j],
8841                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[j],
8842                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[j],
8843                                                                                                         mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[j],
8844                                                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k]) / locals->Dispclk);
8845                                 }
8846                         }
8847                 }
8848         }
8849
8850         for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8851                 for (j = 0; j < mode_lib->ms.num_active_planes; ++j)
8852                         if (mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming[k] == j)
8853                                 locals->WritebackDelay[k] = locals->WritebackDelay[j];
8854
8855         locals->UrgentLatency = CalculateUrgentLatency(mode_lib->ms.state.urgent_latency_pixel_data_only_us,
8856                                                                                                 mode_lib->ms.state.urgent_latency_pixel_mixed_with_vm_data_us,
8857                                                                                                 mode_lib->ms.state.urgent_latency_vm_data_only_us,
8858                                                                                                 mode_lib->ms.soc.do_urgent_latency_adjustment,
8859                                                                                                 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_component_us,
8860                                                                                                 mode_lib->ms.state.urgent_latency_adjustment_fabric_clock_reference_mhz,
8861                                                                                                 mode_lib->ms.FabricClock);
8862
8863         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8864                 CalculateUrgentBurstFactor(mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
8865                                                                         locals->swath_width_luma_ub[k],
8866                                                                         locals->swath_width_chroma_ub[k],
8867                                                                         locals->SwathHeightY[k],
8868                                                                         locals->SwathHeightC[k],
8869                                                                         mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
8870                                                                         locals->UrgentLatency,
8871                                                                         mode_lib->ms.ip.cursor_buffer_size,
8872                                                                         mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
8873                                                                         mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
8874                                                                         mode_lib->ms.cache_display_cfg.plane.VRatio[k],
8875                                                                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
8876                                                                         locals->BytePerPixelDETY[k],
8877                                                                         locals->BytePerPixelDETC[k],
8878                                                                         locals->DETBufferSizeY[k],
8879                                                                         locals->DETBufferSizeC[k],
8880
8881                                                                         /* output */
8882                                                                         &locals->UrgBurstFactorCursor[k],
8883                                                                         &locals->UrgBurstFactorLuma[k],
8884                                                                         &locals->UrgBurstFactorChroma[k],
8885                                                                         &locals->NoUrgentLatencyHiding[k]);
8886
8887                 locals->cursor_bw[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 /
8888                                                                 ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * mode_lib->ms.cache_display_cfg.plane.VRatio[k];
8889         }
8890
8891         s->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
8892         s->MaxVStartupAllPlanes = 0;
8893
8894         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8895                 s->MaxVStartupLines[k] = CalculateMaxVStartup(k,
8896                                                                                                         mode_lib->ms.ip.ptoi_supported,
8897                                                                                                         mode_lib->ms.ip.vblank_nom_default_us,
8898                                                                                                         &mode_lib->ms.cache_display_cfg.timing,
8899                                                                                                         locals->WritebackDelay[k]);
8900
8901 #ifdef __DML_VBA_DEBUG__
8902                 dml_print("DML::%s: k=%u MaxVStartupLines   = %u\n", __func__, k, s->MaxVStartupLines[k]);
8903                 dml_print("DML::%s: k=%u WritebackDelay     = %f\n", __func__, k, locals->WritebackDelay[k]);
8904 #endif
8905         }
8906
8907         for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
8908                 s->MaxVStartupAllPlanes = (dml_uint_t)(dml_max(s->MaxVStartupAllPlanes, s->MaxVStartupLines[k]));
8909
8910         s->ImmediateFlipRequirementFinal = false;
8911         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8912                 s->ImmediateFlipRequirementFinal = s->ImmediateFlipRequirementFinal || (mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
8913         }
8914 #ifdef __DML_VBA_DEBUG__
8915         dml_print("DML::%s: ImmediateFlipRequirementFinal = %u\n", __func__, s->ImmediateFlipRequirementFinal);
8916 #endif
8917
8918         // The prefetch scheduling should only be calculated once as per AllowForPStateChangeOrStutterInVBlank requirement
8919         // If the AllowForPStateChangeOrStutterInVBlank requirement is not strict (i.e. only try those power saving feature
8920         // if possible, then will try to program for the best power saving features in order of diffculty (dram, fclk, stutter)
8921         s->iteration = 0;
8922         s->MaxTotalRDBandwidth = 0;
8923         s->AllPrefetchModeTested = false;
8924         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
8925                 CalculatePrefetchMode(mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k], &s->MinPrefetchMode[k], &s->MaxPrefetchMode[k]);
8926                 s->NextPrefetchMode[k] = s->MinPrefetchMode[k];
8927         }
8928
8929         do {
8930                 s->MaxTotalRDBandwidthNoUrgentBurst = 0.0;
8931                 s->DestinationLineTimesForPrefetchLessThan2 = false;
8932                 s->VRatioPrefetchMoreThanMax = false;
8933
8934                 dml_print("DML::%s: Start one iteration: VStartupLines = %u\n", __func__, s->VStartupLines);
8935
8936                 s->AllPrefetchModeTested = true;
8937                 s->MaxTotalRDBandwidth = 0;
8938                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
8939                         locals->PrefetchMode[k] = s->NextPrefetchMode[k];
8940                         TWait = CalculateTWait(
8941                                         locals->PrefetchMode[k],
8942                                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
8943                                         mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
8944                                         mode_lib->ms.cache_display_cfg.timing.DRRDisplay[k],
8945                                         mode_lib->ms.state.dram_clock_change_latency_us,
8946                                         mode_lib->ms.state.fclk_change_latency_us,
8947                                         locals->UrgentLatency,
8948                                         mode_lib->ms.state.sr_enter_plus_exit_time_us);
8949
8950                         myPipe = &s->myPipe;
8951                         myPipe->Dppclk = locals->Dppclk[k];
8952                         myPipe->Dispclk = locals->Dispclk;
8953                         myPipe->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
8954                         myPipe->DCFClkDeepSleep = locals->DCFCLKDeepSleep;
8955                         myPipe->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k];
8956                         myPipe->ScalerEnabled = mode_lib->ms.cache_display_cfg.plane.ScalerEnabled[k];
8957                         myPipe->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan[k];
8958                         myPipe->BlockWidth256BytesY = locals->BlockWidth256BytesY[k];
8959                         myPipe->BlockHeight256BytesY = locals->BlockHeight256BytesY[k];
8960                         myPipe->BlockWidth256BytesC = locals->BlockWidth256BytesC[k];
8961                         myPipe->BlockHeight256BytesC = locals->BlockHeight256BytesC[k];
8962                         myPipe->InterlaceEnable = mode_lib->ms.cache_display_cfg.timing.Interlace[k];
8963                         myPipe->NumberOfCursors = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k];
8964                         myPipe->VBlank = mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k];
8965                         myPipe->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal[k];
8966                         myPipe->HActive = mode_lib->ms.cache_display_cfg.timing.HActive[k];
8967                         myPipe->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable[k];
8968                         myPipe->ODMMode = mode_lib->ms.cache_display_cfg.hw.ODMMode[k];
8969                         myPipe->SourcePixelFormat = mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k];
8970                         myPipe->BytePerPixelY = locals->BytePerPixelY[k];
8971                         myPipe->BytePerPixelC = locals->BytePerPixelC[k];
8972                         myPipe->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
8973
8974 #ifdef __DML_VBA_DEBUG__
8975                         dml_print("DML::%s: Calling CalculatePrefetchSchedule for k=%u\n", __func__, k);
8976                         dml_print("DML::%s: AllowForPStateChangeOrStutterInVBlank = %u\n", __func__, mode_lib->ms.policy.AllowForPStateChangeOrStutterInVBlank[k]);
8977                         dml_print("DML::%s: PrefetchMode[k] = %u (Min=%u Max=%u)\n", __func__, locals->PrefetchMode[k], s->MinPrefetchMode[k], s->MaxPrefetchMode[k]);
8978 #endif
8979
8980                         CalculatePrefetchSchedule_params->EnhancedPrefetchScheduleAccelerationFinal = mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal;
8981                         CalculatePrefetchSchedule_params->HostVMInefficiencyFactor = s->HostVMInefficiencyFactor;
8982                         CalculatePrefetchSchedule_params->myPipe = myPipe;
8983                         CalculatePrefetchSchedule_params->DSCDelay = locals->DSCDelay[k];
8984                         CalculatePrefetchSchedule_params->DPPCLKDelaySubtotalPlusCNVCFormater = mode_lib->ms.ip.dppclk_delay_subtotal + mode_lib->ms.ip.dppclk_delay_cnvc_formatter;
8985                         CalculatePrefetchSchedule_params->DPPCLKDelaySCL = mode_lib->ms.ip.dppclk_delay_scl;
8986                         CalculatePrefetchSchedule_params->DPPCLKDelaySCLLBOnly = mode_lib->ms.ip.dppclk_delay_scl_lb_only;
8987                         CalculatePrefetchSchedule_params->DPPCLKDelayCNVCCursor = mode_lib->ms.ip.dppclk_delay_cnvc_cursor;
8988                         CalculatePrefetchSchedule_params->DISPCLKDelaySubtotal = mode_lib->ms.ip.dispclk_delay_subtotal;
8989                         CalculatePrefetchSchedule_params->DPP_RECOUT_WIDTH = (dml_uint_t)(locals->SwathWidthY[k] / mode_lib->ms.cache_display_cfg.plane.HRatio[k]);
8990                         CalculatePrefetchSchedule_params->OutputFormat = mode_lib->ms.cache_display_cfg.output.OutputFormat[k];
8991                         CalculatePrefetchSchedule_params->MaxInterDCNTileRepeaters = mode_lib->ms.ip.max_inter_dcn_tile_repeaters;
8992                         CalculatePrefetchSchedule_params->VStartup = (dml_uint_t)(dml_min(s->VStartupLines, s->MaxVStartupLines[k]));
8993                         CalculatePrefetchSchedule_params->MaxVStartup = s->MaxVStartupLines[k];
8994                         CalculatePrefetchSchedule_params->GPUVMPageTableLevels = mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels;
8995                         CalculatePrefetchSchedule_params->GPUVMEnable = mode_lib->ms.cache_display_cfg.plane.GPUVMEnable;
8996                         CalculatePrefetchSchedule_params->HostVMEnable = mode_lib->ms.cache_display_cfg.plane.HostVMEnable;
8997                         CalculatePrefetchSchedule_params->HostVMMaxNonCachedPageTableLevels = mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels;
8998                         CalculatePrefetchSchedule_params->HostVMMinPageSize = mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024;
8999                         CalculatePrefetchSchedule_params->DynamicMetadataEnable = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k];
9000                         CalculatePrefetchSchedule_params->DynamicMetadataVMEnabled = mode_lib->ms.ip.dynamic_metadata_vm_enabled;
9001                         CalculatePrefetchSchedule_params->DynamicMetadataLinesBeforeActiveRequired = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataLinesBeforeActiveRequired[k];
9002                         CalculatePrefetchSchedule_params->DynamicMetadataTransmittedBytes = mode_lib->ms.cache_display_cfg.plane.DynamicMetadataTransmittedBytes[k];
9003                         CalculatePrefetchSchedule_params->UrgentLatency = locals->UrgentLatency;
9004                         CalculatePrefetchSchedule_params->UrgentExtraLatency = locals->UrgentExtraLatency;
9005                         CalculatePrefetchSchedule_params->TCalc = locals->TCalc;
9006                         CalculatePrefetchSchedule_params->PDEAndMetaPTEBytesFrame = locals->PDEAndMetaPTEBytesFrame[k];
9007                         CalculatePrefetchSchedule_params->MetaRowByte = locals->MetaRowByte[k];
9008                         CalculatePrefetchSchedule_params->PixelPTEBytesPerRow = locals->PixelPTEBytesPerRow[k];
9009                         CalculatePrefetchSchedule_params->PrefetchSourceLinesY = locals->PrefetchSourceLinesY[k];
9010                         CalculatePrefetchSchedule_params->VInitPreFillY = locals->VInitPreFillY[k];
9011                         CalculatePrefetchSchedule_params->MaxNumSwathY = locals->MaxNumSwathY[k];
9012                         CalculatePrefetchSchedule_params->PrefetchSourceLinesC = locals->PrefetchSourceLinesC[k];
9013                         CalculatePrefetchSchedule_params->VInitPreFillC = locals->VInitPreFillC[k];
9014                         CalculatePrefetchSchedule_params->MaxNumSwathC = locals->MaxNumSwathC[k];
9015                         CalculatePrefetchSchedule_params->swath_width_luma_ub = locals->swath_width_luma_ub[k];
9016                         CalculatePrefetchSchedule_params->swath_width_chroma_ub = locals->swath_width_chroma_ub[k];
9017                         CalculatePrefetchSchedule_params->SwathHeightY = locals->SwathHeightY[k];
9018                         CalculatePrefetchSchedule_params->SwathHeightC = locals->SwathHeightC[k];
9019                         CalculatePrefetchSchedule_params->TWait = TWait;
9020                         CalculatePrefetchSchedule_params->DSTXAfterScaler = &locals->DSTXAfterScaler[k];
9021                         CalculatePrefetchSchedule_params->DSTYAfterScaler = &locals->DSTYAfterScaler[k];
9022                         CalculatePrefetchSchedule_params->DestinationLinesForPrefetch = &locals->DestinationLinesForPrefetch[k];
9023                         CalculatePrefetchSchedule_params->DestinationLinesToRequestVMInVBlank = &locals->DestinationLinesToRequestVMInVBlank[k];
9024                         CalculatePrefetchSchedule_params->DestinationLinesToRequestRowInVBlank = &locals->DestinationLinesToRequestRowInVBlank[k];
9025                         CalculatePrefetchSchedule_params->VRatioPrefetchY = &locals->VRatioPrefetchY[k];
9026                         CalculatePrefetchSchedule_params->VRatioPrefetchC = &locals->VRatioPrefetchC[k];
9027                         CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWLuma = &locals->RequiredPrefetchPixDataBWLuma[k];
9028                         CalculatePrefetchSchedule_params->RequiredPrefetchPixDataBWChroma = &locals->RequiredPrefetchPixDataBWChroma[k];
9029                         CalculatePrefetchSchedule_params->NotEnoughTimeForDynamicMetadata = &locals->NotEnoughTimeForDynamicMetadata[k];
9030                         CalculatePrefetchSchedule_params->Tno_bw = &locals->Tno_bw[k];
9031                         CalculatePrefetchSchedule_params->prefetch_vmrow_bw = &locals->prefetch_vmrow_bw[k];
9032                         CalculatePrefetchSchedule_params->Tdmdl_vm = &locals->Tdmdl_vm[k];
9033                         CalculatePrefetchSchedule_params->Tdmdl = &locals->Tdmdl[k];
9034                         CalculatePrefetchSchedule_params->TSetup = &locals->TSetup[k];
9035                         CalculatePrefetchSchedule_params->VUpdateOffsetPix = &locals->VUpdateOffsetPix[k];
9036                         CalculatePrefetchSchedule_params->VUpdateWidthPix = &locals->VUpdateWidthPix[k];
9037                         CalculatePrefetchSchedule_params->VReadyOffsetPix = &locals->VReadyOffsetPix[k];
9038
9039                         locals->NoTimeToPrefetch[k] =
9040                                 CalculatePrefetchSchedule(&mode_lib->scratch,
9041                                         CalculatePrefetchSchedule_params);
9042
9043 #ifdef __DML_VBA_DEBUG__
9044                         dml_print("DML::%s: k=%0u NoTimeToPrefetch=%0d\n", __func__, k, locals->NoTimeToPrefetch[k]);
9045 #endif
9046                         locals->VStartup[k] = (dml_uint_t)(dml_min(s->VStartupLines, s->MaxVStartupLines[k]));
9047                         locals->VStartupMin[k] = locals->VStartup[k];
9048                 }
9049
9050                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9051                         CalculateUrgentBurstFactor(
9052                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k],
9053                                 locals->swath_width_luma_ub[k],
9054                                 locals->swath_width_chroma_ub[k],
9055                                 locals->SwathHeightY[k],
9056                                 locals->SwathHeightC[k],
9057                                 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
9058                                 locals->UrgentLatency,
9059                                 mode_lib->ms.ip.cursor_buffer_size,
9060                                 mode_lib->ms.cache_display_cfg.plane.CursorWidth[k],
9061                                 mode_lib->ms.cache_display_cfg.plane.CursorBPP[k],
9062                                 locals->VRatioPrefetchY[k],
9063                                 locals->VRatioPrefetchC[k],
9064                                 locals->BytePerPixelDETY[k],
9065                                 locals->BytePerPixelDETC[k],
9066                                 locals->DETBufferSizeY[k],
9067                                 locals->DETBufferSizeC[k],
9068                                 /* Output */
9069                                 &locals->UrgBurstFactorCursorPre[k],
9070                                 &locals->UrgBurstFactorLumaPre[k],
9071                                 &locals->UrgBurstFactorChromaPre[k],
9072                                 &locals->NoUrgentLatencyHidingPre[k]);
9073
9074                         locals->cursor_bw_pre[k] = mode_lib->ms.cache_display_cfg.plane.NumberOfCursors[k] * mode_lib->ms.cache_display_cfg.plane.CursorWidth[k] * mode_lib->ms.cache_display_cfg.plane.CursorBPP[k] / 8.0 / (mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * locals->VRatioPrefetchY[k];
9075
9076 #ifdef __DML_VBA_DEBUG__
9077                         dml_print("DML::%s: k=%0u DPPPerSurface=%u\n", __func__, k, mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k]);
9078                         dml_print("DML::%s: k=%0u UrgBurstFactorLuma=%f\n", __func__, k, locals->UrgBurstFactorLuma[k]);
9079                         dml_print("DML::%s: k=%0u UrgBurstFactorChroma=%f\n", __func__, k, locals->UrgBurstFactorChroma[k]);
9080                         dml_print("DML::%s: k=%0u UrgBurstFactorLumaPre=%f\n", __func__, k, locals->UrgBurstFactorLumaPre[k]);
9081                         dml_print("DML::%s: k=%0u UrgBurstFactorChromaPre=%f\n", __func__, k, locals->UrgBurstFactorChromaPre[k]);
9082
9083                         dml_print("DML::%s: k=%0u VRatioPrefetchY=%f\n", __func__, k, locals->VRatioPrefetchY[k]);
9084                         dml_print("DML::%s: k=%0u VRatioY=%f\n", __func__, k, mode_lib->ms.cache_display_cfg.plane.VRatio[k]);
9085
9086                         dml_print("DML::%s: k=%0u prefetch_vmrow_bw=%f\n", __func__, k, locals->prefetch_vmrow_bw[k]);
9087                         dml_print("DML::%s: k=%0u ReadBandwidthSurfaceLuma=%f\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
9088                         dml_print("DML::%s: k=%0u ReadBandwidthSurfaceChroma=%f\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
9089                         dml_print("DML::%s: k=%0u cursor_bw=%f\n", __func__, k, locals->cursor_bw[k]);
9090                         dml_print("DML::%s: k=%0u meta_row_bw=%f\n", __func__, k, locals->meta_row_bw[k]);
9091                         dml_print("DML::%s: k=%0u dpte_row_bw=%f\n", __func__, k, locals->dpte_row_bw[k]);
9092                         dml_print("DML::%s: k=%0u RequiredPrefetchPixDataBWLuma=%f\n", __func__, k, locals->RequiredPrefetchPixDataBWLuma[k]);
9093                         dml_print("DML::%s: k=%0u RequiredPrefetchPixDataBWChroma=%f\n", __func__, k, locals->RequiredPrefetchPixDataBWChroma[k]);
9094                         dml_print("DML::%s: k=%0u cursor_bw_pre=%f\n", __func__, k, locals->cursor_bw_pre[k]);
9095                         dml_print("DML::%s: k=%0u MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k, s->MaxTotalRDBandwidthNoUrgentBurst);
9096 #endif
9097                         if (locals->DestinationLinesForPrefetch[k] < 2)
9098                                 s->DestinationLineTimesForPrefetchLessThan2 = true;
9099
9100                         if (locals->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
9101                                 locals->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE_ENHANCE_PREFETCH_ACC__ ||
9102                                 ((s->VStartupLines < s->MaxVStartupLines[k] || mode_lib->ms.policy.EnhancedPrefetchScheduleAccelerationFinal == 0) &&
9103                                         (locals->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE__ || locals->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE__)))
9104                                 s->VRatioPrefetchMoreThanMax = true;
9105
9106                         //dml_bool_t DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
9107                         //dml_bool_t DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
9108                         //if (locals->DestinationLinesToRequestVMInVBlank[k] >= 32) {
9109                         //    DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
9110                         //}
9111
9112                         //if (locals->DestinationLinesToRequestRowInVBlank[k] >= 16) {
9113                         //    DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
9114                         //}
9115                 }
9116
9117                 locals->FractionOfUrgentBandwidth = s->MaxTotalRDBandwidthNoUrgentBurst / mode_lib->ms.ReturnBW;
9118
9119 #ifdef __DML_VBA_DEBUG__
9120                 dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f \n", __func__, s->MaxTotalRDBandwidthNoUrgentBurst);
9121                 dml_print("DML::%s: ReturnBW=%f \n", __func__, mode_lib->ms.ReturnBW);
9122                 dml_print("DML::%s: FractionOfUrgentBandwidth=%f \n", __func__, locals->FractionOfUrgentBandwidth);
9123 #endif
9124
9125                 CalculatePrefetchBandwithSupport(
9126                         mode_lib->ms.num_active_planes,
9127                         mode_lib->ms.ReturnBW,
9128                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9129                         locals->NoUrgentLatencyHidingPre,
9130                         locals->ReadBandwidthSurfaceLuma,
9131                         locals->ReadBandwidthSurfaceChroma,
9132                         locals->RequiredPrefetchPixDataBWLuma,
9133                         locals->RequiredPrefetchPixDataBWChroma,
9134                         locals->cursor_bw,
9135                         locals->meta_row_bw,
9136                         locals->dpte_row_bw,
9137                         locals->cursor_bw_pre,
9138                         locals->prefetch_vmrow_bw,
9139                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9140                         locals->UrgBurstFactorLuma,
9141                         locals->UrgBurstFactorChroma,
9142                         locals->UrgBurstFactorCursor,
9143                         locals->UrgBurstFactorLumaPre,
9144                         locals->UrgBurstFactorChromaPre,
9145                         locals->UrgBurstFactorCursorPre,
9146
9147                         /* output */
9148                         &s->MaxTotalRDBandwidth, // dml_float_t *PrefetchBandwidth
9149                         &s->MaxTotalRDBandwidthNotIncludingMALLPrefetch, // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
9150                         &s->dummy_single[0], // dml_float_t *FractionOfUrgentBandwidth
9151                         &locals->PrefetchModeSupported);
9152
9153                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
9154                         s->dummy_unit_vector[k] = 1.0;
9155
9156                 CalculatePrefetchBandwithSupport(mode_lib->ms.num_active_planes,
9157                         mode_lib->ms.ReturnBW,
9158                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9159                         locals->NoUrgentLatencyHidingPre,
9160                         locals->ReadBandwidthSurfaceLuma,
9161                         locals->ReadBandwidthSurfaceChroma,
9162                         locals->RequiredPrefetchPixDataBWLuma,
9163                         locals->RequiredPrefetchPixDataBWChroma,
9164                         locals->cursor_bw,
9165                         locals->meta_row_bw,
9166                         locals->dpte_row_bw,
9167                         locals->cursor_bw_pre,
9168                         locals->prefetch_vmrow_bw,
9169                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9170                         s->dummy_unit_vector,
9171                         s->dummy_unit_vector,
9172                         s->dummy_unit_vector,
9173                         s->dummy_unit_vector,
9174                         s->dummy_unit_vector,
9175                         s->dummy_unit_vector,
9176
9177                         /* output */
9178                         &s->NonUrgentMaxTotalRDBandwidth, // dml_float_t *PrefetchBandwidth
9179                         &s->NonUrgentMaxTotalRDBandwidthNotIncludingMALLPrefetch, // dml_float_t *PrefetchBandwidthNotIncludingMALLPrefetch
9180                         &locals->FractionOfUrgentBandwidth,
9181                         &s->dummy_boolean[0]); // dml_bool_t *PrefetchBandwidthSupport
9182
9183                 if (s->VRatioPrefetchMoreThanMax != false || s->DestinationLineTimesForPrefetchLessThan2 != false) {
9184                         dml_print("DML::%s: VRatioPrefetchMoreThanMax                   = %u\n", __func__, s->VRatioPrefetchMoreThanMax);
9185                         dml_print("DML::%s: DestinationLineTimesForPrefetchLessThan2    = %u\n", __func__, s->DestinationLineTimesForPrefetchLessThan2);
9186                         locals->PrefetchModeSupported = false;
9187                 }
9188
9189                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9190                         if (locals->NoTimeToPrefetch[k] == true || locals->NotEnoughTimeForDynamicMetadata[k]) {
9191                                 dml_print("DML::%s: k=%u, NoTimeToPrefetch = %0d\n", __func__, k, locals->NoTimeToPrefetch[k]);
9192                                 dml_print("DML::%s: k=%u, NotEnoughTimeForDynamicMetadata=%u\n", __func__, k, locals->NotEnoughTimeForDynamicMetadata[k]);
9193                                 locals->PrefetchModeSupported = false;
9194                         }
9195                 }
9196
9197                 if (locals->PrefetchModeSupported == true && mode_lib->ms.support.ImmediateFlipSupport == true) {
9198                         locals->BandwidthAvailableForImmediateFlip = CalculateBandwidthAvailableForImmediateFlip(
9199                                                                                                                                         mode_lib->ms.num_active_planes,
9200                                                                                                                                         mode_lib->ms.ReturnBW,
9201                                                                                                                                         locals->ReadBandwidthSurfaceLuma,
9202                                                                                                                                         locals->ReadBandwidthSurfaceChroma,
9203                                                                                                                                         locals->RequiredPrefetchPixDataBWLuma,
9204                                                                                                                                         locals->RequiredPrefetchPixDataBWChroma,
9205                                                                                                                                         locals->cursor_bw,
9206                                                                                                                                         locals->cursor_bw_pre,
9207                                                                                                                                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9208                                                                                                                                         locals->UrgBurstFactorLuma,
9209                                                                                                                                         locals->UrgBurstFactorChroma,
9210                                                                                                                                         locals->UrgBurstFactorCursor,
9211                                                                                                                                         locals->UrgBurstFactorLumaPre,
9212                                                                                                                                         locals->UrgBurstFactorChromaPre,
9213                                                                                                                                         locals->UrgBurstFactorCursorPre);
9214
9215                         locals->TotImmediateFlipBytes = 0;
9216                         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9217                                 if (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required) {
9218                                         locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * (locals->PDEAndMetaPTEBytesFrame[k] + locals->MetaRowByte[k]);
9219                                         if (locals->use_one_row_for_frame_flip[k]) {
9220                                                 locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * (2 * locals->PixelPTEBytesPerRow[k]);
9221                                         } else {
9222                                                 locals->TotImmediateFlipBytes = locals->TotImmediateFlipBytes + mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k] * locals->PixelPTEBytesPerRow[k];
9223                                         }
9224 #ifdef __DML_VBA_DEBUG__
9225                                         dml_print("DML::%s: k = %u\n", __func__, k);
9226                                         dml_print("DML::%s: DPPPerSurface = %u\n", __func__, mode_lib->ms.cache_display_cfg.hw.DPPPerSurface[k]);
9227                                         dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %u\n", __func__, locals->PDEAndMetaPTEBytesFrame[k]);
9228                                         dml_print("DML::%s: MetaRowByte = %u\n", __func__, locals->MetaRowByte[k]);
9229                                         dml_print("DML::%s: PixelPTEBytesPerRow = %u\n", __func__, locals->PixelPTEBytesPerRow[k]);
9230                                         dml_print("DML::%s: TotImmediateFlipBytes = %u\n", __func__, locals->TotImmediateFlipBytes);
9231 #endif
9232                                 }
9233                         }
9234                         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9235                                 CalculateFlipSchedule(
9236                                                 s->HostVMInefficiencyFactor,
9237                                                 locals->UrgentExtraLatency,
9238                                                 locals->UrgentLatency,
9239                                                 mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
9240                                                 mode_lib->ms.cache_display_cfg.plane.HostVMEnable,
9241                                                 mode_lib->ms.cache_display_cfg.plane.HostVMMaxPageTableLevels,
9242                                                 mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9243                                                 mode_lib->ms.soc.hostvm_min_page_size_kbytes * 1024,
9244                                                 locals->PDEAndMetaPTEBytesFrame[k],
9245                                                 locals->MetaRowByte[k],
9246                                                 locals->PixelPTEBytesPerRow[k],
9247                                                 locals->BandwidthAvailableForImmediateFlip,
9248                                                 locals->TotImmediateFlipBytes,
9249                                                 mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
9250                                                 mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k],
9251                                                 mode_lib->ms.cache_display_cfg.plane.VRatio[k],
9252                                                 mode_lib->ms.cache_display_cfg.plane.VRatioChroma[k],
9253                                                 locals->Tno_bw[k],
9254                                                 mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
9255                                                 locals->dpte_row_height[k],
9256                                                 locals->meta_row_height[k],
9257                                                 locals->dpte_row_height_chroma[k],
9258                                                 locals->meta_row_height_chroma[k],
9259                                                 locals->use_one_row_for_frame_flip[k],
9260
9261                                                 /* Output */
9262                                                 &locals->DestinationLinesToRequestVMInImmediateFlip[k],
9263                                                 &locals->DestinationLinesToRequestRowInImmediateFlip[k],
9264                                                 &locals->final_flip_bw[k],
9265                                                 &locals->ImmediateFlipSupportedForPipe[k]);
9266                         }
9267
9268                         CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
9269                                                                                                 mode_lib->ms.ReturnBW,
9270                                                                                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9271                                                                                                 mode_lib->ms.policy.ImmediateFlipRequirement,
9272                                                                                                 locals->final_flip_bw,
9273                                                                                                 locals->ReadBandwidthSurfaceLuma,
9274                                                                                                 locals->ReadBandwidthSurfaceChroma,
9275                                                                                                 locals->RequiredPrefetchPixDataBWLuma,
9276                                                                                                 locals->RequiredPrefetchPixDataBWChroma,
9277                                                                                                 locals->cursor_bw,
9278                                                                                                 locals->meta_row_bw,
9279                                                                                                 locals->dpte_row_bw,
9280                                                                                                 locals->cursor_bw_pre,
9281                                                                                                 locals->prefetch_vmrow_bw,
9282                                                                                                 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9283                                                                                                 locals->UrgBurstFactorLuma,
9284                                                                                                 locals->UrgBurstFactorChroma,
9285                                                                                                 locals->UrgBurstFactorCursor,
9286                                                                                                 locals->UrgBurstFactorLumaPre,
9287                                                                                                 locals->UrgBurstFactorChromaPre,
9288                                                                                                 locals->UrgBurstFactorCursorPre,
9289
9290                                                                                                 /* output */
9291                                                                                                 &locals->total_dcn_read_bw_with_flip, // dml_float_t *TotalBandwidth
9292                                                                                                 &locals->total_dcn_read_bw_with_flip_not_including_MALL_prefetch, // dml_float_t TotalBandwidthNotIncludingMALLPrefetch
9293                                                                                                 &s->dummy_single[0], // dml_float_t *FractionOfUrgentBandwidth
9294                                                                                                 &locals->ImmediateFlipSupported); // dml_bool_t *ImmediateFlipBandwidthSupport
9295
9296                         CalculateImmediateFlipBandwithSupport(mode_lib->ms.num_active_planes,
9297                                 mode_lib->ms.ReturnBW,
9298                                 mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9299                                 mode_lib->ms.policy.ImmediateFlipRequirement,
9300                                 locals->final_flip_bw,
9301                                 locals->ReadBandwidthSurfaceLuma,
9302                                 locals->ReadBandwidthSurfaceChroma,
9303                                 locals->RequiredPrefetchPixDataBWLuma,
9304                                 locals->RequiredPrefetchPixDataBWChroma,
9305                                 locals->cursor_bw,
9306                                 locals->meta_row_bw,
9307                                 locals->dpte_row_bw,
9308                                 locals->cursor_bw_pre,
9309                                 locals->prefetch_vmrow_bw,
9310                                 mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9311                                 s->dummy_unit_vector,
9312                                 s->dummy_unit_vector,
9313                                 s->dummy_unit_vector,
9314                                 s->dummy_unit_vector,
9315                                 s->dummy_unit_vector,
9316                                 s->dummy_unit_vector,
9317
9318                                 /* output */
9319                                 &locals->non_urgent_total_dcn_read_bw_with_flip, // dml_float_t *TotalBandwidth
9320                                 &locals->non_urgent_total_dcn_read_bw_with_flip_not_including_MALL_prefetch, // dml_float_t TotalBandwidthNotIncludingMALLPrefetch
9321                                 &locals->FractionOfUrgentBandwidthImmediateFlip, // dml_float_t *FractionOfUrgentBandwidth
9322                                 &s->dummy_boolean[0]); // dml_bool_t *ImmediateFlipBandwidthSupport
9323
9324                         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9325                                 if (mode_lib->ms.policy.ImmediateFlipRequirement[k] != dml_immediate_flip_not_required && locals->ImmediateFlipSupportedForPipe[k] == false) {
9326                                         locals->ImmediateFlipSupported = false;
9327 #ifdef __DML_VBA_DEBUG__
9328                                         dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
9329 #endif
9330                                 }
9331                         }
9332                 } else {
9333                         locals->ImmediateFlipSupported = false;
9334                         locals->total_dcn_read_bw_with_flip = s->MaxTotalRDBandwidth;
9335                         locals->total_dcn_read_bw_with_flip_not_including_MALL_prefetch = s->MaxTotalRDBandwidthNotIncludingMALLPrefetch;
9336                         locals->non_urgent_total_dcn_read_bw_with_flip = s->NonUrgentMaxTotalRDBandwidth;
9337                         locals->non_urgent_total_dcn_read_bw_with_flip_not_including_MALL_prefetch = s->NonUrgentMaxTotalRDBandwidthNotIncludingMALLPrefetch;
9338                 }
9339
9340                 /* consider flip support is okay if the flip bw is ok or (when user does't require a iflip and there is no host vm) */
9341                 locals->PrefetchAndImmediateFlipSupported = (locals->PrefetchModeSupported == true &&
9342                                                                                                         ((!mode_lib->ms.support.ImmediateFlipSupport && !mode_lib->ms.cache_display_cfg.plane.HostVMEnable && !s->ImmediateFlipRequirementFinal) ||
9343                                                                                                         locals->ImmediateFlipSupported)) ? true : false;
9344
9345 #ifdef __DML_VBA_DEBUG__
9346                 dml_print("DML::%s: PrefetchModeSupported = %u\n", __func__, locals->PrefetchModeSupported);
9347                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k)
9348                 dml_print("DML::%s: ImmediateFlipRequirement[%u] = %u\n", __func__, k, mode_lib->ms.policy.ImmediateFlipRequirement[k] == dml_immediate_flip_required);
9349                 dml_print("DML::%s: HostVMEnable = %u\n", __func__, mode_lib->ms.cache_display_cfg.plane.HostVMEnable);
9350                 dml_print("DML::%s: ImmediateFlipSupport = %u (from mode_support)\n", __func__, mode_lib->ms.support.ImmediateFlipSupport);
9351                 dml_print("DML::%s: ImmediateFlipSupported = %u\n", __func__, locals->ImmediateFlipSupported);
9352                 dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %u\n", __func__, locals->PrefetchAndImmediateFlipSupported);
9353 #endif
9354                 dml_print("DML::%s: Done one iteration: VStartupLines=%u, MaxVStartupAllPlanes=%u\n", __func__, s->VStartupLines, s->MaxVStartupAllPlanes);
9355
9356                 s->VStartupLines = s->VStartupLines + 1;
9357
9358                 if (s->VStartupLines > s->MaxVStartupAllPlanes) {
9359                         s->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
9360
9361                         for (k = 0; k <= mode_lib->ms.num_active_planes - 1; k++) {
9362                                 s->NextPrefetchMode[k] = s->NextPrefetchMode[k] + 1;
9363
9364                                 if (s->NextPrefetchMode[k] <= s->MaxPrefetchMode[k])
9365                                         s->AllPrefetchModeTested = false;
9366                                 dml_print("DML::%s: VStartupLines=%u, reaches max vstartup, try next prefetch mode=%u\n", __func__, s->VStartupLines-1, s->AllPrefetchModeTested);
9367                         }
9368                 } else {
9369                         s->AllPrefetchModeTested = false;
9370                 }
9371                 s->iteration++;
9372                 if (s->iteration > 2500) {
9373                         dml_print("ERROR: DML::%s: Too many errors, exit now\n", __func__);
9374                         ASSERT(0);
9375                 }
9376         } while (!(locals->PrefetchAndImmediateFlipSupported || s->AllPrefetchModeTested));
9377
9378         if (locals->PrefetchAndImmediateFlipSupported) {
9379                 dml_print("DML::%s: Good, Prefetch and flip scheduling solution found at VStartupLines=%u (MaxVStartupAllPlanes=%u)\n", __func__, s->VStartupLines-1, s->MaxVStartupAllPlanes);
9380         } else {
9381                 dml_print("DML::%s: Bad, Prefetch and flip scheduling solution did NOT find solution! (MaxVStartupAllPlanes=%u)\n", __func__, s->MaxVStartupAllPlanes);
9382         }
9383
9384         //Watermarks and NB P-State/DRAM Clock Change Support
9385         {
9386                 s->mmSOCParameters.UrgentLatency = locals->UrgentLatency;
9387                 s->mmSOCParameters.ExtraLatency = locals->UrgentExtraLatency;
9388                 s->mmSOCParameters.WritebackLatency = mode_lib->ms.state.writeback_latency_us;
9389                 s->mmSOCParameters.DRAMClockChangeLatency = mode_lib->ms.state.dram_clock_change_latency_us;
9390                 s->mmSOCParameters.FCLKChangeLatency = mode_lib->ms.state.fclk_change_latency_us;
9391                 s->mmSOCParameters.SRExitTime = mode_lib->ms.state.sr_exit_time_us;
9392                 s->mmSOCParameters.SREnterPlusExitTime = mode_lib->ms.state.sr_enter_plus_exit_time_us;
9393                 s->mmSOCParameters.SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
9394                 s->mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->ms.state.sr_enter_plus_exit_z8_time_us;
9395                 s->mmSOCParameters.USRRetrainingLatency = mode_lib->ms.state.usr_retraining_latency_us;
9396                 s->mmSOCParameters.SMNLatency = mode_lib->ms.soc.smn_latency_us;
9397
9398                 CalculateWatermarks_params->USRRetrainingRequiredFinal = mode_lib->ms.policy.USRRetrainingRequiredFinal;
9399                 CalculateWatermarks_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
9400                 CalculateWatermarks_params->PrefetchMode = locals->PrefetchMode;
9401                 CalculateWatermarks_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
9402                 CalculateWatermarks_params->MaxLineBufferLines = mode_lib->ms.ip.max_line_buffer_lines;
9403                 CalculateWatermarks_params->LineBufferSize = mode_lib->ms.ip.line_buffer_size_bits;
9404                 CalculateWatermarks_params->WritebackInterfaceBufferSize = mode_lib->ms.ip.writeback_interface_buffer_size_kbytes;
9405                 CalculateWatermarks_params->DCFCLK = locals->Dcfclk;
9406                 CalculateWatermarks_params->ReturnBW = mode_lib->ms.ReturnBW;
9407                 CalculateWatermarks_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
9408                 CalculateWatermarks_params->SynchronizeDRRDisplaysForUCLKPStateChangeFinal = mode_lib->ms.policy.SynchronizeDRRDisplaysForUCLKPStateChangeFinal;
9409                 CalculateWatermarks_params->DRRDisplay = mode_lib->ms.cache_display_cfg.timing.DRRDisplay;
9410                 CalculateWatermarks_params->dpte_group_bytes = locals->dpte_group_bytes;
9411                 CalculateWatermarks_params->meta_row_height = locals->meta_row_height;
9412                 CalculateWatermarks_params->meta_row_height_chroma = locals->meta_row_height_chroma;
9413                 CalculateWatermarks_params->mmSOCParameters = s->mmSOCParameters;
9414                 CalculateWatermarks_params->WritebackChunkSize = mode_lib->ms.ip.writeback_chunk_size_kbytes;
9415                 CalculateWatermarks_params->SOCCLK = mode_lib->ms.SOCCLK;
9416                 CalculateWatermarks_params->DCFClkDeepSleep = locals->DCFCLKDeepSleep;
9417                 CalculateWatermarks_params->DETBufferSizeY = locals->DETBufferSizeY;
9418                 CalculateWatermarks_params->DETBufferSizeC = locals->DETBufferSizeC;
9419                 CalculateWatermarks_params->SwathHeightY = locals->SwathHeightY;
9420                 CalculateWatermarks_params->SwathHeightC = locals->SwathHeightC;
9421                 CalculateWatermarks_params->LBBitPerPixel = mode_lib->ms.cache_display_cfg.plane.LBBitPerPixel;
9422                 CalculateWatermarks_params->SwathWidthY = locals->SwathWidthY;
9423                 CalculateWatermarks_params->SwathWidthC = locals->SwathWidthC;
9424                 CalculateWatermarks_params->HRatio = mode_lib->ms.cache_display_cfg.plane.HRatio;
9425                 CalculateWatermarks_params->HRatioChroma = mode_lib->ms.cache_display_cfg.plane.HRatioChroma;
9426                 CalculateWatermarks_params->VTaps = mode_lib->ms.cache_display_cfg.plane.VTaps;
9427                 CalculateWatermarks_params->VTapsChroma = mode_lib->ms.cache_display_cfg.plane.VTapsChroma;
9428                 CalculateWatermarks_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
9429                 CalculateWatermarks_params->VRatioChroma = mode_lib->ms.cache_display_cfg.plane.VRatioChroma;
9430                 CalculateWatermarks_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
9431                 CalculateWatermarks_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
9432                 CalculateWatermarks_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
9433                 CalculateWatermarks_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
9434                 CalculateWatermarks_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
9435                 CalculateWatermarks_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
9436                 CalculateWatermarks_params->BytePerPixelDETY = locals->BytePerPixelDETY;
9437                 CalculateWatermarks_params->BytePerPixelDETC = locals->BytePerPixelDETC;
9438                 CalculateWatermarks_params->DSTXAfterScaler = locals->DSTXAfterScaler;
9439                 CalculateWatermarks_params->DSTYAfterScaler = locals->DSTYAfterScaler;
9440                 CalculateWatermarks_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
9441                 CalculateWatermarks_params->WritebackPixelFormat = mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat;
9442                 CalculateWatermarks_params->WritebackDestinationWidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth;
9443                 CalculateWatermarks_params->WritebackDestinationHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight;
9444                 CalculateWatermarks_params->WritebackSourceHeight = mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight;
9445                 CalculateWatermarks_params->UnboundedRequestEnabled = locals->UnboundedRequestEnabled;
9446                 CalculateWatermarks_params->CompressedBufferSizeInkByte = locals->CompressedBufferSizeInkByte;
9447
9448                 // Output
9449                 CalculateWatermarks_params->Watermark = &locals->Watermark; // Watermarks *Watermark
9450                 CalculateWatermarks_params->DRAMClockChangeSupport = &locals->DRAMClockChangeSupport;
9451                 CalculateWatermarks_params->MaxActiveDRAMClockChangeLatencySupported = locals->MaxActiveDRAMClockChangeLatencySupported; // dml_float_t *MaxActiveDRAMClockChangeLatencySupported[]
9452                 CalculateWatermarks_params->SubViewportLinesNeededInMALL = locals->SubViewportLinesNeededInMALL; // dml_uint_t SubViewportLinesNeededInMALL[]
9453                 CalculateWatermarks_params->FCLKChangeSupport = &locals->FCLKChangeSupport;
9454                 CalculateWatermarks_params->MaxActiveFCLKChangeLatencySupported = &locals->MaxActiveFCLKChangeLatencySupported; // dml_float_t *MaxActiveFCLKChangeLatencySupported
9455                 CalculateWatermarks_params->USRRetrainingSupport = &locals->USRRetrainingSupport;
9456
9457                 CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
9458                         &mode_lib->scratch,
9459                         CalculateWatermarks_params);
9460
9461                 /* Copy the calculated watermarks to mp.Watermark as the getter functions are
9462                  * implemented by the DML team to copy the calculated values from the mp.Watermark interface.
9463                  */
9464                 memcpy(&mode_lib->mp.Watermark, CalculateWatermarks_params->Watermark, sizeof(struct Watermarks));
9465
9466                 for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9467                         if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
9468                                 locals->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0, locals->VStartupMin[k] * mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
9469                                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k] - locals->Watermark.WritebackDRAMClockChangeWatermark);
9470                                 locals->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0, locals->VStartupMin[k] * mode_lib->ms.cache_display_cfg.timing.HTotal[k] /
9471                                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.PixelClock[k] - locals->Watermark.WritebackFCLKChangeWatermark);
9472                         } else {
9473                                 locals->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
9474                                 locals->WritebackAllowFCLKChangeEndPosition[k] = 0;
9475                         }
9476                 }
9477         }
9478
9479         //Display Pipeline Delivery Time in Prefetch, Groups
9480         CalculatePixelDeliveryTimes(
9481                         mode_lib->ms.num_active_planes,
9482                         mode_lib->ms.cache_display_cfg.plane.VRatio,
9483                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
9484                         locals->VRatioPrefetchY,
9485                         locals->VRatioPrefetchC,
9486                         locals->swath_width_luma_ub,
9487                         locals->swath_width_chroma_ub,
9488                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9489                         mode_lib->ms.cache_display_cfg.plane.HRatio,
9490                         mode_lib->ms.cache_display_cfg.plane.HRatioChroma,
9491                         mode_lib->ms.cache_display_cfg.timing.PixelClock,
9492                         locals->PSCL_THROUGHPUT,
9493                         locals->PSCL_THROUGHPUT_CHROMA,
9494                         locals->Dppclk,
9495                         locals->BytePerPixelC,
9496                         mode_lib->ms.cache_display_cfg.plane.SourceScan,
9497                         mode_lib->ms.cache_display_cfg.plane.NumberOfCursors,
9498                         mode_lib->ms.cache_display_cfg.plane.CursorWidth,
9499                         mode_lib->ms.cache_display_cfg.plane.CursorBPP,
9500                         locals->BlockWidth256BytesY,
9501                         locals->BlockHeight256BytesY,
9502                         locals->BlockWidth256BytesC,
9503                         locals->BlockHeight256BytesC,
9504
9505                         /* Output */
9506                         locals->DisplayPipeLineDeliveryTimeLuma,
9507                         locals->DisplayPipeLineDeliveryTimeChroma,
9508                         locals->DisplayPipeLineDeliveryTimeLumaPrefetch,
9509                         locals->DisplayPipeLineDeliveryTimeChromaPrefetch,
9510                         locals->DisplayPipeRequestDeliveryTimeLuma,
9511                         locals->DisplayPipeRequestDeliveryTimeChroma,
9512                         locals->DisplayPipeRequestDeliveryTimeLumaPrefetch,
9513                         locals->DisplayPipeRequestDeliveryTimeChromaPrefetch,
9514                         locals->CursorRequestDeliveryTime,
9515                         locals->CursorRequestDeliveryTimePrefetch);
9516
9517         CalculateMetaAndPTETimes(
9518                         locals->use_one_row_for_frame,
9519                         mode_lib->ms.num_active_planes,
9520                         mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9521                         mode_lib->ms.ip.meta_chunk_size_kbytes,
9522                         mode_lib->ms.ip.min_meta_chunk_size_bytes,
9523                         mode_lib->ms.cache_display_cfg.timing.HTotal,
9524                         mode_lib->ms.cache_display_cfg.plane.VRatio,
9525                         mode_lib->ms.cache_display_cfg.plane.VRatioChroma,
9526                         locals->DestinationLinesToRequestRowInVBlank,
9527                         locals->DestinationLinesToRequestRowInImmediateFlip,
9528                         mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9529                         mode_lib->ms.cache_display_cfg.timing.PixelClock,
9530                         locals->BytePerPixelY,
9531                         locals->BytePerPixelC,
9532                         mode_lib->ms.cache_display_cfg.plane.SourceScan,
9533                         locals->dpte_row_height,
9534                         locals->dpte_row_height_chroma,
9535                         locals->meta_row_width,
9536                         locals->meta_row_width_chroma,
9537                         locals->meta_row_height,
9538                         locals->meta_row_height_chroma,
9539                         locals->meta_req_width,
9540                         locals->meta_req_width_chroma,
9541                         locals->meta_req_height,
9542                         locals->meta_req_height_chroma,
9543                         locals->dpte_group_bytes,
9544                         locals->PTERequestSizeY,
9545                         locals->PTERequestSizeC,
9546                         locals->PixelPTEReqWidthY,
9547                         locals->PixelPTEReqHeightY,
9548                         locals->PixelPTEReqWidthC,
9549                         locals->PixelPTEReqHeightC,
9550                         locals->dpte_row_width_luma_ub,
9551                         locals->dpte_row_width_chroma_ub,
9552
9553                         /* Output */
9554                         locals->DST_Y_PER_PTE_ROW_NOM_L,
9555                         locals->DST_Y_PER_PTE_ROW_NOM_C,
9556                         locals->DST_Y_PER_META_ROW_NOM_L,
9557                         locals->DST_Y_PER_META_ROW_NOM_C,
9558                         locals->TimePerMetaChunkNominal,
9559                         locals->TimePerChromaMetaChunkNominal,
9560                         locals->TimePerMetaChunkVBlank,
9561                         locals->TimePerChromaMetaChunkVBlank,
9562                         locals->TimePerMetaChunkFlip,
9563                         locals->TimePerChromaMetaChunkFlip,
9564                         locals->time_per_pte_group_nom_luma,
9565                         locals->time_per_pte_group_vblank_luma,
9566                         locals->time_per_pte_group_flip_luma,
9567                         locals->time_per_pte_group_nom_chroma,
9568                         locals->time_per_pte_group_vblank_chroma,
9569                         locals->time_per_pte_group_flip_chroma);
9570
9571         CalculateVMGroupAndRequestTimes(
9572                         mode_lib->ms.num_active_planes,
9573                         mode_lib->ms.cache_display_cfg.plane.GPUVMEnable,
9574                         mode_lib->ms.cache_display_cfg.plane.GPUVMMaxPageTableLevels,
9575                         mode_lib->ms.cache_display_cfg.timing.HTotal,
9576                         locals->BytePerPixelC,
9577                         locals->DestinationLinesToRequestVMInVBlank,
9578                         locals->DestinationLinesToRequestVMInImmediateFlip,
9579                         mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9580                         mode_lib->ms.cache_display_cfg.timing.PixelClock,
9581                         locals->dpte_row_width_luma_ub,
9582                         locals->dpte_row_width_chroma_ub,
9583                         locals->vm_group_bytes,
9584                         locals->dpde0_bytes_per_frame_ub_l,
9585                         locals->dpde0_bytes_per_frame_ub_c,
9586                         locals->meta_pte_bytes_per_frame_ub_l,
9587                         locals->meta_pte_bytes_per_frame_ub_c,
9588
9589                         /* Output */
9590                         locals->TimePerVMGroupVBlank,
9591                         locals->TimePerVMGroupFlip,
9592                         locals->TimePerVMRequestVBlank,
9593                         locals->TimePerVMRequestFlip);
9594
9595         // Min TTUVBlank
9596         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9597                 if (locals->PrefetchMode[k] == 0) {
9598                         locals->MinTTUVBlank[k] = dml_max4(
9599                                         locals->Watermark.DRAMClockChangeWatermark,
9600                                         locals->Watermark.FCLKChangeWatermark,
9601                                         locals->Watermark.StutterEnterPlusExitWatermark,
9602                                         locals->Watermark.UrgentWatermark);
9603                 } else if (locals->PrefetchMode[k] == 1) {
9604                         locals->MinTTUVBlank[k] = dml_max3(
9605                                         locals->Watermark.FCLKChangeWatermark,
9606                                         locals->Watermark.StutterEnterPlusExitWatermark,
9607                                         locals->Watermark.UrgentWatermark);
9608                 } else if (locals->PrefetchMode[k] == 2) {
9609                         locals->MinTTUVBlank[k] = dml_max(
9610                                         locals->Watermark.StutterEnterPlusExitWatermark,
9611                                         locals->Watermark.UrgentWatermark);
9612                 } else {
9613                         locals->MinTTUVBlank[k] = locals->Watermark.UrgentWatermark;
9614                 }
9615                 if (!mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k])
9616                         locals->MinTTUVBlank[k] = locals->TCalc + locals->MinTTUVBlank[k];
9617         }
9618
9619         // DCC Configuration
9620         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9621 #ifdef __DML_VBA_DEBUG__
9622                 dml_print("DML::%s: Calculate DCC configuration for surface k=%u\n", __func__, k);
9623 #endif
9624                 CalculateDCCConfiguration(
9625                         mode_lib->ms.cache_display_cfg.surface.DCCEnable[k],
9626                         mode_lib->ms.policy.DCCProgrammingAssumesScanDirectionUnknownFinal,
9627                         mode_lib->ms.cache_display_cfg.surface.SourcePixelFormat[k],
9628                         mode_lib->ms.cache_display_cfg.surface.SurfaceWidthY[k],
9629                         mode_lib->ms.cache_display_cfg.surface.SurfaceWidthC[k],
9630                         mode_lib->ms.cache_display_cfg.surface.SurfaceHeightY[k],
9631                         mode_lib->ms.cache_display_cfg.surface.SurfaceHeightC[k],
9632                         mode_lib->ms.NomDETInKByte,
9633                         locals->BlockHeight256BytesY[k],
9634                         locals->BlockHeight256BytesC[k],
9635                         mode_lib->ms.cache_display_cfg.surface.SurfaceTiling[k],
9636                         locals->BytePerPixelY[k],
9637                         locals->BytePerPixelC[k],
9638                         locals->BytePerPixelDETY[k],
9639                         locals->BytePerPixelDETC[k],
9640                         mode_lib->ms.cache_display_cfg.plane.SourceScan[k],
9641                         /* Output */
9642                         &locals->DCCYMaxUncompressedBlock[k],
9643                         &locals->DCCCMaxUncompressedBlock[k],
9644                         &locals->DCCYMaxCompressedBlock[k],
9645                         &locals->DCCCMaxCompressedBlock[k],
9646                         &locals->DCCYIndependentBlock[k],
9647                         &locals->DCCCIndependentBlock[k]);
9648         }
9649
9650         // VStartup Adjustment
9651         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9652                 s->Tvstartup_margin = (s->MaxVStartupLines[k] - locals->VStartupMin[k]) * mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k];
9653 #ifdef __DML_VBA_DEBUG__
9654                 dml_print("DML::%s: k=%u, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k, locals->MinTTUVBlank[k]);
9655 #endif
9656
9657                 locals->MinTTUVBlank[k] = locals->MinTTUVBlank[k] + s->Tvstartup_margin;
9658
9659 #ifdef __DML_VBA_DEBUG__
9660                 dml_print("DML::%s: k=%u, Tvstartup_margin = %f\n", __func__, k, s->Tvstartup_margin);
9661                 dml_print("DML::%s: k=%u, MaxVStartupLines = %u\n", __func__, k, s->MaxVStartupLines[k]);
9662                 dml_print("DML::%s: k=%u, MinTTUVBlank = %f\n", __func__, k, locals->MinTTUVBlank[k]);
9663 #endif
9664
9665                 locals->Tdmdl[k] = locals->Tdmdl[k] + s->Tvstartup_margin;
9666                 if (mode_lib->ms.cache_display_cfg.plane.DynamicMetadataEnable[k] && mode_lib->ms.ip.dynamic_metadata_vm_enabled) {
9667                         locals->Tdmdl_vm[k] = locals->Tdmdl_vm[k] + s->Tvstartup_margin;
9668                 }
9669
9670                 isInterlaceTiming        = (mode_lib->ms.cache_display_cfg.timing.Interlace[k] && !mode_lib->ms.ip.ptoi_supported);
9671
9672                 // The actual positioning of the vstartup
9673                 locals->VStartup[k] = (isInterlaceTiming ? (2 * s->MaxVStartupLines[k]) : s->MaxVStartupLines[k]);
9674
9675                 s->dlg_vblank_start        =  ((isInterlaceTiming ? dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]) / 2.0, 1.0) :
9676                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.VTotal[k]) - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]);
9677                 s->LSetup                  = dml_floor(4.0 * locals->TSetup[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0) / 4.0;
9678                 s->blank_lines_remaining   = (mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k]) - locals->VStartup[k];
9679
9680                 if (s->blank_lines_remaining < 0) {
9681                         dml_print("ERROR: Vstartup is larger than vblank!?\n");
9682                         s->blank_lines_remaining = 0;
9683                         ASSERT(0);
9684                 }
9685                 locals->MIN_DST_Y_NEXT_START[k] = s->dlg_vblank_start + s->blank_lines_remaining + s->LSetup;
9686
9687                 // debug only
9688                 s->old_MIN_DST_Y_NEXT_START = ((isInterlaceTiming ? dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]) / 2.0, 1.0) :
9689                                                                                                                                         mode_lib->ms.cache_display_cfg.timing.VTotal[k]) - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k])
9690                                                                                         + dml_max(1.0, dml_ceil((dml_float_t) locals->WritebackDelay[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0))
9691                                                                                         + dml_floor(4.0 * locals->TSetup[k] / ((dml_float_t) mode_lib->ms.cache_display_cfg.timing.HTotal[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]), 1.0) / 4.0;
9692
9693                 if (((locals->VUpdateOffsetPix[k] + locals->VUpdateWidthPix[k] + locals->VReadyOffsetPix[k]) / mode_lib->ms.cache_display_cfg.timing.HTotal[k]) <=
9694                         (isInterlaceTiming ?
9695                                 dml_floor((mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k] - locals->VStartup[k]) / 2.0, 1.0) :
9696                                 (int) (mode_lib->ms.cache_display_cfg.timing.VTotal[k] - mode_lib->ms.cache_display_cfg.timing.VActive[k] - mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k] - locals->VStartup[k]))) {
9697                         locals->VREADY_AT_OR_AFTER_VSYNC[k] = true;
9698                 } else {
9699                         locals->VREADY_AT_OR_AFTER_VSYNC[k] = false;
9700                 }
9701 #ifdef __DML_VBA_DEBUG__
9702                 dml_print("DML::%s: k=%u, VStartup = %u (max)\n", __func__, k, locals->VStartup[k]);
9703                 dml_print("DML::%s: k=%u, VStartupMin = %u (max)\n", __func__, k, locals->VStartupMin[k]);
9704                 dml_print("DML::%s: k=%u, VUpdateOffsetPix = %u\n", __func__, k, locals->VUpdateOffsetPix[k]);
9705                 dml_print("DML::%s: k=%u, VUpdateWidthPix = %u\n", __func__, k, locals->VUpdateWidthPix[k]);
9706                 dml_print("DML::%s: k=%u, VReadyOffsetPix = %u\n", __func__, k, locals->VReadyOffsetPix[k]);
9707                 dml_print("DML::%s: k=%u, HTotal = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.HTotal[k]);
9708                 dml_print("DML::%s: k=%u, VTotal = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VTotal[k]);
9709                 dml_print("DML::%s: k=%u, VActive = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VActive[k]);
9710                 dml_print("DML::%s: k=%u, VFrontPorch = %u\n", __func__, k, mode_lib->ms.cache_display_cfg.timing.VFrontPorch[k]);
9711                 dml_print("DML::%s: k=%u, TSetup = %f\n", __func__, k, locals->TSetup[k]);
9712                 dml_print("DML::%s: k=%u, MIN_DST_Y_NEXT_START = %f\n", __func__, k, locals->MIN_DST_Y_NEXT_START[k]);
9713                 dml_print("DML::%s: k=%u, MIN_DST_Y_NEXT_START = %f (old)\n", __func__, k, s->old_MIN_DST_Y_NEXT_START);
9714                 dml_print("DML::%s: k=%u, VREADY_AT_OR_AFTER_VSYNC = %u\n", __func__, k, locals->VREADY_AT_OR_AFTER_VSYNC[k]);
9715 #endif
9716         }
9717
9718         //Maximum Bandwidth Used
9719         s->TotalWRBandwidth = 0;
9720         s->WRBandwidth = 0;
9721         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9722                 if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true && mode_lib->ms.cache_display_cfg.writeback.WritebackPixelFormat[k] == dml_444_32) {
9723                         s->WRBandwidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k] /
9724                                                         (mode_lib->ms.cache_display_cfg.timing.HTotal[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 4;
9725                 } else if (mode_lib->ms.cache_display_cfg.writeback.WritebackEnable[k] == true) {
9726                         s->WRBandwidth = mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationWidth[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackDestinationHeight[k] /
9727                                                         (mode_lib->ms.cache_display_cfg.timing.HTotal[k] * mode_lib->ms.cache_display_cfg.writeback.WritebackSourceHeight[k] / mode_lib->ms.cache_display_cfg.timing.PixelClock[k]) * 8;
9728                 }
9729                 s->TotalWRBandwidth = s->TotalWRBandwidth + s->WRBandwidth;
9730         }
9731
9732         locals->TotalDataReadBandwidth = 0;
9733         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9734                 locals->TotalDataReadBandwidth = locals->TotalDataReadBandwidth + locals->ReadBandwidthSurfaceLuma[k] + locals->ReadBandwidthSurfaceChroma[k];
9735
9736 #ifdef __DML_VBA_DEBUG__
9737                 dml_print("DML::%s: k=%u, TotalDataReadBandwidth = %f\n", __func__, k, locals->TotalDataReadBandwidth);
9738                 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceLuma = %f\n", __func__, k, locals->ReadBandwidthSurfaceLuma[k]);
9739                 dml_print("DML::%s: k=%u, ReadBandwidthSurfaceChroma = %f\n", __func__, k, locals->ReadBandwidthSurfaceChroma[k]);
9740 #endif
9741         }
9742
9743         locals->TotalDataReadBandwidthNotIncludingMALLPrefetch = 0;
9744         for (k = 0; k < mode_lib->ms.num_active_planes; ++k) {
9745                 if (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[k] != dml_use_mall_pstate_change_phantom_pipe) {
9746                         locals->TotalDataReadBandwidthNotIncludingMALLPrefetch = locals->TotalDataReadBandwidthNotIncludingMALLPrefetch
9747                 + locals->ReadBandwidthSurfaceLuma[k] + locals->ReadBandwidthSurfaceChroma[k];
9748                 }
9749         }
9750
9751         CalculateStutterEfficiency_params->CompressedBufferSizeInkByte = locals->CompressedBufferSizeInkByte;
9752         CalculateStutterEfficiency_params->UseMALLForPStateChange = mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange;
9753         CalculateStutterEfficiency_params->UnboundedRequestEnabled = locals->UnboundedRequestEnabled;
9754         CalculateStutterEfficiency_params->MetaFIFOSizeInKEntries = mode_lib->ms.ip.meta_fifo_size_in_kentries;
9755         CalculateStutterEfficiency_params->ZeroSizeBufferEntries = mode_lib->ms.ip.zero_size_buffer_entries;
9756         CalculateStutterEfficiency_params->PixelChunkSizeInKByte = mode_lib->ms.ip.pixel_chunk_size_kbytes;
9757         CalculateStutterEfficiency_params->NumberOfActiveSurfaces = mode_lib->ms.num_active_planes;
9758         CalculateStutterEfficiency_params->ROBBufferSizeInKByte = mode_lib->ms.ip.rob_buffer_size_kbytes;
9759         CalculateStutterEfficiency_params->TotalDataReadBandwidth = locals->TotalDataReadBandwidth;
9760         CalculateStutterEfficiency_params->DCFCLK = locals->Dcfclk;
9761         CalculateStutterEfficiency_params->ReturnBW = mode_lib->ms.ReturnBW;
9762         CalculateStutterEfficiency_params->CompbufReservedSpace64B = locals->compbuf_reserved_space_64b;
9763         CalculateStutterEfficiency_params->CompbufReservedSpaceZs = locals->compbuf_reserved_space_zs;
9764         CalculateStutterEfficiency_params->SRExitTime = mode_lib->ms.state.sr_exit_time_us;
9765         CalculateStutterEfficiency_params->SRExitZ8Time = mode_lib->ms.state.sr_exit_z8_time_us;
9766         CalculateStutterEfficiency_params->SynchronizeTimingsFinal = mode_lib->ms.policy.SynchronizeTimingsFinal;
9767         CalculateStutterEfficiency_params->BlendingAndTiming = mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming;
9768         CalculateStutterEfficiency_params->StutterEnterPlusExitWatermark = locals->Watermark.StutterEnterPlusExitWatermark;
9769         CalculateStutterEfficiency_params->Z8StutterEnterPlusExitWatermark = locals->Watermark.Z8StutterEnterPlusExitWatermark;
9770         CalculateStutterEfficiency_params->ProgressiveToInterlaceUnitInOPP = mode_lib->ms.ip.ptoi_supported;
9771         CalculateStutterEfficiency_params->Interlace = mode_lib->ms.cache_display_cfg.timing.Interlace;
9772         CalculateStutterEfficiency_params->MinTTUVBlank = locals->MinTTUVBlank;
9773         CalculateStutterEfficiency_params->DPPPerSurface = mode_lib->ms.cache_display_cfg.hw.DPPPerSurface;
9774         CalculateStutterEfficiency_params->DETBufferSizeY = locals->DETBufferSizeY;
9775         CalculateStutterEfficiency_params->BytePerPixelY = locals->BytePerPixelY;
9776         CalculateStutterEfficiency_params->BytePerPixelDETY = locals->BytePerPixelDETY;
9777         CalculateStutterEfficiency_params->SwathWidthY = locals->SwathWidthY;
9778         CalculateStutterEfficiency_params->SwathHeightY = locals->SwathHeightY;
9779         CalculateStutterEfficiency_params->SwathHeightC = locals->SwathHeightC;
9780         CalculateStutterEfficiency_params->NetDCCRateLuma = mode_lib->ms.cache_display_cfg.surface.DCCRateLuma;
9781         CalculateStutterEfficiency_params->NetDCCRateChroma = mode_lib->ms.cache_display_cfg.surface.DCCRateChroma;
9782         CalculateStutterEfficiency_params->DCCFractionOfZeroSizeRequestsLuma = mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsLuma;
9783         CalculateStutterEfficiency_params->DCCFractionOfZeroSizeRequestsChroma = mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsChroma;
9784         CalculateStutterEfficiency_params->HTotal = mode_lib->ms.cache_display_cfg.timing.HTotal;
9785         CalculateStutterEfficiency_params->VTotal = mode_lib->ms.cache_display_cfg.timing.VTotal;
9786         CalculateStutterEfficiency_params->PixelClock = mode_lib->ms.cache_display_cfg.timing.PixelClock;
9787         CalculateStutterEfficiency_params->VRatio = mode_lib->ms.cache_display_cfg.plane.VRatio;
9788         CalculateStutterEfficiency_params->SourceScan = mode_lib->ms.cache_display_cfg.plane.SourceScan;
9789         CalculateStutterEfficiency_params->BlockHeight256BytesY = locals->BlockHeight256BytesY;
9790         CalculateStutterEfficiency_params->BlockWidth256BytesY = locals->BlockWidth256BytesY;
9791         CalculateStutterEfficiency_params->BlockHeight256BytesC = locals->BlockHeight256BytesC;
9792         CalculateStutterEfficiency_params->BlockWidth256BytesC = locals->BlockWidth256BytesC;
9793         CalculateStutterEfficiency_params->DCCYMaxUncompressedBlock = locals->DCCYMaxUncompressedBlock;
9794         CalculateStutterEfficiency_params->DCCCMaxUncompressedBlock = locals->DCCCMaxUncompressedBlock;
9795         CalculateStutterEfficiency_params->VActive = mode_lib->ms.cache_display_cfg.timing.VActive;
9796         CalculateStutterEfficiency_params->DCCEnable = mode_lib->ms.cache_display_cfg.surface.DCCEnable;
9797         CalculateStutterEfficiency_params->WritebackEnable = mode_lib->ms.cache_display_cfg.writeback.WritebackEnable;
9798         CalculateStutterEfficiency_params->ReadBandwidthSurfaceLuma = locals->ReadBandwidthSurfaceLuma;
9799         CalculateStutterEfficiency_params->ReadBandwidthSurfaceChroma = locals->ReadBandwidthSurfaceChroma;
9800         CalculateStutterEfficiency_params->meta_row_bw = locals->meta_row_bw;
9801         CalculateStutterEfficiency_params->dpte_row_bw = locals->dpte_row_bw;
9802         CalculateStutterEfficiency_params->StutterEfficiencyNotIncludingVBlank = &locals->StutterEfficiencyNotIncludingVBlank;
9803         CalculateStutterEfficiency_params->StutterEfficiency = &locals->StutterEfficiency;
9804         CalculateStutterEfficiency_params->NumberOfStutterBurstsPerFrame = &locals->NumberOfStutterBurstsPerFrame;
9805         CalculateStutterEfficiency_params->Z8StutterEfficiencyNotIncludingVBlank = &locals->Z8StutterEfficiencyNotIncludingVBlank;
9806         CalculateStutterEfficiency_params->Z8StutterEfficiency = &locals->Z8StutterEfficiency;
9807         CalculateStutterEfficiency_params->Z8NumberOfStutterBurstsPerFrame = &locals->Z8NumberOfStutterBurstsPerFrame;
9808         CalculateStutterEfficiency_params->StutterPeriod = &locals->StutterPeriod;
9809         CalculateStutterEfficiency_params->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = &locals->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE;
9810
9811         // Stutter Efficiency
9812         CalculateStutterEfficiency(&mode_lib->scratch,
9813                 CalculateStutterEfficiency_params);
9814
9815 #ifdef __DML_VBA_ALLOW_DELTA__
9816         {
9817         dml_float_t dummy_single[2];
9818         dml_uint_t dummy_integer[1];
9819         dml_bool_t dummy_boolean[1];
9820
9821         // Calculate z8 stutter eff assuming 0 reserved space
9822         CalculateStutterEfficiency(
9823                         locals->CompressedBufferSizeInkByte,
9824                         mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange,
9825                         locals->UnboundedRequestEnabled,
9826                         mode_lib->ms.ip.meta_fifo_size_in_kentries,
9827                         mode_lib->ms.ip.zero_size_buffer_entries,
9828                         mode_lib->ms.ip.pixel_chunk_size_kbytes,
9829                         mode_lib->ms.num_active_planes,
9830                         mode_lib->ms.ip.rob_buffer_size_kbytes,
9831                         locals->TotalDataReadBandwidth,
9832                         locals->Dcfclk,
9833                         mode_lib->ms.ReturnBW,
9834                         0, //mode_lib->ms.ip.compbuf_reserved_space_64b,
9835                         0, //mode_lib->ms.ip.compbuf_reserved_space_zs,
9836                         mode_lib->ms.state.sr_exit_time_us,
9837                         mode_lib->ms.state.sr_exit_z8_time_us,
9838                         mode_lib->ms.policy.SynchronizeTimingsFinal,
9839                         mode_lib->ms.cache_display_cfg.plane.BlendingAndTiming,
9840                         locals->Watermark.StutterEnterPlusExitWatermark,
9841                         locals->Watermark.Z8StutterEnterPlusExitWatermark,
9842                         mode_lib->ms.ip.ptoi_supported,
9843                         mode_lib->ms.cache_display_cfg.timing.Interlace,
9844                         locals->MinTTUVBlank,
9845                         mode_lib->ms.cache_display_cfg.hw.DPPPerSurface,
9846                         mode_lib->ms.DETBufferSizeY,
9847                         locals->BytePerPixelY,
9848                         locals->BytePerPixelDETY,
9849                         locals->SwathWidthY,
9850                         mode_lib->ms.SwathHeightY,
9851                         mode_lib->ms.SwathHeightC,
9852                         mode_lib->ms.cache_display_cfg.surface.DCCRateLuma,
9853                         mode_lib->ms.cache_display_cfg.surface.DCCRateChroma,
9854                         mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsLuma,
9855                         mode_lib->ms.cache_display_cfg.surface.DCCFractionOfZeroSizeRequestsChroma,
9856                         mode_lib->ms.cache_display_cfg.timing.HTotal,
9857                         mode_lib->ms.cache_display_cfg.timing.VTotal,
9858                         mode_lib->ms.cache_display_cfg.timing.PixelClock,
9859                         mode_lib->ms.cache_display_cfg.plane.VRatio,
9860                         mode_lib->ms.cache_display_cfg.plane.SourceScan,
9861                         locals->BlockHeight256BytesY,
9862                         locals->BlockWidth256BytesY,
9863                         locals->BlockHeight256BytesC,
9864                         locals->BlockWidth256BytesC,
9865                         locals->DCCYMaxUncompressedBlock,
9866                         locals->DCCCMaxUncompressedBlock,
9867                         mode_lib->ms.cache_display_cfg.timing.VActive,
9868                         mode_lib->ms.cache_display_cfg.surface.DCCEnable,
9869                         mode_lib->ms.cache_display_cfg.writeback.WritebackEnable,
9870                         locals->ReadBandwidthSurfaceLuma,
9871                         locals->ReadBandwidthSurfaceChroma,
9872                         locals->meta_row_bw,
9873                         locals->dpte_row_bw,
9874
9875                         /* Output */
9876                         &dummy_single[0],
9877                         &dummy_single[1],
9878                         &dummy_integer[0],
9879                         &locals->Z8StutterEfficiencyNotIncludingVBlankBestCase,
9880                         &locals->Z8StutterEfficiencyBestCase,
9881                         &locals->Z8NumberOfStutterBurstsPerFrameBestCase,
9882                         &locals->StutterPeriodBestCase,
9883                         &dummy_boolean[0]);
9884         }
9885 #else
9886         locals->Z8StutterEfficiencyNotIncludingVBlankBestCase = locals->Z8StutterEfficiencyNotIncludingVBlank;
9887         locals->Z8StutterEfficiencyBestCase                   = locals->Z8StutterEfficiency;
9888         locals->Z8NumberOfStutterBurstsPerFrameBestCase       = locals->Z8NumberOfStutterBurstsPerFrame;
9889         locals->StutterPeriodBestCase                         = locals->StutterPeriod;
9890 #endif
9891
9892 #ifdef __DML_VBA_DEBUG__
9893         dml_print("DML::%s: --- END --- \n",  __func__);
9894 #endif
9895 } // dml_core_mode_programming
9896
9897 /// Function: dml_core_get_row_heights
9898 /// @brief Get row height for DPTE and META with minimal input.
9899 void dml_core_get_row_heights(
9900                                                 dml_uint_t                         *dpte_row_height,
9901                                                 dml_uint_t                         *meta_row_height,
9902                                                 const struct display_mode_lib_st   *mode_lib,
9903                                                 dml_bool_t                         is_plane1,
9904                                                 enum dml_source_format_class        SourcePixelFormat,
9905                                                 enum dml_swizzle_mode            SurfaceTiling,
9906                                                 enum dml_rotation_angle          ScanDirection,
9907                                                 dml_uint_t                         pitch,
9908                                                 dml_uint_t                         GPUVMMinPageSizeKBytes)
9909 {
9910         dml_uint_t BytePerPixelY;
9911         dml_uint_t BytePerPixelC;
9912         dml_float_t BytePerPixelInDETY;
9913         dml_float_t BytePerPixelInDETC;
9914         dml_uint_t BlockHeight256BytesY;
9915         dml_uint_t BlockHeight256BytesC;
9916         dml_uint_t BlockWidth256BytesY;
9917         dml_uint_t BlockWidth256BytesC;
9918         dml_uint_t MacroTileWidthY;
9919         dml_uint_t MacroTileWidthC;
9920         dml_uint_t MacroTileHeightY;
9921         dml_uint_t MacroTileHeightC;
9922
9923         dml_uint_t BytePerPixel;
9924         dml_uint_t BlockHeight256Bytes;
9925         dml_uint_t BlockWidth256Bytes;
9926         dml_uint_t MacroTileWidth;
9927         dml_uint_t MacroTileHeight;
9928         dml_uint_t PTEBufferSizeInRequests;
9929
9930         dml_uint_t dummy_integer[16];
9931
9932         CalculateBytePerPixelAndBlockSizes(
9933                 SourcePixelFormat,
9934                 SurfaceTiling,
9935
9936                 /* Output */
9937                 &BytePerPixelY,
9938                 &BytePerPixelC,
9939                 &BytePerPixelInDETY,
9940                 &BytePerPixelInDETC,
9941                 &BlockHeight256BytesY,
9942                 &BlockHeight256BytesC,
9943                 &BlockWidth256BytesY,
9944                 &BlockWidth256BytesC,
9945                 &MacroTileHeightY,
9946                 &MacroTileHeightC,
9947                 &MacroTileWidthY,
9948                 &MacroTileWidthC);
9949
9950         BytePerPixel = is_plane1 ? BytePerPixelC : BytePerPixelY;
9951         BlockHeight256Bytes = is_plane1 ? BlockHeight256BytesC : BlockHeight256BytesY;
9952         BlockWidth256Bytes = is_plane1 ? BlockWidth256BytesC : BlockWidth256BytesY;
9953         MacroTileWidth = is_plane1 ? MacroTileWidthC : MacroTileWidthY;
9954         MacroTileHeight = is_plane1 ? MacroTileHeightC : MacroTileHeightY;
9955         PTEBufferSizeInRequests = is_plane1 ? mode_lib->ip.dpte_buffer_size_in_pte_reqs_chroma : mode_lib->ip.dpte_buffer_size_in_pte_reqs_luma;
9956 #ifdef __DML_RQ_DLG_CALC_DEBUG__
9957         dml_print("DML_DLG: %s: is_plane1 = %u\n", __func__, is_plane1);
9958         dml_print("DML_DLG: %s: BytePerPixel = %u\n", __func__, BytePerPixel);
9959         dml_print("DML_DLG: %s: BlockHeight256Bytes = %u\n", __func__, BlockHeight256Bytes);
9960         dml_print("DML_DLG: %s: BlockWidth256Bytes = %u\n", __func__, BlockWidth256Bytes);
9961         dml_print("DML_DLG: %s: MacroTileWidth = %u\n", __func__, MacroTileWidth);
9962         dml_print("DML_DLG: %s: MacroTileHeight = %u\n", __func__, MacroTileHeight);
9963         dml_print("DML_DLG: %s: PTEBufferSizeInRequests = %u\n", __func__, PTEBufferSizeInRequests);
9964         dml_print("DML_DLG: %s: dpte_buffer_size_in_pte_reqs_luma = %u\n", __func__, mode_lib->ip.dpte_buffer_size_in_pte_reqs_luma);
9965         dml_print("DML_DLG: %s: dpte_buffer_size_in_pte_reqs_chroma = %u\n", __func__, mode_lib->ip.dpte_buffer_size_in_pte_reqs_chroma);
9966         dml_print("DML_DLG: %s: GPUVMMinPageSizeKBytes = %u\n", __func__, GPUVMMinPageSizeKBytes);
9967 #endif
9968
9969         // just suppluy with enough parameters to calculate meta and dte
9970         CalculateVMAndRowBytes(
9971                         0, // dml_bool_t ViewportStationary,
9972                         1, // dml_bool_t DCCEnable,
9973                         1, // dml_uint_t NumberOfDPPs,
9974                         BlockHeight256Bytes,
9975                         BlockWidth256Bytes,
9976                         SourcePixelFormat,
9977                         SurfaceTiling,
9978                         BytePerPixel,
9979                         ScanDirection,
9980                         0, // dml_uint_t SwathWidth,
9981                         0, // dml_uint_t ViewportHeight, (Note: DML calculates one_row_for_frame height regardless, would need test input if that height is useful)
9982                         0, // dml_uint_t ViewportXStart,
9983                         0, // dml_uint_t ViewportYStart,
9984                         1, // dml_bool_t GPUVMEnable,
9985                         4, // dml_uint_t GPUVMMaxPageTableLevels,
9986                         GPUVMMinPageSizeKBytes,
9987                         PTEBufferSizeInRequests,
9988                         pitch,
9989                         0, // dml_uint_t DCCMetaPitch,
9990                         MacroTileWidth,
9991                         MacroTileHeight,
9992
9993                         // /* Output */
9994                         &dummy_integer[0], // dml_uint_t *MetaRowByte,
9995                         &dummy_integer[1], // dml_uint_t *PixelPTEBytesPerRow,
9996                         &dummy_integer[2], // dml_uint_t *PixelPTEBytesPerRowStorage,
9997                         &dummy_integer[3], // dml_uint_t *dpte_row_width_ub,
9998                         dpte_row_height,
9999                         &dummy_integer[4], // dml_uint_t *dpte_row_height_linear
10000                         &dummy_integer[5], // dml_uint_t *PixelPTEBytesPerRow_one_row_per_frame,
10001                         &dummy_integer[6], // dml_uint_t *dpte_row_width_ub_one_row_per_frame,
10002                         &dummy_integer[7], // dml_uint_t *dpte_row_height_one_row_per_frame,
10003                         &dummy_integer[8], // dml_uint_t *MetaRequestWidth,
10004                         &dummy_integer[9], // dml_uint_t *MetaRequestHeight,
10005                         &dummy_integer[10], // dml_uint_t *meta_row_width,
10006                         meta_row_height,
10007                         &dummy_integer[11], // dml_uint_t *PixelPTEReqWidth,
10008                         &dummy_integer[12], // dml_uint_t *PixelPTEReqHeight,
10009                         &dummy_integer[13], // dml_uint_t *PTERequestSize,
10010                         &dummy_integer[14], // dml_uint_t *DPDE0BytesFrame,
10011                         &dummy_integer[15]); // dml_uint_t *MetaPTEBytesFrame)
10012
10013 #ifdef __DML_RQ_DLG_CALC_DEBUG__
10014         dml_print("DML_DLG: %s: dpte_row_height = %u\n", __func__, *dpte_row_height);
10015         dml_print("DML_DLG: %s: meta_row_height = %u\n", __func__, *meta_row_height);
10016 #endif
10017 }
10018
10019 static struct soc_state_bounding_box_st dml_get_soc_state_bounding_box(
10020         const struct soc_states_st *states,
10021         dml_uint_t state_idx)
10022 {
10023         dml_print("DML::%s: state_idx=%u (num_states=%u)\n", __func__, state_idx, states->num_states);
10024
10025         if (state_idx >= (dml_uint_t)states->num_states) {
10026                 dml_print("DML::%s: ERROR: Invalid state_idx=%u! num_states=%u\n", __func__, state_idx, states->num_states);
10027                 ASSERT(0);
10028         }
10029         return (states->state_array[state_idx]);
10030 }
10031
10032 /// @brief Copy the parameters to a calculation struct, it actually only need when the DML needs to have
10033 ///        the intelligence to re-calculate when any of display cfg, bbox, or policy changes since last calculated.
10034 ///
10035 static void cache_ip_soc_cfg(struct display_mode_lib_st *mode_lib,
10036                                                 dml_uint_t state_idx)
10037 {
10038         mode_lib->ms.state_idx = state_idx;
10039         mode_lib->ms.max_state_idx = mode_lib->states.num_states - 1;
10040         mode_lib->ms.soc = mode_lib->soc;
10041         mode_lib->ms.ip = mode_lib->ip;
10042         mode_lib->ms.policy = mode_lib->policy;
10043         mode_lib->ms.state = dml_get_soc_state_bounding_box(&mode_lib->states, state_idx);
10044         mode_lib->ms.max_state = dml_get_soc_state_bounding_box(&mode_lib->states, mode_lib->states.num_states - 1);
10045 }
10046
10047 static void cache_display_cfg(struct display_mode_lib_st *mode_lib,
10048         const struct dml_display_cfg_st *display_cfg)
10049 {
10050         mode_lib->ms.cache_display_cfg = *display_cfg;
10051 }
10052
10053 static void fetch_socbb_params(struct display_mode_lib_st *mode_lib)
10054 {
10055         struct soc_state_bounding_box_st *state = &mode_lib->ms.state;
10056
10057         // Default values, SOCCLK, DRAMSpeed, and FabricClock will be reassigned to the same state value in mode_check step
10058         // If UseMinimumRequiredDCFCLK is used, the DCFCLK will be the min dcflk for the mode support
10059         mode_lib->ms.SOCCLK = (dml_float_t)state->socclk_mhz;
10060         mode_lib->ms.DRAMSpeed = (dml_float_t)state->dram_speed_mts;
10061         mode_lib->ms.FabricClock = (dml_float_t)state->fabricclk_mhz;
10062         mode_lib->ms.DCFCLK = (dml_float_t)state->dcfclk_mhz;
10063 }
10064
10065 /// @brief Use display_cfg directly for mode_support calculation
10066 ///        Calculated values and informational output are stored in mode_lib.vba data struct
10067 ///        The display configuration is described with pipes struct and num_pipes
10068 ///        This function is used when physical resource mapping is not finalized (for example,
10069 ///        don't know how many pipes to represent a surface)
10070 /// @param mode_lib Contains the bounding box and policy setting.
10071 /// @param state_idx Power state index
10072 /// @param display_cfg Display configurations. A display
10073 dml_bool_t dml_mode_support(
10074         struct display_mode_lib_st *mode_lib,
10075         dml_uint_t                        state_idx,
10076         const struct dml_display_cfg_st *display_cfg)
10077 {
10078         dml_bool_t is_mode_support;
10079
10080         dml_print("DML::%s: ------------- START ----------\n", __func__);
10081         cache_ip_soc_cfg(mode_lib, state_idx);
10082         cache_display_cfg(mode_lib, display_cfg);
10083
10084         fetch_socbb_params(mode_lib);
10085
10086         dml_print("DML::%s: state_idx          = %u\n", __func__, state_idx);
10087
10088         is_mode_support = dml_core_mode_support(mode_lib);
10089
10090         dml_print("DML::%s: is_mode_support = %u\n", __func__, is_mode_support);
10091         dml_print("DML::%s: ------------- DONE ----------\n", __func__);
10092         return is_mode_support;
10093 }
10094
10095 /// @Brief A function to calculate the programming values for DCN DCHUB (Assume mode is supported)
10096 /// The output will be stored in the mode_lib.mp (mode_program_st) data struct and those can be accessed via the getter functions
10097 /// Calculated values include: watermarks, dlg, rq reg, different clock frequency
10098 /// This function returns 1 when there is no error.
10099 /// Note: In this function, it is assumed that DCFCLK, SOCCLK freq are the state values, and mode_program will just use the DML calculated DPPCLK and DISPCLK
10100 /// @param mode_lib mode_lib data struct that house all the input/output/bbox and calculation values.
10101 /// @param state_idx Power state idx chosen
10102 /// @param display_cfg Display Congiuration
10103 /// @param call_standalone Calling mode_programming without calling mode support.  Some of the "support" struct member will be pre-calculated before doing mode programming
10104 /// TODO: Add clk_cfg input, could be useful for standalone mode
10105 dml_bool_t dml_mode_programming(
10106         struct display_mode_lib_st *mode_lib,
10107         dml_uint_t                         state_idx,
10108         const struct dml_display_cfg_st *display_cfg,
10109         bool                               call_standalone)
10110 {
10111         struct dml_clk_cfg_st clk_cfg;
10112         memset(&clk_cfg, 0, sizeof(clk_cfg));
10113
10114         clk_cfg.dcfclk_option = dml_use_required_freq;
10115         clk_cfg.dispclk_option = dml_use_required_freq;
10116         for (dml_uint_t k = 0; k < __DML_NUM_PLANES__; ++k)
10117                 clk_cfg.dppclk_option[k] = dml_use_required_freq;
10118
10119         dml_print("DML::%s: ------------- START ----------\n", __func__);
10120         dml_print("DML::%s: state_idx       = %u\n", __func__, state_idx);
10121         dml_print("DML::%s: call_standalone = %u\n", __func__, call_standalone);
10122
10123         cache_ip_soc_cfg(mode_lib, state_idx);
10124         cache_display_cfg(mode_lib, display_cfg);
10125
10126         fetch_socbb_params(mode_lib);
10127         if (call_standalone) {
10128                 mode_lib->ms.support.ImmediateFlipSupport = 1; // assume mode support say immediate flip ok at max state/combine
10129                 dml_core_mode_support_partial(mode_lib);
10130         }
10131
10132         dml_core_mode_programming(mode_lib, &clk_cfg);
10133
10134         dml_print("DML::%s: ------------- DONE ----------\n", __func__);
10135         dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %0d\n", __func__, mode_lib->mp.PrefetchAndImmediateFlipSupported);
10136         return mode_lib->mp.PrefetchAndImmediateFlipSupported;
10137 }
10138
10139 static dml_uint_t mode_support_pwr_states(
10140         dml_uint_t *lowest_state_idx,
10141         struct display_mode_lib_st *mode_lib,
10142         const struct dml_display_cfg_st *display_cfg,
10143         dml_uint_t start_state_idx,
10144         dml_uint_t end_state_idx)
10145 {
10146         dml_uint_t state_idx = 0;
10147         dml_bool_t mode_is_supported = 0;
10148         *lowest_state_idx = end_state_idx;
10149
10150         if (end_state_idx < start_state_idx)
10151                 ASSERT(0);
10152
10153         if (end_state_idx >= mode_lib->states.num_states) // idx is 0-based
10154                 ASSERT(0);
10155
10156         for (state_idx = start_state_idx; state_idx <= end_state_idx; state_idx++) {
10157                 if (dml_mode_support(mode_lib, state_idx, display_cfg)) {
10158                         dml_print("DML::%s: Mode is supported at power state_idx = %u\n", __func__, state_idx);
10159                         mode_is_supported = 1;
10160                         *lowest_state_idx = state_idx;
10161                         break;
10162                 }
10163         }
10164
10165         return mode_is_supported;
10166 }
10167
10168 dml_uint_t dml_mode_support_ex(struct dml_mode_support_ex_params_st *in_out_params)
10169 {
10170         dml_uint_t result;
10171
10172         result = mode_support_pwr_states(&in_out_params->out_lowest_state_idx,
10173                 in_out_params->mode_lib,
10174                 in_out_params->in_display_cfg,
10175                 0,
10176                 in_out_params->mode_lib->states.num_states - 1);
10177
10178         if (result)
10179                 *in_out_params->out_evaluation_info = in_out_params->mode_lib->ms.support;
10180
10181         return result;
10182 }
10183
10184 dml_bool_t dml_get_is_phantom_pipe(struct display_mode_lib_st *mode_lib, dml_uint_t pipe_idx)
10185 {
10186         dml_uint_t plane_idx = mode_lib->mp.pipe_plane[pipe_idx];
10187         dml_print("DML::%s: pipe_idx=%d UseMALLForPStateChange=%0d\n", __func__, pipe_idx, mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[plane_idx]);
10188         return (mode_lib->ms.cache_display_cfg.plane.UseMALLForPStateChange[plane_idx] == dml_use_mall_pstate_change_phantom_pipe);
10189 }
10190
10191 #define dml_get_per_surface_var_func(variable, type, interval_var) type dml_get_##variable(struct display_mode_lib_st *mode_lib, dml_uint_t surface_idx) \
10192 { \
10193         dml_uint_t plane_idx; \
10194         plane_idx = mode_lib->mp.pipe_plane[surface_idx]; \
10195         return (type) interval_var[plane_idx]; \
10196 }
10197
10198 #define dml_get_var_func(var, type, internal_var)  type dml_get_##var(struct display_mode_lib_st *mode_lib) \
10199 { \
10200         return (type) internal_var; \
10201 }
10202
10203 dml_get_var_func(wm_urgent, dml_float_t, mode_lib->mp.Watermark.UrgentWatermark);
10204 dml_get_var_func(wm_stutter_exit, dml_float_t, mode_lib->mp.Watermark.StutterExitWatermark);
10205 dml_get_var_func(wm_stutter_enter_exit, dml_float_t, mode_lib->mp.Watermark.StutterEnterPlusExitWatermark);
10206 dml_get_var_func(wm_memory_trip, dml_float_t, mode_lib->mp.UrgentLatency);
10207 dml_get_var_func(wm_fclk_change, dml_float_t, mode_lib->mp.Watermark.FCLKChangeWatermark);
10208 dml_get_var_func(wm_usr_retraining, dml_float_t, mode_lib->mp.Watermark.USRRetrainingWatermark);
10209 dml_get_var_func(wm_dram_clock_change, dml_float_t, mode_lib->mp.Watermark.DRAMClockChangeWatermark);
10210 dml_get_var_func(wm_z8_stutter_enter_exit, dml_float_t, mode_lib->mp.Watermark.Z8StutterEnterPlusExitWatermark);
10211 dml_get_var_func(wm_z8_stutter, dml_float_t, mode_lib->mp.Watermark.Z8StutterExitWatermark);
10212 dml_get_var_func(fraction_of_urgent_bandwidth, dml_float_t, mode_lib->mp.FractionOfUrgentBandwidth);
10213 dml_get_var_func(fraction_of_urgent_bandwidth_imm_flip, dml_float_t, mode_lib->mp.FractionOfUrgentBandwidthImmediateFlip);
10214 dml_get_var_func(urgent_latency, dml_float_t, mode_lib->mp.UrgentLatency);
10215 dml_get_var_func(clk_dcf_deepsleep, dml_float_t, mode_lib->mp.DCFCLKDeepSleep);
10216 dml_get_var_func(wm_writeback_dram_clock_change, dml_float_t, mode_lib->mp.Watermark.WritebackDRAMClockChangeWatermark);
10217 dml_get_var_func(stutter_efficiency, dml_float_t, mode_lib->mp.StutterEfficiency);
10218 dml_get_var_func(stutter_efficiency_no_vblank, dml_float_t, mode_lib->mp.StutterEfficiencyNotIncludingVBlank);
10219 dml_get_var_func(stutter_efficiency_z8, dml_float_t, mode_lib->mp.Z8StutterEfficiency);
10220 dml_get_var_func(stutter_num_bursts_z8, dml_float_t, mode_lib->mp.Z8NumberOfStutterBurstsPerFrame);
10221 dml_get_var_func(stutter_period, dml_float_t, mode_lib->mp.StutterPeriod);
10222 dml_get_var_func(stutter_efficiency_z8_bestcase, dml_float_t, mode_lib->mp.Z8StutterEfficiencyBestCase);
10223 dml_get_var_func(stutter_num_bursts_z8_bestcase, dml_float_t, mode_lib->mp.Z8NumberOfStutterBurstsPerFrameBestCase);
10224 dml_get_var_func(stutter_period_bestcase, dml_float_t, mode_lib->mp.StutterPeriodBestCase);
10225 dml_get_var_func(urgent_extra_latency, dml_float_t, mode_lib->mp.UrgentExtraLatency);
10226 dml_get_var_func(dispclk_calculated, dml_float_t, mode_lib->mp.Dispclk_calculated);
10227 dml_get_var_func(total_data_read_bw, dml_float_t, mode_lib->mp.TotalDataReadBandwidth);
10228 dml_get_var_func(return_bw, dml_float_t, mode_lib->ms.ReturnBW);
10229 dml_get_var_func(tcalc, dml_float_t, mode_lib->mp.TCalc);
10230 dml_get_var_func(comp_buffer_size_kbytes, dml_uint_t, mode_lib->mp.CompressedBufferSizeInkByte);
10231 dml_get_var_func(pixel_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.pixel_chunk_size_kbytes);
10232 dml_get_var_func(alpha_pixel_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.alpha_pixel_chunk_size_kbytes);
10233 dml_get_var_func(meta_chunk_size_in_kbyte, dml_uint_t, mode_lib->ms.ip.meta_chunk_size_kbytes);
10234 dml_get_var_func(min_pixel_chunk_size_in_byte, dml_uint_t, mode_lib->ms.ip.min_pixel_chunk_size_bytes);
10235 dml_get_var_func(min_meta_chunk_size_in_byte, dml_uint_t, mode_lib->ms.ip.min_meta_chunk_size_bytes);
10236 dml_get_var_func(total_immediate_flip_bytes, dml_uint_t, mode_lib->mp.TotImmediateFlipBytes);
10237
10238 dml_get_per_surface_var_func(dsc_delay, dml_uint_t, mode_lib->mp.DSCDelay); // this is the dsc latency
10239 dml_get_per_surface_var_func(dppclk_calculated, dml_float_t, mode_lib->mp.Dppclk_calculated);
10240 dml_get_per_surface_var_func(dscclk_calculated, dml_float_t, mode_lib->mp.DSCCLK_calculated);
10241 dml_get_per_surface_var_func(min_ttu_vblank_in_us, dml_float_t, mode_lib->mp.MinTTUVBlank);
10242 dml_get_per_surface_var_func(vratio_prefetch_l, dml_float_t, mode_lib->mp.VRatioPrefetchY);
10243 dml_get_per_surface_var_func(vratio_prefetch_c, dml_float_t, mode_lib->mp.VRatioPrefetchC);
10244 dml_get_per_surface_var_func(dst_x_after_scaler, dml_uint_t, mode_lib->mp.DSTXAfterScaler);
10245 dml_get_per_surface_var_func(dst_y_after_scaler, dml_uint_t, mode_lib->mp.DSTYAfterScaler);
10246 dml_get_per_surface_var_func(dst_y_per_vm_vblank, dml_float_t, mode_lib->mp.DestinationLinesToRequestVMInVBlank);
10247 dml_get_per_surface_var_func(dst_y_per_row_vblank, dml_float_t, mode_lib->mp.DestinationLinesToRequestRowInVBlank);
10248 dml_get_per_surface_var_func(dst_y_prefetch, dml_float_t, mode_lib->mp.DestinationLinesForPrefetch);
10249 dml_get_per_surface_var_func(dst_y_per_vm_flip, dml_float_t, mode_lib->mp.DestinationLinesToRequestVMInImmediateFlip);
10250 dml_get_per_surface_var_func(dst_y_per_row_flip, dml_float_t, mode_lib->mp.DestinationLinesToRequestRowInImmediateFlip);
10251 dml_get_per_surface_var_func(dst_y_per_pte_row_nom_l, dml_float_t, mode_lib->mp.DST_Y_PER_PTE_ROW_NOM_L);
10252 dml_get_per_surface_var_func(dst_y_per_pte_row_nom_c, dml_float_t, mode_lib->mp.DST_Y_PER_PTE_ROW_NOM_C);
10253 dml_get_per_surface_var_func(dst_y_per_meta_row_nom_l, dml_float_t, mode_lib->mp.DST_Y_PER_META_ROW_NOM_L);
10254 dml_get_per_surface_var_func(dst_y_per_meta_row_nom_c, dml_float_t, mode_lib->mp.DST_Y_PER_META_ROW_NOM_C);
10255 dml_get_per_surface_var_func(refcyc_per_vm_group_vblank_in_us, dml_float_t, mode_lib->mp.TimePerVMGroupVBlank);
10256 dml_get_per_surface_var_func(refcyc_per_vm_group_flip_in_us, dml_float_t, mode_lib->mp.TimePerVMGroupFlip);
10257 dml_get_per_surface_var_func(refcyc_per_vm_req_vblank_in_us, dml_float_t, mode_lib->mp.TimePerVMRequestVBlank);
10258 dml_get_per_surface_var_func(refcyc_per_vm_req_flip_in_us, dml_float_t, mode_lib->mp.TimePerVMRequestFlip);
10259 dml_get_per_surface_var_func(refcyc_per_vm_dmdata_in_us, dml_float_t, mode_lib->mp.Tdmdl_vm);
10260 dml_get_per_surface_var_func(dmdata_dl_delta_in_us, dml_float_t, mode_lib->mp.Tdmdl);
10261 dml_get_per_surface_var_func(refcyc_per_line_delivery_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeLuma);
10262 dml_get_per_surface_var_func(refcyc_per_line_delivery_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeChroma);
10263 dml_get_per_surface_var_func(refcyc_per_line_delivery_pre_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeLumaPrefetch);
10264 dml_get_per_surface_var_func(refcyc_per_line_delivery_pre_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeLineDeliveryTimeChromaPrefetch);
10265 dml_get_per_surface_var_func(refcyc_per_req_delivery_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeLuma);
10266 dml_get_per_surface_var_func(refcyc_per_req_delivery_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeChroma);
10267 dml_get_per_surface_var_func(refcyc_per_req_delivery_pre_l_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeLumaPrefetch);
10268 dml_get_per_surface_var_func(refcyc_per_req_delivery_pre_c_in_us, dml_float_t, mode_lib->mp.DisplayPipeRequestDeliveryTimeChromaPrefetch);
10269 dml_get_per_surface_var_func(refcyc_per_cursor_req_delivery_in_us, dml_float_t, mode_lib->mp.CursorRequestDeliveryTime);
10270 dml_get_per_surface_var_func(refcyc_per_cursor_req_delivery_pre_in_us, dml_float_t, mode_lib->mp.CursorRequestDeliveryTimePrefetch);
10271 dml_get_per_surface_var_func(refcyc_per_meta_chunk_nom_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkNominal);
10272 dml_get_per_surface_var_func(refcyc_per_meta_chunk_nom_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkNominal);
10273 dml_get_per_surface_var_func(refcyc_per_meta_chunk_vblank_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkVBlank);
10274 dml_get_per_surface_var_func(refcyc_per_meta_chunk_vblank_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkVBlank);
10275 dml_get_per_surface_var_func(refcyc_per_meta_chunk_flip_l_in_us, dml_float_t, mode_lib->mp.TimePerMetaChunkFlip);
10276 dml_get_per_surface_var_func(refcyc_per_meta_chunk_flip_c_in_us, dml_float_t, mode_lib->mp.TimePerChromaMetaChunkFlip);
10277 dml_get_per_surface_var_func(refcyc_per_pte_group_nom_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_nom_luma);
10278 dml_get_per_surface_var_func(refcyc_per_pte_group_nom_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_nom_chroma);
10279 dml_get_per_surface_var_func(refcyc_per_pte_group_vblank_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_vblank_luma);
10280 dml_get_per_surface_var_func(refcyc_per_pte_group_vblank_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_vblank_chroma);
10281 dml_get_per_surface_var_func(refcyc_per_pte_group_flip_l_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_flip_luma);
10282 dml_get_per_surface_var_func(refcyc_per_pte_group_flip_c_in_us, dml_float_t, mode_lib->mp.time_per_pte_group_flip_chroma);
10283 dml_get_per_surface_var_func(dpte_group_size_in_bytes, dml_uint_t, mode_lib->mp.dpte_group_bytes);
10284 dml_get_per_surface_var_func(vm_group_size_in_bytes, dml_uint_t, mode_lib->mp.vm_group_bytes);
10285 dml_get_per_surface_var_func(swath_height_l, dml_uint_t, mode_lib->ms.SwathHeightY);
10286 dml_get_per_surface_var_func(swath_height_c, dml_uint_t, mode_lib->ms.SwathHeightC);
10287 dml_get_per_surface_var_func(dpte_row_height_l, dml_uint_t, mode_lib->mp.dpte_row_height);
10288 dml_get_per_surface_var_func(dpte_row_height_c, dml_uint_t, mode_lib->mp.dpte_row_height_chroma);
10289 dml_get_per_surface_var_func(dpte_row_height_linear_l, dml_uint_t, mode_lib->mp.dpte_row_height_linear);
10290 dml_get_per_surface_var_func(dpte_row_height_linear_c, dml_uint_t, mode_lib->mp.dpte_row_height_linear_chroma);
10291 dml_get_per_surface_var_func(meta_row_height_l, dml_uint_t, mode_lib->mp.meta_row_height);
10292 dml_get_per_surface_var_func(meta_row_height_c, dml_uint_t, mode_lib->mp.meta_row_height_chroma);
10293
10294 dml_get_per_surface_var_func(vstartup_calculated, dml_uint_t, mode_lib->mp.VStartup);
10295 dml_get_per_surface_var_func(vupdate_offset, dml_uint_t, mode_lib->mp.VUpdateOffsetPix);
10296 dml_get_per_surface_var_func(vupdate_width, dml_uint_t, mode_lib->mp.VUpdateWidthPix);
10297 dml_get_per_surface_var_func(vready_offset, dml_uint_t, mode_lib->mp.VReadyOffsetPix);
10298 dml_get_per_surface_var_func(vready_at_or_after_vsync, dml_uint_t, mode_lib->mp.VREADY_AT_OR_AFTER_VSYNC);
10299 dml_get_per_surface_var_func(min_dst_y_next_start, dml_uint_t, mode_lib->mp.MIN_DST_Y_NEXT_START);
10300 dml_get_per_surface_var_func(det_stored_buffer_size_l_bytes, dml_uint_t, mode_lib->ms.DETBufferSizeY);
10301 dml_get_per_surface_var_func(det_stored_buffer_size_c_bytes, dml_uint_t, mode_lib->ms.DETBufferSizeC);
10302 dml_get_per_surface_var_func(use_mall_for_static_screen, dml_uint_t, mode_lib->mp.UsesMALLForStaticScreen);
10303 dml_get_per_surface_var_func(surface_size_for_mall, dml_uint_t, mode_lib->mp.SurfaceSizeInTheMALL);
10304 dml_get_per_surface_var_func(dcc_max_uncompressed_block_l, dml_uint_t, mode_lib->mp.DCCYMaxUncompressedBlock);
10305 dml_get_per_surface_var_func(dcc_max_compressed_block_l, dml_uint_t, mode_lib->mp.DCCYMaxCompressedBlock);
10306 dml_get_per_surface_var_func(dcc_independent_block_l, dml_uint_t, mode_lib->mp.DCCYIndependentBlock);
10307 dml_get_per_surface_var_func(dcc_max_uncompressed_block_c, dml_uint_t, mode_lib->mp.DCCCMaxUncompressedBlock);
10308 dml_get_per_surface_var_func(dcc_max_compressed_block_c, dml_uint_t, mode_lib->mp.DCCCMaxCompressedBlock);
10309 dml_get_per_surface_var_func(dcc_independent_block_c, dml_uint_t, mode_lib->mp.DCCCIndependentBlock);
10310 dml_get_per_surface_var_func(max_active_dram_clock_change_latency_supported, dml_uint_t, mode_lib->mp.MaxActiveDRAMClockChangeLatencySupported);
10311 dml_get_per_surface_var_func(pte_buffer_mode, dml_uint_t, mode_lib->mp.PTE_BUFFER_MODE);
10312 dml_get_per_surface_var_func(bigk_fragment_size, dml_uint_t, mode_lib->mp.BIGK_FRAGMENT_SIZE);
10313 dml_get_per_surface_var_func(dpte_bytes_per_row, dml_uint_t, mode_lib->mp.PixelPTEBytesPerRow);
10314 dml_get_per_surface_var_func(meta_bytes_per_row, dml_uint_t, mode_lib->mp.MetaRowByte);
10315 dml_get_per_surface_var_func(det_buffer_size_kbytes, dml_uint_t, mode_lib->ms.DETBufferSizeInKByte);