drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c

   1 /*
   2  * Copyright 2022 Advanced Micro Devices, Inc. All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25
  26 #include "dc.h"
  27 #include "dc_link.h"
  28 #include "../display_mode_lib.h"
  29 #include "display_mode_vba_32.h"
  30 #include "../dml_inline_defs.h"
  31 #include "display_mode_vba_util_32.h"
  32
  33 void dml32_recalculate(struct display_mode_lib *mode_lib);
  34 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
  35                 struct display_mode_lib *mode_lib);
  36 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib);
  37
  38 void dml32_recalculate(struct display_mode_lib *mode_lib)
  39 {
  40         ModeSupportAndSystemConfiguration(mode_lib);
  41
  42         dml32_CalculateMaxDETAndMinCompressedBufferSize(mode_lib->vba.ConfigReturnBufferSizeInKByte,
  43                         mode_lib->vba.ROBBufferSizeInKByte,
  44                         DC__NUM_DPP,
  45                         false, //mode_lib->vba.override_setting.nomDETInKByteOverrideEnable,
  46                         0, //mode_lib->vba.override_setting.nomDETInKByteOverrideValue,
  47
  48                         /* Output */
  49                         &mode_lib->vba.MaxTotalDETInKByte, &mode_lib->vba.nomDETInKByte,
  50                         &mode_lib->vba.MinCompressedBufferSizeInKByte);
  51
  52         PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
  53 #ifdef __DML_VBA_DEBUG__
  54         dml_print("DML::%s: Calling DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation\n", __func__);
  55 #endif
  56         DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
  57 }
  58
  59 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
  60                 struct display_mode_lib *mode_lib)
  61 {
  62         struct vba_vars_st *v = &mode_lib->vba;
  63         unsigned int j, k;
  64         bool ImmediateFlipRequirementFinal;
  65         int iteration;
  66         double MaxTotalRDBandwidth;
  67         unsigned int NextPrefetchMode;
  68         double MaxTotalRDBandwidthNoUrgentBurst = 0.0;
  69         bool DestinationLineTimesForPrefetchLessThan2 = false;
  70         bool VRatioPrefetchMoreThanMax = false;
  71         double TWait;
  72         double TotalWRBandwidth = 0;
  73         double WRBandwidth = 0;
  74
  75 #ifdef __DML_VBA_DEBUG__
  76         dml_print("DML::%s: --- START ---\n", __func__);
  77         dml_print("DML::%s: mode_lib->vba.PrefetchMode = %d\n", __func__, mode_lib->vba.PrefetchMode);
  78         dml_print("DML::%s: mode_lib->vba.ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
  79         dml_print("DML::%s: mode_lib->vba.VoltageLevel = %d\n", __func__, mode_lib->vba.VoltageLevel);
  80 #endif
  81
  82         v->WritebackDISPCLK = 0.0;
  83         v->GlobalDPPCLK = 0.0;
  84
  85         // DISPCLK and DPPCLK Calculation
  86         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
  87                 if (mode_lib->vba.WritebackEnable[k]) {
  88                         v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
  89                                         dml32_CalculateWriteBackDISPCLK(
  90                                                         mode_lib->vba.WritebackPixelFormat[k],
  91                                                         mode_lib->vba.PixelClock[k], mode_lib->vba.WritebackHRatio[k],
  92                                                         mode_lib->vba.WritebackVRatio[k],
  93                                                         mode_lib->vba.WritebackHTaps[k],
  94                                                         mode_lib->vba.WritebackVTaps[k],
  95                                                         mode_lib->vba.WritebackSourceWidth[k],
  96                                                         mode_lib->vba.WritebackDestinationWidth[k],
  97                                                         mode_lib->vba.HTotal[k], mode_lib->vba.WritebackLineBufferSize,
  98                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
  99                 }
 100         }
 101
 102         v->DISPCLK_calculated = v->WritebackDISPCLK;
 103
 104         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 105                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
 106                         v->DISPCLK_calculated = dml_max(v->DISPCLK_calculated,
 107                                         dml32_CalculateRequiredDispclk(
 108                                                         mode_lib->vba.ODMCombineEnabled[k],
 109                                                         mode_lib->vba.PixelClock[k],
 110                                                         mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
 111                                                         mode_lib->vba.DISPCLKRampingMargin,
 112                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
 113                                                         mode_lib->vba.MaxDppclk[v->soc.num_states - 1]));
 114                 }
 115         }
 116
 117         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 118                 dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k],
 119                                 mode_lib->vba.HRatioChroma[k],
 120                                 mode_lib->vba.VRatio[k],
 121                                 mode_lib->vba.VRatioChroma[k],
 122                                 mode_lib->vba.MaxDCHUBToPSCLThroughput,
 123                                 mode_lib->vba.MaxPSCLToLBThroughput,
 124                                 mode_lib->vba.PixelClock[k],
 125                                 mode_lib->vba.SourcePixelFormat[k],
 126                                 mode_lib->vba.htaps[k],
 127                                 mode_lib->vba.HTAPsChroma[k],
 128                                 mode_lib->vba.vtaps[k],
 129                                 mode_lib->vba.VTAPsChroma[k],
 130
 131                                 /* Output */
 132                                 &v->PSCL_THROUGHPUT_LUMA[k], &v->PSCL_THROUGHPUT_CHROMA[k],
 133                                 &v->DPPCLKUsingSingleDPP[k]);
 134         }
 135
 136         dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces, mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
 137                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed, v->DPPCLKUsingSingleDPP, mode_lib->vba.DPPPerPlane,
 138                         /* Output */
 139                         &v->GlobalDPPCLK, v->DPPCLK);
 140
 141         for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
 142                 v->DPPCLK_calculated[k] = v->DPPCLK[k];
 143         }
 144
 145         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 146                 dml32_CalculateBytePerPixelAndBlockSizes(
 147                                 mode_lib->vba.SourcePixelFormat[k],
 148                                 mode_lib->vba.SurfaceTiling[k],
 149
 150                                 /* Output */
 151                                 &v->BytePerPixelY[k],
 152                                 &v->BytePerPixelC[k],
 153                                 &v->BytePerPixelDETY[k],
 154                                 &v->BytePerPixelDETC[k],
 155                                 &v->BlockHeight256BytesY[k],
 156                                 &v->BlockHeight256BytesC[k],
 157                                 &v->BlockWidth256BytesY[k],
 158                                 &v->BlockWidth256BytesC[k],
 159                                 &v->BlockHeightY[k],
 160                                 &v->BlockHeightC[k],
 161                                 &v->BlockWidthY[k],
 162                                 &v->BlockWidthC[k]);
 163         }
 164
 165 #ifdef __DML_VBA_DEBUG__
 166         dml_print("DML::%s: %d\n", __func__, __LINE__);
 167 #endif
 168         dml32_CalculateSwathWidth(
 169                         false,  // ForceSingleDPP
 170                         mode_lib->vba.NumberOfActiveSurfaces,
 171                         mode_lib->vba.SourcePixelFormat,
 172                         mode_lib->vba.SourceRotation,
 173                         mode_lib->vba.ViewportStationary,
 174                         mode_lib->vba.ViewportWidth,
 175                         mode_lib->vba.ViewportHeight,
 176                         mode_lib->vba.ViewportXStartY,
 177                         mode_lib->vba.ViewportYStartY,
 178                         mode_lib->vba.ViewportXStartC,
 179                         mode_lib->vba.ViewportYStartC,
 180                         mode_lib->vba.SurfaceWidthY,
 181                         mode_lib->vba.SurfaceWidthC,
 182                         mode_lib->vba.SurfaceHeightY,
 183                         mode_lib->vba.SurfaceHeightC,
 184                         mode_lib->vba.ODMCombineEnabled,
 185                         v->BytePerPixelY,
 186                         v->BytePerPixelC,
 187                         v->BlockHeight256BytesY,
 188                         v->BlockHeight256BytesC,
 189                         v->BlockWidth256BytesY,
 190                         v->BlockWidth256BytesC,
 191                         mode_lib->vba.BlendingAndTiming,
 192                         mode_lib->vba.HActive,
 193                         mode_lib->vba.HRatio,
 194                         mode_lib->vba.DPPPerPlane,
 195
 196                         /* Output */
 197                         v->SwathWidthSingleDPPY, v->SwathWidthSingleDPPC, v->SwathWidthY, v->SwathWidthC,
 198                         v->dummy_vars
 199                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 200                                 .dummy_integer_array[0], // Integer             MaximumSwathHeightY[]
 201                         v->dummy_vars
 202                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 203                                 .dummy_integer_array[1], // Integer             MaximumSwathHeightC[]
 204                         v->swath_width_luma_ub, v->swath_width_chroma_ub);
 205
 206         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 207                 v->ReadBandwidthSurfaceLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k]
 208                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
 209                 v->ReadBandwidthSurfaceChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k]
 210                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
 211                                 * mode_lib->vba.VRatioChroma[k];
 212 #ifdef __DML_VBA_DEBUG__
 213                 dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n",
 214                                 __func__, k, v->ReadBandwidthSurfaceLuma[k]);
 215                 dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n",
 216                                 __func__, k, v->ReadBandwidthSurfaceChroma[k]);
 217 #endif
 218         }
 219
 220         {
 221                 // VBA_DELTA
 222                 // Calculate DET size, swath height
 223                 dml32_CalculateSwathAndDETConfiguration(
 224                                 mode_lib->vba.DETSizeOverride,
 225                                 mode_lib->vba.UsesMALLForPStateChange,
 226                                 mode_lib->vba.ConfigReturnBufferSizeInKByte,
 227                                 mode_lib->vba.MaxTotalDETInKByte,
 228                                 mode_lib->vba.MinCompressedBufferSizeInKByte,
 229                                 false, /* ForceSingleDPP */
 230                                 mode_lib->vba.NumberOfActiveSurfaces,
 231                                 mode_lib->vba.nomDETInKByte,
 232                                 mode_lib->vba.UseUnboundedRequesting,
 233                                 mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
 234                                 mode_lib->vba.ip.pixel_chunk_size_kbytes,
 235                                 mode_lib->vba.ip.rob_buffer_size_kbytes,
 236                                 mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
 237                                 v->dummy_vars
 238                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 239                                         .dummy_output_encoder_array, /* output_encoder_class Output[] */
 240                                 v->ReadBandwidthSurfaceLuma,
 241                                 v->ReadBandwidthSurfaceChroma,
 242                                 v->dummy_vars
 243                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 244                                         .dummy_single_array[0], /* Single MaximumSwathWidthLuma[] */
 245                                 v->dummy_vars
 246                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 247                                         .dummy_single_array[1], /* Single MaximumSwathWidthChroma[] */
 248                                 mode_lib->vba.SourceRotation,
 249                                 mode_lib->vba.ViewportStationary,
 250                                 mode_lib->vba.SourcePixelFormat,
 251                                 mode_lib->vba.SurfaceTiling,
 252                                 mode_lib->vba.ViewportWidth,
 253                                 mode_lib->vba.ViewportHeight,
 254                                 mode_lib->vba.ViewportXStartY,
 255                                 mode_lib->vba.ViewportYStartY,
 256                                 mode_lib->vba.ViewportXStartC,
 257                                 mode_lib->vba.ViewportYStartC,
 258                                 mode_lib->vba.SurfaceWidthY,
 259                                 mode_lib->vba.SurfaceWidthC,
 260                                 mode_lib->vba.SurfaceHeightY,
 261                                 mode_lib->vba.SurfaceHeightC,
 262                                 v->BlockHeight256BytesY,
 263                                 v->BlockHeight256BytesC,
 264                                 v->BlockWidth256BytesY,
 265                                 v->BlockWidth256BytesC,
 266                                 mode_lib->vba.ODMCombineEnabled,
 267                                 mode_lib->vba.BlendingAndTiming,
 268                                 v->BytePerPixelY,
 269                                 v->BytePerPixelC,
 270                                 v->BytePerPixelDETY,
 271                                 v->BytePerPixelDETC,
 272                                 mode_lib->vba.HActive,
 273                                 mode_lib->vba.HRatio,
 274                                 mode_lib->vba.HRatioChroma,
 275                                 mode_lib->vba.DPPPerPlane,
 276
 277                                 /* Output */
 278                                 v->dummy_vars
 279                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 280                                         .dummy_long_array[0], /* Long swath_width_luma_ub[] */
 281                                 v->dummy_vars
 282                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 283                                         .dummy_long_array[1], /* Long swath_width_chroma_ub[] */
 284                                 v->dummy_vars
 285                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 286                                         .dummy_double_array[0], /* Long SwathWidth[] */
 287                                 v->dummy_vars
 288                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 289                                         .dummy_double_array[1], /* Long SwathWidthChroma[] */
 290                                 mode_lib->vba.SwathHeightY,
 291                                 mode_lib->vba.SwathHeightC,
 292                                 mode_lib->vba.DETBufferSizeInKByte,
 293                                 mode_lib->vba.DETBufferSizeY,
 294                                 mode_lib->vba.DETBufferSizeC,
 295                                 &v->UnboundedRequestEnabled,
 296                                 &v->CompressedBufferSizeInkByte,
 297                                 &v->CompBufReservedSpaceKBytes,
 298                                 &v->dummy_vars
 299                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 300                                         .dummy_boolean,       /* bool *CompBufReservedSpaceNeedAjustment */
 301                                 v->dummy_vars
 302                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 303                                         .dummy_boolean_array, /* bool ViewportSizeSupportPerSurface[] */
 304                                 &v->dummy_vars
 305                                          .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 306                                          .dummy_boolean); /* bool *ViewportSizeSupport */
 307         }
 308
 309         v->CompBufReservedSpaceZs     = v->CompBufReservedSpaceKBytes * 1024.0 / 256.0;
 310         v->CompBufReservedSpace64B    = v->CompBufReservedSpaceKBytes * 1024.0 / 64.0;
 311
 312         // DCFCLK Deep Sleep
 313         dml32_CalculateDCFCLKDeepSleep(
 314                         mode_lib->vba.NumberOfActiveSurfaces,
 315                         v->BytePerPixelY,
 316                         v->BytePerPixelC,
 317                         mode_lib->vba.VRatio,
 318                         mode_lib->vba.VRatioChroma,
 319                         v->SwathWidthY,
 320                         v->SwathWidthC,
 321                         mode_lib->vba.DPPPerPlane,
 322                         mode_lib->vba.HRatio,
 323                         mode_lib->vba.HRatioChroma,
 324                         mode_lib->vba.PixelClock,
 325                         v->PSCL_THROUGHPUT_LUMA,
 326                         v->PSCL_THROUGHPUT_CHROMA,
 327                         mode_lib->vba.DPPCLK,
 328                         v->ReadBandwidthSurfaceLuma,
 329                         v->ReadBandwidthSurfaceChroma,
 330                         mode_lib->vba.ReturnBusWidth,
 331
 332                         /* Output */
 333                         &v->DCFCLKDeepSleep);
 334
 335         // DSCCLK
 336         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 337                 if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
 338                         v->DSCCLK_calculated[k] = 0.0;
 339                 } else {
 340                         if (mode_lib->vba.OutputFormat[k] == dm_420)
 341                                 mode_lib->vba.DSCFormatFactor = 2;
 342                         else if (mode_lib->vba.OutputFormat[k] == dm_444)
 343                                 mode_lib->vba.DSCFormatFactor = 1;
 344                         else if (mode_lib->vba.OutputFormat[k] == dm_n422)
 345                                 mode_lib->vba.DSCFormatFactor = 2;
 346                         else
 347                                 mode_lib->vba.DSCFormatFactor = 1;
 348                         if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
 349                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 12
 350                                                 / mode_lib->vba.DSCFormatFactor
 351                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 352                         else if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
 353                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 6
 354                                                 / mode_lib->vba.DSCFormatFactor
 355                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 356                         else
 357                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 3
 358                                                 / mode_lib->vba.DSCFormatFactor
 359                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 360                 }
 361         }
 362
 363         // DSC Delay
 364         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 365                 v->DSCDelay[k] = dml32_DSCDelayRequirement(mode_lib->vba.DSCEnabled[k],
 366                                 mode_lib->vba.ODMCombineEnabled[k], mode_lib->vba.DSCInputBitPerComponent[k],
 367                                 mode_lib->vba.OutputBpp[k], mode_lib->vba.HActive[k], mode_lib->vba.HTotal[k],
 368                                 mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.OutputFormat[k],
 369                                 mode_lib->vba.Output[k], mode_lib->vba.PixelClock[k],
 370                                 mode_lib->vba.PixelClockBackEnd[k]);
 371         }
 372
 373         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 374                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) // NumberOfSurfaces
 375                         if (j != k && mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.DSCEnabled[j])
 376                                 v->DSCDelay[k] = v->DSCDelay[j];
 377
 378         //Immediate Flip
 379         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 380                 v->ImmediateFlipSupportedSurface[k] = mode_lib->vba.ImmediateFlipSupport
 381                                 && (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required);
 382         }
 383
 384         // Prefetch
 385         dml32_CalculateSurfaceSizeInMall(
 386                                 mode_lib->vba.NumberOfActiveSurfaces,
 387                                 mode_lib->vba.MALLAllocatedForDCNFinal,
 388                                 mode_lib->vba.UseMALLForStaticScreen,
 389                                 mode_lib->vba.DCCEnable,
 390                                 mode_lib->vba.ViewportStationary,
 391                                 mode_lib->vba.ViewportXStartY,
 392                                 mode_lib->vba.ViewportYStartY,
 393                                 mode_lib->vba.ViewportXStartC,
 394                                 mode_lib->vba.ViewportYStartC,
 395                                 mode_lib->vba.ViewportWidth,
 396                                 mode_lib->vba.ViewportHeight,
 397                                 v->BytePerPixelY,
 398                                 mode_lib->vba.ViewportWidthChroma,
 399                                 mode_lib->vba.ViewportHeightChroma,
 400                                 v->BytePerPixelC,
 401                                 mode_lib->vba.SurfaceWidthY,
 402                                 mode_lib->vba.SurfaceWidthC,
 403                                 mode_lib->vba.SurfaceHeightY,
 404                                 mode_lib->vba.SurfaceHeightC,
 405                                 v->BlockWidth256BytesY,
 406                                 v->BlockWidth256BytesC,
 407                                 v->BlockHeight256BytesY,
 408                                 v->BlockHeight256BytesC,
 409                                 v->BlockWidthY,
 410                                 v->BlockWidthC,
 411                                 v->BlockHeightY,
 412                                 v->BlockHeightC,
 413
 414                                 /* Output */
 415                                 v->SurfaceSizeInMALL,
 416                                 &v->dummy_vars.
 417                                 DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 418                                 .dummy_boolean2); /* Boolean *ExceededMALLSize */
 419
 420         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 421                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
 422                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
 423                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
 424                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
 425                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
 426                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesY = v->BlockWidth256BytesY[k];
 427                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesY = v->BlockHeight256BytesY[k];
 428                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesC = v->BlockWidth256BytesC[k];
 429                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesC = v->BlockHeight256BytesC[k];
 430                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthY = v->BlockWidthY[k];
 431                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightY = v->BlockHeightY[k];
 432                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthC = v->BlockWidthC[k];
 433                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightC = v->BlockHeightC[k];
 434                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
 435                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].HTotal = mode_lib->vba.HTotal[k];
 436                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
 437                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
 438                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
 439                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelY = v->BytePerPixelY[k];
 440                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelC = v->BytePerPixelC[k];
 441                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
 442                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatio = mode_lib->vba.VRatio[k];
 443                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
 444                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTaps = mode_lib->vba.vtaps[k];
 445                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
 446                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchY = mode_lib->vba.PitchY[k];
 447                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
 448                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchC = mode_lib->vba.PitchC[k];
 449                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
 450                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
 451                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
 452                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
 453                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
 454                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
 455                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
 456                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightY = mode_lib->vba.SwathHeightY[k];
 457                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightC = mode_lib->vba.SwathHeightC[k];
 458         }
 459
 460         {
 461
 462                 dml32_CalculateVMRowAndSwath(
 463                                 mode_lib->vba.NumberOfActiveSurfaces,
 464                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters,
 465                                 v->SurfaceSizeInMALL,
 466                                 mode_lib->vba.PTEBufferSizeInRequestsLuma,
 467                                 mode_lib->vba.PTEBufferSizeInRequestsChroma,
 468                                 mode_lib->vba.DCCMetaBufferSizeBytes,
 469                                 mode_lib->vba.UseMALLForStaticScreen,
 470                                 mode_lib->vba.UsesMALLForPStateChange,
 471                                 mode_lib->vba.MALLAllocatedForDCNFinal,
 472                                 v->SwathWidthY,
 473                                 v->SwathWidthC,
 474                                 mode_lib->vba.GPUVMEnable,
 475                                 mode_lib->vba.HostVMEnable,
 476                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
 477                                 mode_lib->vba.GPUVMMaxPageTableLevels,
 478                                 mode_lib->vba.GPUVMMinPageSizeKBytes,
 479                                 mode_lib->vba.HostVMMinPageSize,
 480
 481                                 /* Output */
 482                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[0],  // Boolean PTEBufferSizeNotExceeded[]
 483                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[1],  // Boolean DCCMetaBufferSizeNotExceeded[]
 484                                 v->dpte_row_width_luma_ub,
 485                                 v->dpte_row_width_chroma_ub,
 486                                 v->dpte_row_height,
 487                                 v->dpte_row_height_chroma,
 488                                 v->dpte_row_height_linear,
 489                                 v->dpte_row_height_linear_chroma,
 490                                 v->meta_req_width,
 491                                 v->meta_req_width_chroma,
 492                                 v->meta_req_height,
 493                                 v->meta_req_height_chroma,
 494                                 v->meta_row_width,
 495                                 v->meta_row_width_chroma,
 496                                 v->meta_row_height,
 497                                 v->meta_row_height_chroma,
 498                                 v->vm_group_bytes,
 499                                 v->dpte_group_bytes,
 500                                 v->PixelPTEReqWidthY,
 501                                 v->PixelPTEReqHeightY,
 502                                 v->PTERequestSizeY,
 503                                 v->PixelPTEReqWidthC,
 504                                 v->PixelPTEReqHeightC,
 505                                 v->PTERequestSizeC,
 506                                 v->dpde0_bytes_per_frame_ub_l,
 507                                 v->meta_pte_bytes_per_frame_ub_l,
 508                                 v->dpde0_bytes_per_frame_ub_c,
 509                                 v->meta_pte_bytes_per_frame_ub_c,
 510                                 v->PrefetchSourceLinesY,
 511                                 v->PrefetchSourceLinesC,
 512                                 v->VInitPreFillY, v->VInitPreFillC,
 513                                 v->MaxNumSwathY,
 514                                 v->MaxNumSwathC,
 515                                 v->meta_row_bw,
 516                                 v->dpte_row_bw,
 517                                 v->PixelPTEBytesPerRow,
 518                                 v->PDEAndMetaPTEBytesFrame,
 519                                 v->MetaRowByte,
 520                                 v->Use_One_Row_For_Frame,
 521                                 v->Use_One_Row_For_Frame_Flip,
 522                                 v->UsesMALLForStaticScreen,
 523                                 v->PTE_BUFFER_MODE,
 524                                 v->BIGK_FRAGMENT_SIZE);
 525         }
 526
 527
 528         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes = mode_lib->vba.NumberOfChannels
 529                         * dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
 530                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
 531                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
 532
 533         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.VMDataOnlyReturnBW = dml32_get_return_bw_mbps_vm_only(
 534                         &mode_lib->vba.soc,
 535                         mode_lib->vba.VoltageLevel,
 536                         mode_lib->vba.DCFCLK,
 537                         mode_lib->vba.FabricClock,
 538                         mode_lib->vba.DRAMSpeed);
 539
 540 #ifdef __DML_VBA_DEBUG__
 541         dml_print("DML::%s: mode_lib->vba.ReturnBusWidth = %f\n", __func__, mode_lib->vba.ReturnBusWidth);
 542         dml_print("DML::%s: mode_lib->vba.DCFCLK = %f\n", __func__, mode_lib->vba.DCFCLK);
 543         dml_print("DML::%s: mode_lib->vba.FabricClock = %f\n", __func__, mode_lib->vba.FabricClock);
 544         dml_print("DML::%s: mode_lib->vba.FabricDatapathToDCNDataReturn = %f\n", __func__,
 545                         mode_lib->vba.FabricDatapathToDCNDataReturn);
 546         dml_print("DML::%s: mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency = %f\n",
 547                         __func__, mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency);
 548         dml_print("DML::%s: mode_lib->vba.DRAMSpeed = %f\n", __func__, mode_lib->vba.DRAMSpeed);
 549         dml_print("DML::%s: mode_lib->vba.NumberOfChannels = %f\n", __func__, mode_lib->vba.NumberOfChannels);
 550         dml_print("DML::%s: mode_lib->vba.DRAMChannelWidth = %f\n", __func__, mode_lib->vba.DRAMChannelWidth);
 551         dml_print("DML::%s: mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly = %f\n",
 552                         __func__, mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly);
 553         dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
 554         dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->vba.ReturnBW);
 555 #endif
 556
 557         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor = 1.0;
 558
 559         if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
 560                 v->dummy_vars
 561                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 562                         .HostVMInefficiencyFactor =
 563                         mode_lib->vba.ReturnBW / v->dummy_vars
 564                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 565                                 .VMDataOnlyReturnBW;
 566
 567         mode_lib->vba.TotalDCCActiveDPP = 0;
 568         mode_lib->vba.TotalActiveDPP = 0;
 569         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 570                 mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + mode_lib->vba.DPPPerPlane[k];
 571                 if (mode_lib->vba.DCCEnable[k])
 572                         mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP
 573                                         + mode_lib->vba.DPPPerPlane[k];
 574         }
 575
 576         v->UrgentExtraLatency = dml32_CalculateExtraLatency(
 577                         mode_lib->vba.RoundTripPingLatencyCycles,
 578                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes,
 579                         mode_lib->vba.DCFCLK,
 580                         mode_lib->vba.TotalActiveDPP,
 581                         mode_lib->vba.PixelChunkSizeInKByte,
 582                         mode_lib->vba.TotalDCCActiveDPP,
 583                         mode_lib->vba.MetaChunkSize,
 584                         mode_lib->vba.ReturnBW,
 585                         mode_lib->vba.GPUVMEnable,
 586                         mode_lib->vba.HostVMEnable,
 587                         mode_lib->vba.NumberOfActiveSurfaces,
 588                         mode_lib->vba.DPPPerPlane,
 589                         v->dpte_group_bytes,
 590                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
 591                         mode_lib->vba.HostVMMinPageSize,
 592                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
 593
 594         mode_lib->vba.TCalc = 24.0 / v->DCFCLKDeepSleep;
 595
 596         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 597                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
 598                         if (mode_lib->vba.WritebackEnable[k] == true) {
 599                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = mode_lib->vba.WritebackLatency
 600                                                 + dml32_CalculateWriteBackDelay(
 601                                                                 mode_lib->vba.WritebackPixelFormat[k],
 602                                                                 mode_lib->vba.WritebackHRatio[k],
 603                                                                 mode_lib->vba.WritebackVRatio[k],
 604                                                                 mode_lib->vba.WritebackVTaps[k],
 605                                                                 mode_lib->vba.WritebackDestinationWidth[k],
 606                                                                 mode_lib->vba.WritebackDestinationHeight[k],
 607                                                                 mode_lib->vba.WritebackSourceHeight[k],
 608                                                                 mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK;
 609                         } else
 610                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
 611                         for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
 612                                 if (mode_lib->vba.BlendingAndTiming[j] == k &&
 613                                         mode_lib->vba.WritebackEnable[j] == true) {
 614                                         v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
 615                                                 dml_max(v->WritebackDelay[mode_lib->vba.VoltageLevel][k],
 616                                                 mode_lib->vba.WritebackLatency +
 617                                                 dml32_CalculateWriteBackDelay(
 618                                                                 mode_lib->vba.WritebackPixelFormat[j],
 619                                                                 mode_lib->vba.WritebackHRatio[j],
 620                                                                 mode_lib->vba.WritebackVRatio[j],
 621                                                                 mode_lib->vba.WritebackVTaps[j],
 622                                                                 mode_lib->vba.WritebackDestinationWidth[j],
 623                                                                 mode_lib->vba.WritebackDestinationHeight[j],
 624                                                                 mode_lib->vba.WritebackSourceHeight[j],
 625                                                                 mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK);
 626                                 }
 627                         }
 628                 }
 629         }
 630
 631         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 632                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j)
 633                         if (mode_lib->vba.BlendingAndTiming[k] == j)
 634                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
 635                                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][j];
 636
 637         v->UrgentLatency = dml32_CalculateUrgentLatency(mode_lib->vba.UrgentLatencyPixelDataOnly,
 638                         mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
 639                         mode_lib->vba.UrgentLatencyVMDataOnly,
 640                         mode_lib->vba.DoUrgentLatencyAdjustment,
 641                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
 642                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
 643                         mode_lib->vba.FabricClock);
 644
 645         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 646                 dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
 647                                 v->swath_width_luma_ub[k],
 648                                 v->swath_width_chroma_ub[k],
 649                                 mode_lib->vba.SwathHeightY[k],
 650                                 mode_lib->vba.SwathHeightC[k],
 651                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
 652                                 v->UrgentLatency,
 653                                 mode_lib->vba.CursorBufferSize,
 654                                 mode_lib->vba.CursorWidth[k][0],
 655                                 mode_lib->vba.CursorBPP[k][0],
 656                                 mode_lib->vba.VRatio[k],
 657                                 mode_lib->vba.VRatioChroma[k],
 658                                 v->BytePerPixelDETY[k],
 659                                 v->BytePerPixelDETC[k],
 660                                 mode_lib->vba.DETBufferSizeY[k],
 661                                 mode_lib->vba.DETBufferSizeC[k],
 662
 663                                 /* output */
 664                                 &v->UrgBurstFactorCursor[k],
 665                                 &v->UrgBurstFactorLuma[k],
 666                                 &v->UrgBurstFactorChroma[k],
 667                                 &v->NoUrgentLatencyHiding[k]);
 668
 669                 v->cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] / 8 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
 670         }
 671
 672         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 673                 v->MaxVStartupLines[k] = ((mode_lib->vba.Interlace[k] &&
 674                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
 675                                 dml_floor((mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) / 2.0, 1.0) :
 676                                 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) - dml_max(1.0,
 677                                 dml_ceil((double) v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
 678                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1));
 679
 680                 // Clamp to max OTG vstartup register limit
 681                 if (v->MaxVStartupLines[k] > 1023)
 682                         v->MaxVStartupLines[k] = 1023;
 683
 684 #ifdef __DML_VBA_DEBUG__
 685                 dml_print("DML::%s: k=%d MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
 686                 dml_print("DML::%s: k=%d VoltageLevel = %d\n", __func__, k, mode_lib->vba.VoltageLevel);
 687                 dml_print("DML::%s: k=%d WritebackDelay = %f\n", __func__,
 688                                 k, v->WritebackDelay[mode_lib->vba.VoltageLevel][k]);
 689 #endif
 690         }
 691
 692         v->MaximumMaxVStartupLines = 0;
 693         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 694                 v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);
 695
 696         ImmediateFlipRequirementFinal = false;
 697
 698         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 699                 ImmediateFlipRequirementFinal = ImmediateFlipRequirementFinal
 700                                 || (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
 701         }
 702 #ifdef __DML_VBA_DEBUG__
 703         dml_print("DML::%s: ImmediateFlipRequirementFinal = %d\n", __func__, ImmediateFlipRequirementFinal);
 704 #endif
 705         // ModeProgramming will not repeat the schedule calculation using different prefetch mode,
 706         //it is just calcualated once with given prefetch mode
 707         dml32_CalculateMinAndMaxPrefetchMode(
 708                         mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
 709                         &mode_lib->vba.MinPrefetchMode,
 710                         &mode_lib->vba.MaxPrefetchMode);
 711
 712         v->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
 713
 714         iteration = 0;
 715         MaxTotalRDBandwidth = 0;
 716         NextPrefetchMode = mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb];
 717
 718         do {
 719                 MaxTotalRDBandwidth = 0;
 720 #ifdef __DML_VBA_DEBUG__
 721                 dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);
 722 #endif
 723                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 724                         /* NOTE PerfetchMode variable is invalid in DAL as per the input received.
 725                          * Hence the direction is to use PrefetchModePerState.
 726                          */
 727                         TWait = dml32_CalculateTWait(
 728                                 mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
 729                                 mode_lib->vba.UsesMALLForPStateChange[k],
 730                                 mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
 731                                 mode_lib->vba.DRRDisplay[k],
 732                                 mode_lib->vba.DRAMClockChangeLatency,
 733                                 mode_lib->vba.FCLKChangeLatency, v->UrgentLatency,
 734                                 mode_lib->vba.SREnterPlusExitTime);
 735
 736                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dppclk = mode_lib->vba.DPPCLK[k];
 737                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dispclk = mode_lib->vba.DISPCLK;
 738                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
 739                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCFClkDeepSleep = v->DCFCLKDeepSleep;
 740                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
 741                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
 742                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
 743                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
 744                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
 745                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
 746                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
 747                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
 748                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
 749                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
 750                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HTotal = mode_lib->vba.HTotal[k];
 751                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HActive = mode_lib->vba.HActive[k];
 752                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
 753                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ODMMode = mode_lib->vba.ODMCombineEnabled[k];
 754                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
 755                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelY = v->BytePerPixelY[k];
 756                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelC = v->BytePerPixelC[k];
 757                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
 758                         v->ErrorResult[k] = dml32_CalculatePrefetchSchedule(
 759                                         v,
 760                                         k,
 761                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
 762                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe,
 763                                         v->DSCDelay[k],
 764                                         (unsigned int) (v->SwathWidthY[k] / v->HRatio[k]),
 765                                         dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
 766                                         v->MaxVStartupLines[k],
 767                                         v->UrgentLatency,
 768                                         v->UrgentExtraLatency,
 769                                         v->TCalc,
 770                                         v->PDEAndMetaPTEBytesFrame[k],
 771                                         v->MetaRowByte[k],
 772                                         v->PixelPTEBytesPerRow[k],
 773                                         v->PrefetchSourceLinesY[k],
 774                                         v->SwathWidthY[k],
 775                                         v->VInitPreFillY[k],
 776                                         v->MaxNumSwathY[k],
 777                                         v->PrefetchSourceLinesC[k],
 778                                         v->SwathWidthC[k],
 779                                         v->VInitPreFillC[k],
 780                                         v->MaxNumSwathC[k],
 781                                         v->swath_width_luma_ub[k],
 782                                         v->swath_width_chroma_ub[k],
 783                                         v->SwathHeightY[k],
 784                                         v->SwathHeightC[k],
 785                                         TWait,
 786                                         /* Output */
 787                                         &v->DSTXAfterScaler[k],
 788                                         &v->DSTYAfterScaler[k],
 789                                         &v->DestinationLinesForPrefetch[k],
 790                                         &v->PrefetchBandwidth[k],
 791                                         &v->DestinationLinesToRequestVMInVBlank[k],
 792                                         &v->DestinationLinesToRequestRowInVBlank[k],
 793                                         &v->VRatioPrefetchY[k],
 794                                         &v->VRatioPrefetchC[k],
 795                                         &v->RequiredPrefetchPixDataBWLuma[k],
 796                                         &v->RequiredPrefetchPixDataBWChroma[k],
 797                                         &v->NotEnoughTimeForDynamicMetadata[k],
 798                                         &v->Tno_bw[k], &v->prefetch_vmrow_bw[k],
 799                                         &v->Tdmdl_vm[k],
 800                                         &v->Tdmdl[k],
 801                                         &v->TSetup[k],
 802                                         &v->VUpdateOffsetPix[k],
 803                                         &v->VUpdateWidthPix[k],
 804                                         &v->VReadyOffsetPix[k]);
 805
 806 #ifdef __DML_VBA_DEBUG__
 807                         dml_print("DML::%s: k=%0d Prefetch calculation errResult=%0d\n",
 808                                         __func__, k, mode_lib->vba.ErrorResult[k]);
 809 #endif
 810                         v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
 811                 }
 812
 813                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 814                         dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
 815                                         v->swath_width_luma_ub[k],
 816                                         v->swath_width_chroma_ub[k],
 817                                         mode_lib->vba.SwathHeightY[k],
 818                                         mode_lib->vba.SwathHeightC[k],
 819                                         mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
 820                                         v->UrgentLatency,
 821                                         mode_lib->vba.CursorBufferSize,
 822                                         mode_lib->vba.CursorWidth[k][0],
 823                                         mode_lib->vba.CursorBPP[k][0],
 824                                         v->VRatioPrefetchY[k],
 825                                         v->VRatioPrefetchC[k],
 826                                         v->BytePerPixelDETY[k],
 827                                         v->BytePerPixelDETC[k],
 828                                         mode_lib->vba.DETBufferSizeY[k],
 829                                         mode_lib->vba.DETBufferSizeC[k],
 830                                         /* Output */
 831                                         &v->UrgBurstFactorCursorPre[k],
 832                                         &v->UrgBurstFactorLumaPre[k],
 833                                         &v->UrgBurstFactorChromaPre[k],
 834                                         &v->NoUrgentLatencyHidingPre[k]);
 835
 836                         v->cursor_bw_pre[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] /
 837                                         8.0 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * v->VRatioPrefetchY[k];
 838
 839 #ifdef __DML_VBA_DEBUG__
 840                         dml_print("DML::%s: k=%0d DPPPerSurface=%d\n", __func__, k, mode_lib->vba.DPPPerPlane[k]);
 841                         dml_print("DML::%s: k=%0d UrgBurstFactorLuma=%f\n", __func__, k, v->UrgBurstFactorLuma[k]);
 842                         dml_print("DML::%s: k=%0d UrgBurstFactorChroma=%f\n", __func__, k, v->UrgBurstFactorChroma[k]);
 843                         dml_print("DML::%s: k=%0d UrgBurstFactorLumaPre=%f\n", __func__, k,
 844                                         v->UrgBurstFactorLumaPre[k]);
 845                         dml_print("DML::%s: k=%0d UrgBurstFactorChromaPre=%f\n", __func__, k,
 846                                         v->UrgBurstFactorChromaPre[k]);
 847
 848                         dml_print("DML::%s: k=%0d VRatioPrefetchY=%f\n", __func__, k, v->VRatioPrefetchY[k]);
 849                         dml_print("DML::%s: k=%0d VRatioY=%f\n", __func__, k, mode_lib->vba.VRatio[k]);
 850
 851                         dml_print("DML::%s: k=%0d prefetch_vmrow_bw=%f\n", __func__, k, v->prefetch_vmrow_bw[k]);
 852                         dml_print("DML::%s: k=%0d ReadBandwidthSurfaceLuma=%f\n", __func__, k,
 853                                         v->ReadBandwidthSurfaceLuma[k]);
 854                         dml_print("DML::%s: k=%0d ReadBandwidthSurfaceChroma=%f\n", __func__, k,
 855                                         v->ReadBandwidthSurfaceChroma[k]);
 856                         dml_print("DML::%s: k=%0d cursor_bw=%f\n", __func__, k, v->cursor_bw[k]);
 857                         dml_print("DML::%s: k=%0d meta_row_bw=%f\n", __func__, k, v->meta_row_bw[k]);
 858                         dml_print("DML::%s: k=%0d dpte_row_bw=%f\n", __func__, k, v->dpte_row_bw[k]);
 859                         dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWLuma=%f\n", __func__, k,
 860                                         v->RequiredPrefetchPixDataBWLuma[k]);
 861                         dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWChroma=%f\n", __func__, k,
 862                                         v->RequiredPrefetchPixDataBWChroma[k]);
 863                         dml_print("DML::%s: k=%0d cursor_bw_pre=%f\n", __func__, k, v->cursor_bw_pre[k]);
 864                         dml_print("DML::%s: k=%0d MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k,
 865                                         MaxTotalRDBandwidthNoUrgentBurst);
 866 #endif
 867                         if (v->DestinationLinesForPrefetch[k] < 2)
 868                                 DestinationLineTimesForPrefetchLessThan2 = true;
 869
 870                         if (v->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE__
 871                                         || v->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE__)
 872                                 VRatioPrefetchMoreThanMax = true;
 873
 874                         //bool DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
 875                         //bool DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
 876                         //if (v->DestinationLinesToRequestVMInVBlank[k] >= 32) {
 877                         //    DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
 878                         //}
 879
 880                         //if (v->DestinationLinesToRequestRowInVBlank[k] >= 16) {
 881                         //    DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
 882                         //}
 883                 }
 884
 885                 v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / mode_lib->vba.ReturnBW;
 886
 887 #ifdef __DML_VBA_DEBUG__
 888                 dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f\n",
 889                                 __func__, MaxTotalRDBandwidthNoUrgentBurst);
 890                 dml_print("DML::%s: ReturnBW=%f\n", __func__, mode_lib->vba.ReturnBW);
 891                 dml_print("DML::%s: FractionOfUrgentBandwidth=%f\n",
 892                                 __func__, mode_lib->vba.FractionOfUrgentBandwidth);
 893 #endif
 894
 895                 {
 896                         dml32_CalculatePrefetchBandwithSupport(
 897                                         mode_lib->vba.NumberOfActiveSurfaces,
 898                                         mode_lib->vba.ReturnBW,
 899                                         v->NoUrgentLatencyHidingPre,
 900                                         v->ReadBandwidthSurfaceLuma,
 901                                         v->ReadBandwidthSurfaceChroma,
 902                                         v->RequiredPrefetchPixDataBWLuma,
 903                                         v->RequiredPrefetchPixDataBWChroma,
 904                                         v->cursor_bw,
 905                                         v->meta_row_bw,
 906                                         v->dpte_row_bw,
 907                                         v->cursor_bw_pre,
 908                                         v->prefetch_vmrow_bw,
 909                                         mode_lib->vba.DPPPerPlane,
 910                                         v->UrgBurstFactorLuma,
 911                                         v->UrgBurstFactorChroma,
 912                                         v->UrgBurstFactorCursor,
 913                                         v->UrgBurstFactorLumaPre,
 914                                         v->UrgBurstFactorChromaPre,
 915                                         v->UrgBurstFactorCursorPre,
 916
 917                                         /* output */
 918                                         &MaxTotalRDBandwidth,
 919                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
 920                                         &v->PrefetchModeSupported);
 921                 }
 922
 923                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 924                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector[k] = 1.0;
 925
 926                 {
 927                         dml32_CalculatePrefetchBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
 928                                         mode_lib->vba.ReturnBW,
 929                                         v->NoUrgentLatencyHidingPre,
 930                                         v->ReadBandwidthSurfaceLuma,
 931                                         v->ReadBandwidthSurfaceChroma,
 932                                         v->RequiredPrefetchPixDataBWLuma,
 933                                         v->RequiredPrefetchPixDataBWChroma,
 934                                         v->cursor_bw,
 935                                         v->meta_row_bw,
 936                                         v->dpte_row_bw,
 937                                         v->cursor_bw_pre,
 938                                         v->prefetch_vmrow_bw,
 939                                         mode_lib->vba.DPPPerPlane,
 940                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 941                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 942                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 943                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 944                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 945                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 946
 947                                         /* output */
 948                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
 949                                         &v->FractionOfUrgentBandwidth,
 950                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
 951                 }
 952
 953                 if (VRatioPrefetchMoreThanMax != false || DestinationLineTimesForPrefetchLessThan2 != false) {
 954                         v->PrefetchModeSupported = false;
 955                 }
 956
 957                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 958                         if (v->ErrorResult[k] == true || v->NotEnoughTimeForDynamicMetadata[k]) {
 959                                 v->PrefetchModeSupported = false;
 960                         }
 961                 }
 962
 963                 if (v->PrefetchModeSupported == true && mode_lib->vba.ImmediateFlipSupport == true) {
 964                         mode_lib->vba.BandwidthAvailableForImmediateFlip = dml32_CalculateBandwidthAvailableForImmediateFlip(
 965                                         mode_lib->vba.NumberOfActiveSurfaces,
 966                                         mode_lib->vba.ReturnBW,
 967                                         v->ReadBandwidthSurfaceLuma,
 968                                         v->ReadBandwidthSurfaceChroma,
 969                                         v->RequiredPrefetchPixDataBWLuma,
 970                                         v->RequiredPrefetchPixDataBWChroma,
 971                                         v->cursor_bw,
 972                                         v->cursor_bw_pre,
 973                                         mode_lib->vba.DPPPerPlane,
 974                                         v->UrgBurstFactorLuma,
 975                                         v->UrgBurstFactorChroma,
 976                                         v->UrgBurstFactorCursor,
 977                                         v->UrgBurstFactorLumaPre,
 978                                         v->UrgBurstFactorChromaPre,
 979                                         v->UrgBurstFactorCursorPre);
 980
 981                         mode_lib->vba.TotImmediateFlipBytes = 0;
 982                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 983                                 if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) {
 984                                         mode_lib->vba.TotImmediateFlipBytes = mode_lib->vba.TotImmediateFlipBytes
 985                                                         + mode_lib->vba.DPPPerPlane[k]
 986                                                                         * (v->PDEAndMetaPTEBytesFrame[k]
 987                                                                                         + v->MetaRowByte[k]);
 988                                         if (v->use_one_row_for_frame_flip[k][0][0]) {
 989                                                 mode_lib->vba.TotImmediateFlipBytes =
 990                                                                 mode_lib->vba.TotImmediateFlipBytes
 991                                                                                 + 2 * v->PixelPTEBytesPerRow[k];
 992                                         } else {
 993                                                 mode_lib->vba.TotImmediateFlipBytes =
 994                                                                 mode_lib->vba.TotImmediateFlipBytes
 995                                                                                 + v->PixelPTEBytesPerRow[k];
 996                                         }
 997                                 }
 998                         }
 999                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1000                                 dml32_CalculateFlipSchedule(v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
1001                                                 v->UrgentExtraLatency,
1002                                                 v->UrgentLatency,
1003                                                 mode_lib->vba.GPUVMMaxPageTableLevels,
1004                                                 mode_lib->vba.HostVMEnable,
1005                                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
1006                                                 mode_lib->vba.GPUVMEnable,
1007                                                 mode_lib->vba.HostVMMinPageSize,
1008                                                 v->PDEAndMetaPTEBytesFrame[k],
1009                                                 v->MetaRowByte[k],
1010                                                 v->PixelPTEBytesPerRow[k],
1011                                                 mode_lib->vba.BandwidthAvailableForImmediateFlip,
1012                                                 mode_lib->vba.TotImmediateFlipBytes,
1013                                                 mode_lib->vba.SourcePixelFormat[k],
1014                                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
1015                                                 mode_lib->vba.VRatio[k],
1016                                                 mode_lib->vba.VRatioChroma[k],
1017                                                 v->Tno_bw[k],
1018                                                 mode_lib->vba.DCCEnable[k],
1019                                                 v->dpte_row_height[k],
1020                                                 v->meta_row_height[k],
1021                                                 v->dpte_row_height_chroma[k],
1022                                                 v->meta_row_height_chroma[k],
1023                                                 v->Use_One_Row_For_Frame_Flip[k],
1024
1025                                                 /* Output */
1026                                                 &v->DestinationLinesToRequestVMInImmediateFlip[k],
1027                                                 &v->DestinationLinesToRequestRowInImmediateFlip[k],
1028                                                 &v->final_flip_bw[k],
1029                                                 &v->ImmediateFlipSupportedForPipe[k]);
1030                         }
1031
1032                         {
1033                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1034                                                 mode_lib->vba.ReturnBW,
1035                                                 mode_lib->vba.ImmediateFlipRequirement,
1036                                                 v->final_flip_bw,
1037                                                 v->ReadBandwidthSurfaceLuma,
1038                                                 v->ReadBandwidthSurfaceChroma,
1039                                                 v->RequiredPrefetchPixDataBWLuma,
1040                                                 v->RequiredPrefetchPixDataBWChroma,
1041                                                 v->cursor_bw,
1042                                                 v->meta_row_bw,
1043                                                 v->dpte_row_bw,
1044                                                 v->cursor_bw_pre,
1045                                                 v->prefetch_vmrow_bw,
1046                                                 mode_lib->vba.DPPPerPlane,
1047                                                 v->UrgBurstFactorLuma,
1048                                                 v->UrgBurstFactorChroma,
1049                                                 v->UrgBurstFactorCursor,
1050                                                 v->UrgBurstFactorLumaPre,
1051                                                 v->UrgBurstFactorChromaPre,
1052                                                 v->UrgBurstFactorCursorPre,
1053
1054                                                 /* output */
1055                                                 &v->total_dcn_read_bw_with_flip,    // Single  *TotalBandwidth
1056                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],                        // Single  *FractionOfUrgentBandwidth
1057                                                 &v->ImmediateFlipSupported);        // Boolean *ImmediateFlipBandwidthSupport
1058
1059                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1060                                                 mode_lib->vba.ReturnBW,
1061                                                 mode_lib->vba.ImmediateFlipRequirement,
1062                                                 v->final_flip_bw,
1063                                                 v->ReadBandwidthSurfaceLuma,
1064                                                 v->ReadBandwidthSurfaceChroma,
1065                                                 v->RequiredPrefetchPixDataBWLuma,
1066                                                 v->RequiredPrefetchPixDataBWChroma,
1067                                                 v->cursor_bw,
1068                                                 v->meta_row_bw,
1069                                                 v->dpte_row_bw,
1070                                                 v->cursor_bw_pre,
1071                                                 v->prefetch_vmrow_bw,
1072                                                 mode_lib->vba.DPPPerPlane,
1073                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1074                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1075                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1076                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1077                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1078                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1079
1080                                                 /* output */
1081                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],                                // Single  *TotalBandwidth
1082                                                 &v->FractionOfUrgentBandwidthImmediateFlip, // Single  *FractionOfUrgentBandwidth
1083                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);                              // Boolean *ImmediateFlipBandwidthSupport
1084                         }
1085
1086                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1087                                 if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required && v->ImmediateFlipSupportedForPipe[k] == false) {
1088                                         v->ImmediateFlipSupported = false;
1089 #ifdef __DML_VBA_DEBUG__
1090                                         dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
1091 #endif
1092                                 }
1093                         }
1094                 } else {
1095                         v->ImmediateFlipSupported = false;
1096                 }
1097
1098                 /* 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) */
1099                 v->PrefetchAndImmediateFlipSupported = (v->PrefetchModeSupported == true &&
1100                                 ((!mode_lib->vba.ImmediateFlipSupport && !mode_lib->vba.HostVMEnable && !ImmediateFlipRequirementFinal) ||
1101                                                 v->ImmediateFlipSupported)) ? true : false;
1102
1103 #ifdef __DML_VBA_DEBUG__
1104                 dml_print("DML::%s: PrefetchModeSupported = %d\n", __func__, locals->PrefetchModeSupported);
1105                 for (uint k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
1106                         dml_print("DML::%s: ImmediateFlipRequirement[%d] = %d\n", __func__, k,  mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
1107                 dml_print("DML::%s: ImmediateFlipSupported = %d\n", __func__, locals->ImmediateFlipSupported);
1108                 dml_print("DML::%s: ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
1109                 dml_print("DML::%s: HostVMEnable = %d\n", __func__, mode_lib->vba.HostVMEnable);
1110                 dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %d\n", __func__, locals->PrefetchAndImmediateFlipSupported);
1111                 dml_print("DML::%s: Done loop: Vstartup=%d, Max Vstartup=%d\n", __func__, locals->VStartupLines, locals->MaximumMaxVStartupLines);
1112 #endif
1113
1114                 v->VStartupLines = v->VStartupLines + 1;
1115
1116                 if (v->VStartupLines > v->MaximumMaxVStartupLines) {
1117 #ifdef __DML_VBA_DEBUG__
1118                         dml_print("DML::%s: Vstartup exceeds max vstartup, exiting loop\n", __func__);
1119 #endif
1120                         break; // VBA_DELTA: Implementation divergence! Gabe is *still* iterating across prefetch modes which we don't care to do
1121                 }
1122                 iteration++;
1123                 if (iteration > 2500) {
1124 #ifdef __DML_VBA_DEBUG__
1125                         dml_print("DML::%s: too many errors, exit now\n", __func__);
1126                         assert(0);
1127 #endif
1128                 }
1129         } while (!(v->PrefetchAndImmediateFlipSupported || NextPrefetchMode > mode_lib->vba.MaxPrefetchMode));
1130
1131
1132         if (v->VStartupLines <= v->MaximumMaxVStartupLines) {
1133 #ifdef __DML_VBA_DEBUG__
1134                 dml_print("DML::%s: Good, Prefetch and flip scheduling found solution at VStartupLines=%d\n", __func__, locals->VStartupLines-1);
1135 #endif
1136         }
1137
1138
1139         //Watermarks and NB P-State/DRAM Clock Change Support
1140         {
1141                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.UrgentLatency = v->UrgentLatency;
1142                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.ExtraLatency = v->UrgentExtraLatency;
1143                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
1144                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
1145                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
1146                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
1147                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
1148                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
1149                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
1150                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
1151                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
1152
1153                 dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
1154                         v,
1155                         v->PrefetchModePerState[v->VoltageLevel][v->maxMpcComb],
1156                         v->DCFCLK,
1157                         v->ReturnBW,
1158                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters,
1159                         v->SOCCLK,
1160                         v->DCFCLKDeepSleep,
1161                         v->DETBufferSizeY,
1162                         v->DETBufferSizeC,
1163                         v->SwathHeightY,
1164                         v->SwathHeightC,
1165                         v->SwathWidthY,
1166                         v->SwathWidthC,
1167                         v->DPPPerPlane,
1168                         v->BytePerPixelDETY,
1169                         v->BytePerPixelDETC,
1170                         v->DSTXAfterScaler,
1171                         v->DSTYAfterScaler,
1172                         v->UnboundedRequestEnabled,
1173                         v->CompressedBufferSizeInkByte,
1174
1175                         /* Output */
1176                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_dramchange_support,
1177                         v->MaxActiveDRAMClockChangeLatencySupported,
1178                         v->SubViewportLinesNeededInMALL,
1179                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_fclkchange_support,
1180                         &v->MinActiveFCLKChangeLatencySupported,
1181                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_USRRetrainingSupport,
1182                         mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);
1183
1184                 /* DCN32 has a new struct Watermarks (typedef) which is used to store
1185                  * calculated WM values. Copy over values from struct to vba varaibles
1186                  * to ensure that the DCN32 getters return the correct value.
1187                  */
1188                 v->UrgentWatermark = v->Watermark.UrgentWatermark;
1189                 v->WritebackUrgentWatermark = v->Watermark.WritebackUrgentWatermark;
1190                 v->DRAMClockChangeWatermark = v->Watermark.DRAMClockChangeWatermark;
1191                 v->WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark;
1192                 v->StutterExitWatermark = v->Watermark.StutterExitWatermark;
1193                 v->StutterEnterPlusExitWatermark = v->Watermark.StutterEnterPlusExitWatermark;
1194                 v->Z8StutterExitWatermark = v->Watermark.Z8StutterExitWatermark;
1195                 v->Z8StutterEnterPlusExitWatermark = v->Watermark.Z8StutterEnterPlusExitWatermark;
1196
1197                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1198                         if (mode_lib->vba.WritebackEnable[k] == true) {
1199                                 v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
1200                                                 v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1201                                                                 - v->Watermark.WritebackDRAMClockChangeWatermark);
1202                                 v->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0,
1203                                                 v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1204                                                                 - v->Watermark.WritebackFCLKChangeWatermark);
1205                         } else {
1206                                 v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
1207                                 v->WritebackAllowFCLKChangeEndPosition[k] = 0;
1208                         }
1209                 }
1210         }
1211
1212         //Display Pipeline Delivery Time in Prefetch, Groups
1213         dml32_CalculatePixelDeliveryTimes(
1214                         mode_lib->vba.NumberOfActiveSurfaces,
1215                         mode_lib->vba.VRatio,
1216                         mode_lib->vba.VRatioChroma,
1217                         v->VRatioPrefetchY,
1218                         v->VRatioPrefetchC,
1219                         v->swath_width_luma_ub,
1220                         v->swath_width_chroma_ub,
1221                         mode_lib->vba.DPPPerPlane,
1222                         mode_lib->vba.HRatio,
1223                         mode_lib->vba.HRatioChroma,
1224                         mode_lib->vba.PixelClock,
1225                         v->PSCL_THROUGHPUT_LUMA,
1226                         v->PSCL_THROUGHPUT_CHROMA,
1227                         mode_lib->vba.DPPCLK,
1228                         v->BytePerPixelC,
1229                         mode_lib->vba.SourceRotation,
1230                         mode_lib->vba.NumberOfCursors,
1231                         mode_lib->vba.CursorWidth,
1232                         mode_lib->vba.CursorBPP,
1233                         v->BlockWidth256BytesY,
1234                         v->BlockHeight256BytesY,
1235                         v->BlockWidth256BytesC,
1236                         v->BlockHeight256BytesC,
1237
1238                         /* Output */
1239                         v->DisplayPipeLineDeliveryTimeLuma,
1240                         v->DisplayPipeLineDeliveryTimeChroma,
1241                         v->DisplayPipeLineDeliveryTimeLumaPrefetch,
1242                         v->DisplayPipeLineDeliveryTimeChromaPrefetch,
1243                         v->DisplayPipeRequestDeliveryTimeLuma,
1244                         v->DisplayPipeRequestDeliveryTimeChroma,
1245                         v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
1246                         v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
1247                         v->CursorRequestDeliveryTime,
1248                         v->CursorRequestDeliveryTimePrefetch);
1249
1250         dml32_CalculateMetaAndPTETimes(v->Use_One_Row_For_Frame,
1251                         mode_lib->vba.NumberOfActiveSurfaces,
1252                         mode_lib->vba.GPUVMEnable,
1253                         mode_lib->vba.MetaChunkSize,
1254                         mode_lib->vba.MinMetaChunkSizeBytes,
1255                         mode_lib->vba.HTotal,
1256                         mode_lib->vba.VRatio,
1257                         mode_lib->vba.VRatioChroma,
1258                         v->DestinationLinesToRequestRowInVBlank,
1259                         v->DestinationLinesToRequestRowInImmediateFlip,
1260                         mode_lib->vba.DCCEnable,
1261                         mode_lib->vba.PixelClock,
1262                         v->BytePerPixelY,
1263                         v->BytePerPixelC,
1264                         mode_lib->vba.SourceRotation,
1265                         v->dpte_row_height,
1266                         v->dpte_row_height_chroma,
1267                         v->meta_row_width,
1268                         v->meta_row_width_chroma,
1269                         v->meta_row_height,
1270                         v->meta_row_height_chroma,
1271                         v->meta_req_width,
1272                         v->meta_req_width_chroma,
1273                         v->meta_req_height,
1274                         v->meta_req_height_chroma,
1275                         v->dpte_group_bytes,
1276                         v->PTERequestSizeY,
1277                         v->PTERequestSizeC,
1278                         v->PixelPTEReqWidthY,
1279                         v->PixelPTEReqHeightY,
1280                         v->PixelPTEReqWidthC,
1281                         v->PixelPTEReqHeightC,
1282                         v->dpte_row_width_luma_ub,
1283                         v->dpte_row_width_chroma_ub,
1284
1285                         /* Output */
1286                         v->DST_Y_PER_PTE_ROW_NOM_L,
1287                         v->DST_Y_PER_PTE_ROW_NOM_C,
1288                         v->DST_Y_PER_META_ROW_NOM_L,
1289                         v->DST_Y_PER_META_ROW_NOM_C,
1290                         v->TimePerMetaChunkNominal,
1291                         v->TimePerChromaMetaChunkNominal,
1292                         v->TimePerMetaChunkVBlank,
1293                         v->TimePerChromaMetaChunkVBlank,
1294                         v->TimePerMetaChunkFlip,
1295                         v->TimePerChromaMetaChunkFlip,
1296                         v->time_per_pte_group_nom_luma,
1297                         v->time_per_pte_group_vblank_luma,
1298                         v->time_per_pte_group_flip_luma,
1299                         v->time_per_pte_group_nom_chroma,
1300                         v->time_per_pte_group_vblank_chroma,
1301                         v->time_per_pte_group_flip_chroma);
1302
1303         dml32_CalculateVMGroupAndRequestTimes(
1304                         mode_lib->vba.NumberOfActiveSurfaces,
1305                         mode_lib->vba.GPUVMEnable,
1306                         mode_lib->vba.GPUVMMaxPageTableLevels,
1307                         mode_lib->vba.HTotal,
1308                         v->BytePerPixelC,
1309                         v->DestinationLinesToRequestVMInVBlank,
1310                         v->DestinationLinesToRequestVMInImmediateFlip,
1311                         mode_lib->vba.DCCEnable,
1312                         mode_lib->vba.PixelClock,
1313                         v->dpte_row_width_luma_ub,
1314                         v->dpte_row_width_chroma_ub,
1315                         v->vm_group_bytes,
1316                         v->dpde0_bytes_per_frame_ub_l,
1317                         v->dpde0_bytes_per_frame_ub_c,
1318                         v->meta_pte_bytes_per_frame_ub_l,
1319                         v->meta_pte_bytes_per_frame_ub_c,
1320
1321                         /* Output */
1322                         v->TimePerVMGroupVBlank,
1323                         v->TimePerVMGroupFlip,
1324                         v->TimePerVMRequestVBlank,
1325                         v->TimePerVMRequestFlip);
1326
1327         // Min TTUVBlank
1328         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1329                 if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
1330                         v->MinTTUVBlank[k] = dml_max4(v->Watermark.DRAMClockChangeWatermark,
1331                                         v->Watermark.FCLKChangeWatermark, v->Watermark.StutterEnterPlusExitWatermark,
1332                                         v->Watermark.UrgentWatermark);
1333                 } else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1334                                 == 1) {
1335                         v->MinTTUVBlank[k] = dml_max3(v->Watermark.FCLKChangeWatermark,
1336                                         v->Watermark.StutterEnterPlusExitWatermark, v->Watermark.UrgentWatermark);
1337                 } else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1338                                 == 2) {
1339                         v->MinTTUVBlank[k] = dml_max(v->Watermark.StutterEnterPlusExitWatermark,
1340                                         v->Watermark.UrgentWatermark);
1341                 } else {
1342                         v->MinTTUVBlank[k] = v->Watermark.UrgentWatermark;
1343                 }
1344                 if (!mode_lib->vba.DynamicMetadataEnable[k])
1345                         v->MinTTUVBlank[k] = mode_lib->vba.TCalc + v->MinTTUVBlank[k];
1346         }
1347
1348         // DCC Configuration
1349         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1350 #ifdef __DML_VBA_DEBUG__
1351                 dml_print("DML::%s: Calculate DCC configuration for surface k=%d\n", __func__, k);
1352 #endif
1353                 dml32_CalculateDCCConfiguration(
1354                                 mode_lib->vba.DCCEnable[k],
1355                                 mode_lib->vba.DCCProgrammingAssumesScanDirectionUnknownFinal,
1356                                 mode_lib->vba.SourcePixelFormat[k], mode_lib->vba.SurfaceWidthY[k],
1357                                 mode_lib->vba.SurfaceWidthC[k],
1358                                 mode_lib->vba.SurfaceHeightY[k],
1359                                 mode_lib->vba.SurfaceHeightC[k],
1360                                 mode_lib->vba.nomDETInKByte,
1361                                 v->BlockHeight256BytesY[k],
1362                                 v->BlockHeight256BytesC[k],
1363                                 mode_lib->vba.SurfaceTiling[k],
1364                                 v->BytePerPixelY[k],
1365                                 v->BytePerPixelC[k],
1366                                 v->BytePerPixelDETY[k],
1367                                 v->BytePerPixelDETC[k],
1368                                 (enum dm_rotation_angle) mode_lib->vba.SourceScan[k],
1369                                 /* Output */
1370                                 &v->DCCYMaxUncompressedBlock[k],
1371                                 &v->DCCCMaxUncompressedBlock[k],
1372                                 &v->DCCYMaxCompressedBlock[k],
1373                                 &v->DCCCMaxCompressedBlock[k],
1374                                 &v->DCCYIndependentBlock[k],
1375                                 &v->DCCCIndependentBlock[k]);
1376         }
1377
1378         // VStartup Adjustment
1379         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1380                 bool isInterlaceTiming;
1381                 double Tvstartup_margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * mode_lib->vba.HTotal[k]
1382                                 / mode_lib->vba.PixelClock[k];
1383 #ifdef __DML_VBA_DEBUG__
1384                 dml_print("DML::%s: k=%d, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k,
1385                                 v->MinTTUVBlank[k]);
1386 #endif
1387
1388                 v->MinTTUVBlank[k] = v->MinTTUVBlank[k] + Tvstartup_margin;
1389
1390 #ifdef __DML_VBA_DEBUG__
1391                 dml_print("DML::%s: k=%d, Tvstartup_margin = %f\n", __func__, k, Tvstartup_margin);
1392                 dml_print("DML::%s: k=%d, MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
1393                 dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1394                 dml_print("DML::%s: k=%d, MinTTUVBlank = %f\n", __func__, k, v->MinTTUVBlank[k]);
1395 #endif
1396
1397                 v->Tdmdl[k] = v->Tdmdl[k] + Tvstartup_margin;
1398                 if (mode_lib->vba.DynamicMetadataEnable[k] && mode_lib->vba.DynamicMetadataVMEnabled)
1399                         v->Tdmdl_vm[k] = v->Tdmdl_vm[k] + Tvstartup_margin;
1400
1401                 isInterlaceTiming = (mode_lib->vba.Interlace[k] &&
1402                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP);
1403
1404                 v->MIN_DST_Y_NEXT_START[k] = ((isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k] -
1405                                                 mode_lib->vba.VFrontPorch[k]) / 2.0, 1.0) :
1406                                                 mode_lib->vba.VTotal[k]) - mode_lib->vba.VFrontPorch[k])
1407                                                 + dml_max(1.0,
1408                                                 dml_ceil(v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
1409                                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0))
1410                                                 + dml_floor(4.0 * v->TSetup[k] / (mode_lib->vba.HTotal[k]
1411                                                 / mode_lib->vba.PixelClock[k]), 1.0) / 4.0;
1412
1413                 v->VStartup[k] = (isInterlaceTiming ? (2 * v->MaxVStartupLines[k]) : v->MaxVStartupLines[k]);
1414
1415                 if (((v->VUpdateOffsetPix[k] + v->VUpdateWidthPix[k] + v->VReadyOffsetPix[k])
1416                         / mode_lib->vba.HTotal[k]) <= (isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k]
1417                         - mode_lib->vba.VActive[k] - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]) / 2.0, 1.0) :
1418                         (int) (mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
1419                        - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]))) {
1420                         v->VREADY_AT_OR_AFTER_VSYNC[k] = true;
1421                 } else {
1422                         v->VREADY_AT_OR_AFTER_VSYNC[k] = false;
1423                 }
1424 #ifdef __DML_VBA_DEBUG__
1425                 dml_print("DML::%s: k=%d, VStartup = %d (max)\n", __func__, k, v->VStartup[k]);
1426                 dml_print("DML::%s: k=%d, VUpdateOffsetPix = %d\n", __func__, k, v->VUpdateOffsetPix[k]);
1427                 dml_print("DML::%s: k=%d, VUpdateWidthPix = %d\n", __func__, k, v->VUpdateWidthPix[k]);
1428                 dml_print("DML::%s: k=%d, VReadyOffsetPix = %d\n", __func__, k, v->VReadyOffsetPix[k]);
1429                 dml_print("DML::%s: k=%d, HTotal = %d\n", __func__, k, mode_lib->vba.HTotal[k]);
1430                 dml_print("DML::%s: k=%d, VTotal = %d\n", __func__, k, mode_lib->vba.VTotal[k]);
1431                 dml_print("DML::%s: k=%d, VActive = %d\n", __func__, k, mode_lib->vba.VActive[k]);
1432                 dml_print("DML::%s: k=%d, VFrontPorch = %d\n", __func__, k, mode_lib->vba.VFrontPorch[k]);
1433                 dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1434                 dml_print("DML::%s: k=%d, TSetup = %f\n", __func__, k, v->TSetup[k]);
1435                 dml_print("DML::%s: k=%d, MIN_DST_Y_NEXT_START = %f\n", __func__, k, v->MIN_DST_Y_NEXT_START[k]);
1436                 dml_print("DML::%s: k=%d, VREADY_AT_OR_AFTER_VSYNC = %d\n", __func__, k,
1437                                 v->VREADY_AT_OR_AFTER_VSYNC[k]);
1438 #endif
1439         }
1440
1441         {
1442                 //Maximum Bandwidth Used
1443                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1444                         if (mode_lib->vba.WritebackEnable[k] == true
1445                                         && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
1446                                 WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1447                                                 * mode_lib->vba.WritebackDestinationHeight[k]
1448                                                 / (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1449                                                                 / mode_lib->vba.PixelClock[k]) * 4;
1450                         } else if (mode_lib->vba.WritebackEnable[k] == true) {
1451                                 WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1452                                                 * mode_lib->vba.WritebackDestinationHeight[k]
1453                                                 / (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1454                                                                 / mode_lib->vba.PixelClock[k]) * 8;
1455                         }
1456                         TotalWRBandwidth = TotalWRBandwidth + WRBandwidth;
1457                 }
1458
1459                 v->TotalDataReadBandwidth = 0;
1460                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1461                         v->TotalDataReadBandwidth = v->TotalDataReadBandwidth + v->ReadBandwidthSurfaceLuma[k]
1462                                         + v->ReadBandwidthSurfaceChroma[k];
1463 #ifdef __DML_VBA_DEBUG__
1464                         dml_print("DML::%s: k=%d, TotalDataReadBandwidth = %f\n",
1465                                         __func__, k, v->TotalDataReadBandwidth);
1466                         dml_print("DML::%s: k=%d, ReadBandwidthSurfaceLuma = %f\n",
1467                                         __func__, k, v->ReadBandwidthSurfaceLuma[k]);
1468                         dml_print("DML::%s: k=%d, ReadBandwidthSurfaceChroma = %f\n",
1469                                         __func__, k, v->ReadBandwidthSurfaceChroma[k]);
1470 #endif
1471                 }
1472         }
1473
1474         // Stutter Efficiency
1475         dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1476                         mode_lib->vba.UsesMALLForPStateChange,
1477                         v->UnboundedRequestEnabled,
1478                         mode_lib->vba.MetaFIFOSizeInKEntries,
1479                         mode_lib->vba.ZeroSizeBufferEntries,
1480                         mode_lib->vba.PixelChunkSizeInKByte,
1481                         mode_lib->vba.NumberOfActiveSurfaces,
1482                         mode_lib->vba.ROBBufferSizeInKByte,
1483                         v->TotalDataReadBandwidth,
1484                         mode_lib->vba.DCFCLK,
1485                         mode_lib->vba.ReturnBW,
1486                         v->CompbufReservedSpace64B,
1487                         v->CompbufReservedSpaceZs,
1488                         mode_lib->vba.SRExitTime,
1489                         mode_lib->vba.SRExitZ8Time,
1490                         mode_lib->vba.SynchronizeTimingsFinal,
1491                         mode_lib->vba.BlendingAndTiming,
1492                         v->Watermark.StutterEnterPlusExitWatermark,
1493                         v->Watermark.Z8StutterEnterPlusExitWatermark,
1494                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1495                         mode_lib->vba.Interlace,
1496                         v->MinTTUVBlank, mode_lib->vba.DPPPerPlane,
1497                         mode_lib->vba.DETBufferSizeY,
1498                         v->BytePerPixelY,
1499                         v->BytePerPixelDETY,
1500                         v->SwathWidthY,
1501                         mode_lib->vba.SwathHeightY,
1502                         mode_lib->vba.SwathHeightC,
1503                         mode_lib->vba.DCCRateLuma,
1504                         mode_lib->vba.DCCRateChroma,
1505                         mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1506                         mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1507                         mode_lib->vba.HTotal, mode_lib->vba.VTotal,
1508                         mode_lib->vba.PixelClock,
1509                         mode_lib->vba.VRatio,
1510                         mode_lib->vba.SourceRotation,
1511                         v->BlockHeight256BytesY,
1512                         v->BlockWidth256BytesY,
1513                         v->BlockHeight256BytesC,
1514                         v->BlockWidth256BytesC,
1515                         v->DCCYMaxUncompressedBlock,
1516                         v->DCCCMaxUncompressedBlock,
1517                         mode_lib->vba.VActive,
1518                         mode_lib->vba.DCCEnable,
1519                         mode_lib->vba.WritebackEnable,
1520                         v->ReadBandwidthSurfaceLuma,
1521                         v->ReadBandwidthSurfaceChroma,
1522                         v->meta_row_bw,
1523                         v->dpte_row_bw,
1524                         /* Output */
1525                         &v->StutterEfficiencyNotIncludingVBlank,
1526                         &v->StutterEfficiency,
1527                         &v->NumberOfStutterBurstsPerFrame,
1528                         &v->Z8StutterEfficiencyNotIncludingVBlank,
1529                         &v->Z8StutterEfficiency,
1530                         &v->Z8NumberOfStutterBurstsPerFrame,
1531                         &v->StutterPeriod,
1532                         &v->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
1533
1534 #ifdef __DML_VBA_ALLOW_DELTA__
1535         {
1536                 unsigned int dummy_integer[1];
1537
1538                 // Calculate z8 stutter eff assuming 0 reserved space
1539                 dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1540                                 mode_lib->vba.UsesMALLForPStateChange,
1541                                 v->UnboundedRequestEnabled,
1542                                 mode_lib->vba.MetaFIFOSizeInKEntries,
1543                                 mode_lib->vba.ZeroSizeBufferEntries,
1544                                 mode_lib->vba.PixelChunkSizeInKByte,
1545                                 mode_lib->vba.NumberOfActiveSurfaces,
1546                                 mode_lib->vba.ROBBufferSizeInKByte,
1547                                 v->TotalDataReadBandwidth,
1548                                 mode_lib->vba.DCFCLK,
1549                                 mode_lib->vba.ReturnBW,
1550                                 0, //CompbufReservedSpace64B,
1551                                 0, //CompbufReservedSpaceZs,
1552                                 mode_lib->vba.SRExitTime,
1553                                 mode_lib->vba.SRExitZ8Time,
1554                                 mode_lib->vba.SynchronizeTimingsFinal,
1555                                 mode_lib->vba.BlendingAndTiming,
1556                                 v->Watermark.StutterEnterPlusExitWatermark,
1557                                 v->Watermark.Z8StutterEnterPlusExitWatermark,
1558                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1559                                 mode_lib->vba.Interlace,
1560                                 v->MinTTUVBlank,
1561                                 mode_lib->vba.DPPPerPlane,
1562                                 mode_lib->vba.DETBufferSizeY,
1563                                 v->BytePerPixelY, v->BytePerPixelDETY,
1564                                 v->SwathWidthY, mode_lib->vba.SwathHeightY,
1565                                 mode_lib->vba.SwathHeightC,
1566                                 mode_lib->vba.DCCRateLuma,
1567                                 mode_lib->vba.DCCRateChroma,
1568                                 mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1569                                 mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1570                                 mode_lib->vba.HTotal,
1571                                 mode_lib->vba.VTotal,
1572                                 mode_lib->vba.PixelClock,
1573                                 mode_lib->vba.VRatio,
1574                                 mode_lib->vba.SourceRotation,
1575                                 v->BlockHeight256BytesY,
1576                                 v->BlockWidth256BytesY,
1577                                 v->BlockHeight256BytesC,
1578                                 v->BlockWidth256BytesC,
1579                                 v->DCCYMaxUncompressedBlock,
1580                                 v->DCCCMaxUncompressedBlock,
1581                                 mode_lib->vba.VActive,
1582                                 mode_lib->vba.DCCEnable,
1583                                 mode_lib->vba.WritebackEnable,
1584                                 v->ReadBandwidthSurfaceLuma,
1585                                 v->ReadBandwidthSurfaceChroma,
1586                                 v->meta_row_bw, v->dpte_row_bw,
1587
1588                                 /* Output */
1589                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
1590                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],
1591                                 &dummy_integer[0],
1592                                 &v->Z8StutterEfficiencyNotIncludingVBlankBestCase,
1593                                 &v->Z8StutterEfficiencyBestCase,
1594                                 &v->Z8NumberOfStutterBurstsPerFrameBestCase,
1595                                 &v->StutterPeriodBestCase,
1596                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
1597         }
1598 #else
1599         v->Z8StutterEfficiencyNotIncludingVBlankBestCase = v->Z8StutterEfficiencyNotIncludingVBlank;
1600         v->Z8StutterEfficiencyBestCase = v->Z8StutterEfficiency;
1601         v->Z8NumberOfStutterBurstsPerFrameBestCase = v->Z8NumberOfStutterBurstsPerFrame;
1602         v->StutterPeriodBestCase = v->StutterPeriod;
1603 #endif
1604
1605 #ifdef __DML_VBA_DEBUG__
1606         dml_print("DML::%s: --- END ---\n", __func__);
1607 #endif
1608 }
1609
1610 static void mode_support_configuration(struct vba_vars_st *v,
1611                                   struct display_mode_lib *mode_lib)
1612 {
1613         int i, j;
1614
1615         for (i = v->soc.num_states - 1; i >= 0; i--) {
1616                 for (j = 0; j < 2; j++) {
1617                         if (mode_lib->vba.ScaleRatioAndTapsSupport == true
1618                                 && mode_lib->vba.SourceFormatPixelAndScanSupport == true
1619                                 && mode_lib->vba.ViewportSizeSupport[i][j] == true
1620                                 && !mode_lib->vba.LinkRateDoesNotMatchDPVersion
1621                                 && !mode_lib->vba.LinkRateForMultistreamNotIndicated
1622                                 && !mode_lib->vba.BPPForMultistreamNotIndicated
1623                                 && !mode_lib->vba.MultistreamWithHDMIOreDP
1624                                 && !mode_lib->vba.ExceededMultistreamSlots[i]
1625                                 && !mode_lib->vba.MSOOrODMSplitWithNonDPLink
1626                                 && !mode_lib->vba.NotEnoughLanesForMSO
1627                                 && mode_lib->vba.LinkCapacitySupport[i] == true && !mode_lib->vba.P2IWith420
1628                                 && !mode_lib->vba.DSCOnlyIfNecessaryWithBPP
1629                                 && !mode_lib->vba.DSC422NativeNotSupported
1630                                 && !mode_lib->vba.MPCCombineMethodIncompatible
1631                                 && mode_lib->vba.ODMCombine2To1SupportCheckOK[i] == true
1632                                 && mode_lib->vba.ODMCombine4To1SupportCheckOK[i] == true
1633                                 && mode_lib->vba.NotEnoughDSCUnits[i] == false
1634                                 && !mode_lib->vba.NotEnoughDSCSlices[i]
1635                                 && !mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
1636                                 && !mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
1637                                 && mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] == false
1638                                 && mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i]
1639                                 && mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] == false
1640                                 && !mode_lib->vba.InvalidCombinationOfMALLUseForPState
1641                                 && !mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
1642                                 && mode_lib->vba.ROBSupport[i][j] == true
1643                                 && mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] == true
1644                                 && mode_lib->vba.TotalAvailablePipesSupport[i][j] == true
1645                                 && mode_lib->vba.NumberOfOTGSupport == true
1646                                 && mode_lib->vba.NumberOfHDMIFRLSupport == true
1647                                 && mode_lib->vba.EnoughWritebackUnits == true
1648                                 && mode_lib->vba.WritebackLatencySupport == true
1649                                 && mode_lib->vba.WritebackScaleRatioAndTapsSupport == true
1650                                 && mode_lib->vba.CursorSupport == true && mode_lib->vba.PitchSupport == true
1651                                 && mode_lib->vba.ViewportExceedsSurface == false
1652                                 && mode_lib->vba.PrefetchSupported[i][j] == true
1653                                 && mode_lib->vba.VActiveBandwithSupport[i][j] == true
1654                                 && mode_lib->vba.DynamicMetadataSupported[i][j] == true
1655                                 && mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] == true
1656                                 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true
1657                                 && mode_lib->vba.PTEBufferSizeNotExceeded[i][j] == true
1658                                 && mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] == true
1659                                 && mode_lib->vba.NonsupportedDSCInputBPC == false
1660                                 && !mode_lib->vba.ExceededMALLSize
1661                                 && ((mode_lib->vba.HostVMEnable == false
1662                                 && !mode_lib->vba.ImmediateFlipRequiredFinal)
1663                                 || mode_lib->vba.ImmediateFlipSupportedForState[i][j])
1664                                 && (!mode_lib->vba.DRAMClockChangeRequirementFinal
1665                                 || i == v->soc.num_states - 1
1666                                 || mode_lib->vba.DRAMClockChangeSupport[i][j] != dm_dram_clock_change_unsupported)
1667                                 && (!mode_lib->vba.FCLKChangeRequirementFinal || i == v->soc.num_states - 1
1668                                 || mode_lib->vba.FCLKChangeSupport[i][j] != dm_fclock_change_unsupported)
1669                                 && (!mode_lib->vba.USRRetrainingRequiredFinal
1670                                 || mode_lib->vba.USRRetrainingSupport[i][j])) {
1671                                 mode_lib->vba.ModeSupport[i][j] = true;
1672                         } else {
1673                                 mode_lib->vba.ModeSupport[i][j] = false;
1674                         }
1675                 }
1676         }
1677 }
1678
1679 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
1680 {
1681         struct vba_vars_st *v = &mode_lib->vba;
1682         int i, j;
1683         unsigned int k, m;
1684         unsigned int MaximumMPCCombine;
1685         unsigned int NumberOfNonCombinedSurfaceOfMaximumBandwidth;
1686         unsigned int TotalSlots;
1687         bool CompBufReservedSpaceNeedAdjustment;
1688         bool CompBufReservedSpaceNeedAdjustmentSingleDPP;
1689
1690 #ifdef __DML_VBA_DEBUG__
1691         dml_print("DML::%s: called\n", __func__);
1692 #endif
1693
1694         /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
1695
1696         /*Scale Ratio, taps Support Check*/
1697
1698         mode_lib->vba.ScaleRatioAndTapsSupport = true;
1699         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1700                 if (mode_lib->vba.ScalerEnabled[k] == false
1701                                 && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1702                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1703                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1704                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1705                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1706                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1707                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha)
1708                                                 || mode_lib->vba.HRatio[k] != 1.0 || mode_lib->vba.htaps[k] != 1.0
1709                                                 || mode_lib->vba.VRatio[k] != 1.0 || mode_lib->vba.vtaps[k] != 1.0)) {
1710                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
1711                 } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0 || mode_lib->vba.htaps[k] < 1.0
1712                                 || mode_lib->vba.htaps[k] > 8.0
1713                                 || (mode_lib->vba.htaps[k] > 1.0 && (mode_lib->vba.htaps[k] % 2) == 1)
1714                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
1715                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
1716                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
1717                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
1718                                 || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1719                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1720                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1721                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1722                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1723                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1724                                                 && (mode_lib->vba.VTAPsChroma[k] < 1
1725                                                                 || mode_lib->vba.VTAPsChroma[k] > 8
1726                                                                 || mode_lib->vba.HTAPsChroma[k] < 1
1727                                                                 || mode_lib->vba.HTAPsChroma[k] > 8
1728                                                                 || (mode_lib->vba.HTAPsChroma[k] > 1
1729                                                                                 && mode_lib->vba.HTAPsChroma[k] % 2
1730                                                                                                 == 1)
1731                                                                 || mode_lib->vba.HRatioChroma[k]
1732                                                                                 > mode_lib->vba.MaxHSCLRatio
1733                                                                 || mode_lib->vba.VRatioChroma[k]
1734                                                                                 > mode_lib->vba.MaxVSCLRatio
1735                                                                 || mode_lib->vba.HRatioChroma[k]
1736                                                                                 > mode_lib->vba.HTAPsChroma[k]
1737                                                                 || mode_lib->vba.VRatioChroma[k]
1738                                                                                 > mode_lib->vba.VTAPsChroma[k]))) {
1739                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
1740                 }
1741         }
1742
1743         /*Source Format, Pixel Format and Scan Support Check*/
1744         mode_lib->vba.SourceFormatPixelAndScanSupport = true;
1745         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1746                 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
1747                         && (!(!IsVertical((enum dm_rotation_angle) mode_lib->vba.SourceScan[k]))
1748                                 || mode_lib->vba.DCCEnable[k] == true)) {
1749                         mode_lib->vba.SourceFormatPixelAndScanSupport = false;
1750                 }
1751         }
1752
1753         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1754                 dml32_CalculateBytePerPixelAndBlockSizes(
1755                                 mode_lib->vba.SourcePixelFormat[k],
1756                                 mode_lib->vba.SurfaceTiling[k],
1757
1758                                 /* Output */
1759                                 &mode_lib->vba.BytePerPixelY[k],
1760                                 &mode_lib->vba.BytePerPixelC[k],
1761                                 &mode_lib->vba.BytePerPixelInDETY[k],
1762                                 &mode_lib->vba.BytePerPixelInDETC[k],
1763                                 &mode_lib->vba.Read256BlockHeightY[k],
1764                                 &mode_lib->vba.Read256BlockHeightC[k],
1765                                 &mode_lib->vba.Read256BlockWidthY[k],
1766                                 &mode_lib->vba.Read256BlockWidthC[k],
1767                                 &mode_lib->vba.MacroTileHeightY[k],
1768                                 &mode_lib->vba.MacroTileHeightC[k],
1769                                 &mode_lib->vba.MacroTileWidthY[k],
1770                                 &mode_lib->vba.MacroTileWidthC[k]);
1771         }
1772
1773         /*Bandwidth Support Check*/
1774         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1775                 if (!IsVertical(mode_lib->vba.SourceRotation[k])) {
1776                         v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
1777                         v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportWidthChroma[k];
1778                 } else {
1779                         v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
1780                         v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportHeightChroma[k];
1781                 }
1782         }
1783         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1784                 v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0)
1785                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
1786                 v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0)
1787                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]
1788                                 / 2.0;
1789         }
1790         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1791                 if (mode_lib->vba.WritebackEnable[k] == true && mode_lib->vba.WritebackPixelFormat[k] == dm_444_64) {
1792                         v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1793                                         * mode_lib->vba.WritebackDestinationHeight[k]
1794                                         / (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1795                                                         / mode_lib->vba.PixelClock[k]) * 8.0;
1796                 } else if (mode_lib->vba.WritebackEnable[k] == true) {
1797                         v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1798                                         * mode_lib->vba.WritebackDestinationHeight[k]
1799                                         / (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1800                                                         / mode_lib->vba.PixelClock[k]) * 4.0;
1801                 } else {
1802                         v->WriteBandwidth[k] = 0.0;
1803                 }
1804         }
1805
1806         /*Writeback Latency support check*/
1807
1808         mode_lib->vba.WritebackLatencySupport = true;
1809         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1810                 if (mode_lib->vba.WritebackEnable[k] == true
1811                                 && (v->WriteBandwidth[k]
1812                                                 > mode_lib->vba.WritebackInterfaceBufferSize * 1024
1813                                                                 / mode_lib->vba.WritebackLatency)) {
1814                         mode_lib->vba.WritebackLatencySupport = false;
1815                 }
1816         }
1817
1818         /*Writeback Mode Support Check*/
1819         mode_lib->vba.EnoughWritebackUnits = true;
1820         mode_lib->vba.TotalNumberOfActiveWriteback = 0;
1821         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1822                 if (mode_lib->vba.WritebackEnable[k] == true)
1823                         mode_lib->vba.TotalNumberOfActiveWriteback = mode_lib->vba.TotalNumberOfActiveWriteback + 1;
1824         }
1825
1826         if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback)
1827                 mode_lib->vba.EnoughWritebackUnits = false;
1828
1829         /*Writeback Scale Ratio and Taps Support Check*/
1830         mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
1831         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1832                 if (mode_lib->vba.WritebackEnable[k] == true) {
1833                         if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
1834                                         || mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackMaxVSCLRatio
1835                                         || mode_lib->vba.WritebackHRatio[k] < mode_lib->vba.WritebackMinHSCLRatio
1836                                         || mode_lib->vba.WritebackVRatio[k] < mode_lib->vba.WritebackMinVSCLRatio
1837                                         || mode_lib->vba.WritebackHTaps[k] > mode_lib->vba.WritebackMaxHSCLTaps
1838                                         || mode_lib->vba.WritebackVTaps[k] > mode_lib->vba.WritebackMaxVSCLTaps
1839                                         || mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackHTaps[k]
1840                                         || mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackVTaps[k]
1841                                         || (mode_lib->vba.WritebackHTaps[k] > 2.0
1842                                                         && ((mode_lib->vba.WritebackHTaps[k] % 2) == 1))) {
1843                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1844                         }
1845                         if (2.0 * mode_lib->vba.WritebackDestinationWidth[k] * (mode_lib->vba.WritebackVTaps[k] - 1)
1846                                         * 57 > mode_lib->vba.WritebackLineBufferSize) {
1847                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1848                         }
1849                 }
1850         }
1851
1852         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1853                 dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k], mode_lib->vba.HRatioChroma[k],
1854                                 mode_lib->vba.VRatio[k], mode_lib->vba.VRatioChroma[k],
1855                                 mode_lib->vba.MaxDCHUBToPSCLThroughput, mode_lib->vba.MaxPSCLToLBThroughput,
1856                                 mode_lib->vba.PixelClock[k], mode_lib->vba.SourcePixelFormat[k],
1857                                 mode_lib->vba.htaps[k], mode_lib->vba.HTAPsChroma[k], mode_lib->vba.vtaps[k],
1858                                 mode_lib->vba.VTAPsChroma[k],
1859                                 /* Output */
1860                                 &mode_lib->vba.PSCL_FACTOR[k], &mode_lib->vba.PSCL_FACTOR_CHROMA[k],
1861                                 &mode_lib->vba.MinDPPCLKUsingSingleDPP[k]);
1862         }
1863
1864         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1865
1866                 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
1867                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 8192;
1868                 } else if (!IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1869                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1870                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 7680;
1871                 } else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1872                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1873                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 4320;
1874                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
1875                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3840;
1876                 } else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelY[k] == 8 &&
1877                                 mode_lib->vba.DCCEnable[k] == true) {
1878                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3072;
1879                 } else {
1880                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 6144;
1881                 }
1882
1883                 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
1884                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_12) {
1885                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma / 2.0;
1886                 } else {
1887                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma;
1888                 }
1889                 v->MaximumSwathWidthInLineBufferLuma = mode_lib->vba.LineBufferSizeFinal
1890                                 * dml_max(mode_lib->vba.HRatio[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1891                                 / (mode_lib->vba.vtaps[k] + dml_max(dml_ceil(mode_lib->vba.VRatio[k], 1.0) - 2, 0.0));
1892                 if (v->BytePerPixelC[k] == 0.0) {
1893                         v->MaximumSwathWidthInLineBufferChroma = 0;
1894                 } else {
1895                         v->MaximumSwathWidthInLineBufferChroma = mode_lib->vba.LineBufferSizeFinal
1896                                         * dml_max(mode_lib->vba.HRatioChroma[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1897                                         / (mode_lib->vba.VTAPsChroma[k]
1898                                                         + dml_max(dml_ceil(mode_lib->vba.VRatioChroma[k], 1.0) - 2,
1899                                                                         0.0));
1900                 }
1901                 v->MaximumSwathWidthLuma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma,
1902                                 v->MaximumSwathWidthInLineBufferLuma);
1903                 v->MaximumSwathWidthChroma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma,
1904                                 v->MaximumSwathWidthInLineBufferChroma);
1905         }
1906
1907         dml32_CalculateSwathAndDETConfiguration(
1908                         mode_lib->vba.DETSizeOverride,
1909                         mode_lib->vba.UsesMALLForPStateChange,
1910                         mode_lib->vba.ConfigReturnBufferSizeInKByte,
1911                         mode_lib->vba.MaxTotalDETInKByte,
1912                         mode_lib->vba.MinCompressedBufferSizeInKByte,
1913                         1, /* ForceSingleDPP */
1914                         mode_lib->vba.NumberOfActiveSurfaces,
1915                         mode_lib->vba.nomDETInKByte,
1916                         mode_lib->vba.UseUnboundedRequesting,
1917                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
1918                         mode_lib->vba.ip.pixel_chunk_size_kbytes,
1919                         mode_lib->vba.ip.rob_buffer_size_kbytes,
1920                         mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
1921                         mode_lib->vba.Output,
1922                         mode_lib->vba.ReadBandwidthLuma,
1923                         mode_lib->vba.ReadBandwidthChroma,
1924                         mode_lib->vba.MaximumSwathWidthLuma,
1925                         mode_lib->vba.MaximumSwathWidthChroma,
1926                         mode_lib->vba.SourceRotation,
1927                         mode_lib->vba.ViewportStationary,
1928                         mode_lib->vba.SourcePixelFormat,
1929                         mode_lib->vba.SurfaceTiling,
1930                         mode_lib->vba.ViewportWidth,
1931                         mode_lib->vba.ViewportHeight,
1932                         mode_lib->vba.ViewportXStartY,
1933                         mode_lib->vba.ViewportYStartY,
1934                         mode_lib->vba.ViewportXStartC,
1935                         mode_lib->vba.ViewportYStartC,
1936                         mode_lib->vba.SurfaceWidthY,
1937                         mode_lib->vba.SurfaceWidthC,
1938                         mode_lib->vba.SurfaceHeightY,
1939                         mode_lib->vba.SurfaceHeightC,
1940                         mode_lib->vba.Read256BlockHeightY,
1941                         mode_lib->vba.Read256BlockHeightC,
1942                         mode_lib->vba.Read256BlockWidthY,
1943                         mode_lib->vba.Read256BlockWidthC,
1944                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_odm_mode,
1945                         mode_lib->vba.BlendingAndTiming,
1946                         mode_lib->vba.BytePerPixelY,
1947                         mode_lib->vba.BytePerPixelC,
1948                         mode_lib->vba.BytePerPixelInDETY,
1949                         mode_lib->vba.BytePerPixelInDETC,
1950                         mode_lib->vba.HActive,
1951                         mode_lib->vba.HRatio,
1952                         mode_lib->vba.HRatioChroma,
1953                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0], /*  Integer DPPPerSurface[] */
1954
1955                         /* Output */
1956                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1], /* Long            swath_width_luma_ub[] */
1957                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2], /* Long            swath_width_chroma_ub[]  */
1958                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[0], /* Long            SwathWidth[]  */
1959                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[1], /* Long            SwathWidthChroma[]  */
1960                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3], /* Integer         SwathHeightY[]  */
1961                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4], /* Integer         SwathHeightC[]  */
1962                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5], /* Long            DETBufferSizeInKByte[]  */
1963                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6], /* Long            DETBufferSizeY[]  */
1964                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7], /* Long            DETBufferSizeC[]  */
1965                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0][0], /* bool           *UnboundedRequestEnabled  */
1966                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0][0], /* Long           *CompressedBufferSizeInkByte  */
1967                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1][0], /* Long           *CompBufReservedSpaceKBytes */
1968                         &CompBufReservedSpaceNeedAdjustmentSingleDPP,
1969                         mode_lib->vba.SingleDPPViewportSizeSupportPerSurface,/* bool ViewportSizeSupportPerSurface[] */
1970                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1][0]); /* bool           *ViewportSizeSupport */
1971
1972         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
1973         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = false;
1974
1975         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1976                 if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_reduce_voltage_and_clocks)
1977                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
1978                 if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_always_when_possible)
1979                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = true;
1980         }
1981         mode_lib->vba.MPCCombineMethodIncompatible = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage
1982                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible;
1983
1984         for (i = 0; i < v->soc.num_states; i++) {
1985                 for (j = 0; j < 2; j++) {
1986                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] = 0;
1987                         mode_lib->vba.TotalAvailablePipesSupport[i][j] = true;
1988                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC = dm_odm_combine_mode_disabled;
1989                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC = dm_odm_combine_mode_disabled;
1990
1991                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1992                                 dml32_CalculateODMMode(
1993                                                 mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
1994                                                 mode_lib->vba.HActive[k],
1995                                                 mode_lib->vba.OutputFormat[k],
1996                                                 mode_lib->vba.Output[k],
1997                                                 mode_lib->vba.ODMUse[k],
1998                                                 mode_lib->vba.MaxDispclk[i],
1999                                                 mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
2000                                                 false,
2001                                                 mode_lib->vba.TotalNumberOfActiveDPP[i][j],
2002                                                 mode_lib->vba.MaxNumDPP,
2003                                                 mode_lib->vba.PixelClock[k],
2004                                                 mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2005                                                 mode_lib->vba.DISPCLKRampingMargin,
2006                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
2007                                                 mode_lib->vba.NumberOfDSCSlices[k],
2008
2009                                                 /* Output */
2010                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC,
2011                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC,
2012                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
2013                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC);
2014
2015                                 dml32_CalculateODMMode(
2016                                                 mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
2017                                                 mode_lib->vba.HActive[k],
2018                                                 mode_lib->vba.OutputFormat[k],
2019                                                 mode_lib->vba.Output[k],
2020                                                 mode_lib->vba.ODMUse[k],
2021                                                 mode_lib->vba.MaxDispclk[i],
2022                                                 mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
2023                                                 true,
2024                                                 mode_lib->vba.TotalNumberOfActiveDPP[i][j],
2025                                                 mode_lib->vba.MaxNumDPP,
2026                                                 mode_lib->vba.PixelClock[k],
2027                                                 mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2028                                                 mode_lib->vba.DISPCLKRampingMargin,
2029                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
2030                                                 mode_lib->vba.NumberOfDSCSlices[k],
2031
2032                                                 /* Output */
2033                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC,
2034                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC,
2035                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2036                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC);
2037
2038                                 dml32_CalculateOutputLink(
2039                                                 mode_lib->vba.PHYCLKPerState[i],
2040                                                 mode_lib->vba.PHYCLKD18PerState[i],
2041                                                 mode_lib->vba.PHYCLKD32PerState[i],
2042                                                 mode_lib->vba.Downspreading,
2043                                                 (mode_lib->vba.BlendingAndTiming[k] == k),
2044                                                 mode_lib->vba.Output[k],
2045                                                 mode_lib->vba.OutputFormat[k],
2046                                                 mode_lib->vba.HTotal[k],
2047                                                 mode_lib->vba.HActive[k],
2048                                                 mode_lib->vba.PixelClockBackEnd[k],
2049                                                 mode_lib->vba.ForcedOutputLinkBPP[k],
2050                                                 mode_lib->vba.DSCInputBitPerComponent[k],
2051                                                 mode_lib->vba.NumberOfDSCSlices[k],
2052                                                 mode_lib->vba.AudioSampleRate[k],
2053                                                 mode_lib->vba.AudioSampleLayout[k],
2054                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
2055                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2056                                                 mode_lib->vba.DSCEnable[k],
2057                                                 mode_lib->vba.OutputLinkDPLanes[k],
2058                                                 mode_lib->vba.OutputLinkDPRate[k],
2059
2060                                                 /* Output */
2061                                                 &mode_lib->vba.RequiresDSC[i][k],
2062                                                 &mode_lib->vba.RequiresFEC[i][k],
2063                                                 &mode_lib->vba.OutputBppPerState[i][k],
2064                                                 &mode_lib->vba.OutputTypePerState[i][k],
2065                                                 &mode_lib->vba.OutputRatePerState[i][k],
2066                                                 &mode_lib->vba.RequiredSlots[i][k]);
2067
2068                                 if (mode_lib->vba.RequiresDSC[i][k] == false) {
2069                                         mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC;
2070                                         mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2071                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC;
2072                                         if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC)
2073                                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2074                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2075                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC;
2076                                 } else {
2077                                         mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC;
2078                                         mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2079                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC;
2080                                         if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC)
2081                                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2082                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2083                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC;
2084                                 }
2085                         }
2086
2087                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2088                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2089                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2090                                         mode_lib->vba.NoOfDPP[i][j][k] = 4;
2091                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2092                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2093                                         mode_lib->vba.NoOfDPP[i][j][k] = 2;
2094                                 } else if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_never) {
2095                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2096                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2097                                 } else if (dml32_RoundToDFSGranularity(
2098                                                 mode_lib->vba.MinDPPCLKUsingSingleDPP[k]
2099                                                                 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
2100                                                                                                 / 100), 1,
2101                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed) <= mode_lib->vba.MaxDppclk[i] &&
2102                                 mode_lib->vba.SingleDPPViewportSizeSupportPerSurface[k] == true) {
2103                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2104                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2105                                 } else if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP) {
2106                                         mode_lib->vba.MPCCombine[i][j][k] = true;
2107                                         mode_lib->vba.NoOfDPP[i][j][k] = 2;
2108                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2109                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2110                                 } else {
2111                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2112                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2113                                         mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2114                                 }
2115                         }
2116
2117                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] = 0;
2118                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = true;
2119
2120                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2121                                 if (mode_lib->vba.NoOfDPP[i][j][k] == 1)
2122                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2123                                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] + 1;
2124                                 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2125                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2126                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_12
2127                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
2128                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = false;
2129                                 }
2130                         }
2131
2132                         // if TotalNumberOfActiveDPP is > 1, then there should be no unbounded req mode (hw limitation), the comp buf reserved adjustment is not needed regardless
2133                         // if TotalNumberOfActiveDPP is == 1, then will use the SingleDPP version of unbounded_req for the decision
2134                         CompBufReservedSpaceNeedAdjustment = (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > 1) ? 0 : CompBufReservedSpaceNeedAdjustmentSingleDPP;
2135
2136
2137
2138                         if (j == 1 && !dml32_UnboundedRequest(mode_lib->vba.UseUnboundedRequesting,
2139                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j], v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma,
2140                                         mode_lib->vba.Output[0],
2141                                         mode_lib->vba.SurfaceTiling[0],
2142                                         CompBufReservedSpaceNeedAdjustment,
2143                                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)) {
2144                                 while (!(mode_lib->vba.TotalNumberOfActiveDPP[i][j] >= mode_lib->vba.MaxNumDPP
2145                                                 || mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] == 0)) {
2146                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2147                                         NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2148
2149                                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2150                                                 if (mode_lib->vba.MPCCombineUse[k]
2151                                                         != dm_mpc_never &&
2152                                                         mode_lib->vba.MPCCombineUse[k] != dm_mpc_reduce_voltage &&
2153                                                         mode_lib->vba.ReadBandwidthLuma[k] +
2154                                                         mode_lib->vba.ReadBandwidthChroma[k] >
2155                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth &&
2156                                                         (mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2157                                                         dm_odm_combine_mode_2to1 &&
2158                                                         mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2159                                                         dm_odm_combine_mode_4to1) &&
2160                                                                 mode_lib->vba.MPCCombine[i][j][k] == false) {
2161                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth =
2162                                                                 mode_lib->vba.ReadBandwidthLuma[k]
2163                                                                 + mode_lib->vba.ReadBandwidthChroma[k];
2164                                                         NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
2165                                                 }
2166                                         }
2167                                         mode_lib->vba.MPCCombine[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] =
2168                                                         true;
2169                                         mode_lib->vba.NoOfDPP[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
2170                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2171                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2172                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2173                                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] - 1;
2174                                 }
2175                         }
2176
2177                         //DISPCLK/DPPCLK
2178                         mode_lib->vba.WritebackRequiredDISPCLK = 0;
2179                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2180                                 if (mode_lib->vba.WritebackEnable[k]) {
2181                                         mode_lib->vba.WritebackRequiredDISPCLK = dml_max(
2182                                                         mode_lib->vba.WritebackRequiredDISPCLK,
2183                                                         dml32_CalculateWriteBackDISPCLK(
2184                                                                         mode_lib->vba.WritebackPixelFormat[k],
2185                                                                         mode_lib->vba.PixelClock[k],
2186                                                                         mode_lib->vba.WritebackHRatio[k],
2187                                                                         mode_lib->vba.WritebackVRatio[k],
2188                                                                         mode_lib->vba.WritebackHTaps[k],
2189                                                                         mode_lib->vba.WritebackVTaps[k],
2190                                                                         mode_lib->vba.WritebackSourceWidth[k],
2191                                                                         mode_lib->vba.WritebackDestinationWidth[k],
2192                                                                         mode_lib->vba.HTotal[k],
2193                                                                         mode_lib->vba.WritebackLineBufferSize,
2194                                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
2195                                 }
2196                         }
2197
2198                         mode_lib->vba.RequiredDISPCLK[i][j] = mode_lib->vba.WritebackRequiredDISPCLK;
2199                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2200                                 mode_lib->vba.RequiredDISPCLK[i][j] = dml_max(mode_lib->vba.RequiredDISPCLK[i][j],
2201                                                 mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k]);
2202                         }
2203
2204                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2205                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2206
2207                         dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces,
2208                                         mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2209                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed, mode_lib->vba.MinDPPCLKUsingSingleDPP,
2210                                         mode_lib->vba.NoOfDPPThisState,
2211                                         /* Output */
2212                                         &mode_lib->vba.GlobalDPPCLK, mode_lib->vba.RequiredDPPCLKThisState);
2213
2214                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2215                                 mode_lib->vba.RequiredDPPCLK[i][j][k] = mode_lib->vba.RequiredDPPCLKThisState[k];
2216
2217                         mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] = !((mode_lib->vba.RequiredDISPCLK[i][j]
2218                                         > mode_lib->vba.MaxDispclk[i])
2219                                         || (mode_lib->vba.GlobalDPPCLK > mode_lib->vba.MaxDppclk[i]));
2220
2221                         if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP)
2222                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2223                 } // j
2224         } // i (VOLTAGE_STATE)
2225
2226         /* Total Available OTG, HDMIFRL, DP Support Check */
2227         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = 0;
2228         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL = 0;
2229         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = 0;
2230         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = 0;
2231
2232         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2233                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2234                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG + 1;
2235                         if (mode_lib->vba.Output[k] == dm_dp2p0) {
2236                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 + 1;
2237                                 if (mode_lib->vba.OutputMultistreamId[k]
2238                                                 == k || mode_lib->vba.OutputMultistreamEn[k] == false) {
2239                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs + 1;
2240                                 }
2241                         }
2242                 }
2243         }
2244
2245         mode_lib->vba.NumberOfOTGSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG);
2246         mode_lib->vba.NumberOfHDMIFRLSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL <= mode_lib->vba.MaxNumHDMIFRLOutputs);
2247         mode_lib->vba.NumberOfDP2p0Support = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 <= mode_lib->vba.MaxNumDP2p0Streams
2248                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs <= mode_lib->vba.MaxNumDP2p0Outputs);
2249
2250         /* Display IO and DSC Support Check */
2251         mode_lib->vba.NonsupportedDSCInputBPC = false;
2252         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2253                 if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
2254                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
2255                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0
2256                                 || mode_lib->vba.DSCInputBitPerComponent[k] >
2257                                 mode_lib->vba.MaximumDSCBitsPerComponent)) {
2258                         mode_lib->vba.NonsupportedDSCInputBPC = true;
2259                 }
2260         }
2261
2262         for (i = 0; i < v->soc.num_states; ++i) {
2263                 mode_lib->vba.ExceededMultistreamSlots[i] = false;
2264                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2265                         if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == k) {
2266                                 TotalSlots = mode_lib->vba.RequiredSlots[i][k];
2267                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2268                                         if (mode_lib->vba.OutputMultistreamId[j] == k)
2269                                                 TotalSlots = TotalSlots + mode_lib->vba.RequiredSlots[i][j];
2270                                 }
2271                                 if (mode_lib->vba.Output[k] == dm_dp && TotalSlots > 63)
2272                                         mode_lib->vba.ExceededMultistreamSlots[i] = true;
2273                                 if (mode_lib->vba.Output[k] == dm_dp2p0 && TotalSlots > 64)
2274                                         mode_lib->vba.ExceededMultistreamSlots[i] = true;
2275                         }
2276                 }
2277                 mode_lib->vba.LinkCapacitySupport[i] = true;
2278                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2279                         if (mode_lib->vba.BlendingAndTiming[k] == k
2280                                         && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2281                                                         || mode_lib->vba.Output[k] == dm_edp
2282                                                         || mode_lib->vba.Output[k] == dm_hdmi)
2283                                         && mode_lib->vba.OutputBppPerState[i][k] == 0) {
2284                                 mode_lib->vba.LinkCapacitySupport[i] = false;
2285                         }
2286                 }
2287         }
2288
2289         mode_lib->vba.P2IWith420 = false;
2290         mode_lib->vba.DSCOnlyIfNecessaryWithBPP = false;
2291         mode_lib->vba.DSC422NativeNotSupported = false;
2292         mode_lib->vba.LinkRateDoesNotMatchDPVersion = false;
2293         mode_lib->vba.LinkRateForMultistreamNotIndicated = false;
2294         mode_lib->vba.BPPForMultistreamNotIndicated = false;
2295         mode_lib->vba.MultistreamWithHDMIOreDP = false;
2296         mode_lib->vba.MSOOrODMSplitWithNonDPLink = false;
2297         mode_lib->vba.NotEnoughLanesForMSO = false;
2298
2299         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2300                 if (mode_lib->vba.BlendingAndTiming[k] == k
2301                                 && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2302                                                 || mode_lib->vba.Output[k] == dm_edp
2303                                                 || mode_lib->vba.Output[k] == dm_hdmi)) {
2304                         if (mode_lib->vba.OutputFormat[k]
2305                                         == dm_420 && mode_lib->vba.Interlace[k] == 1 &&
2306                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)
2307                                 mode_lib->vba.P2IWith420 = true;
2308
2309                         if (mode_lib->vba.DSCEnable[k] && mode_lib->vba.ForcedOutputLinkBPP[k] != 0)
2310                                 mode_lib->vba.DSCOnlyIfNecessaryWithBPP = true;
2311                         if ((mode_lib->vba.DSCEnable[k] || mode_lib->vba.DSCEnable[k])
2312                                         && mode_lib->vba.OutputFormat[k] == dm_n422
2313                                         && !mode_lib->vba.DSC422NativeSupport)
2314                                 mode_lib->vba.DSC422NativeNotSupported = true;
2315
2316                         if (((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr
2317                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr2
2318                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr3)
2319                                         && mode_lib->vba.Output[k] != dm_dp && mode_lib->vba.Output[k] != dm_edp)
2320                                         || ((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr10
2321                                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5
2322                                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr20)
2323                                                         && mode_lib->vba.Output[k] != dm_dp2p0))
2324                                 mode_lib->vba.LinkRateDoesNotMatchDPVersion = true;
2325
2326                         if (mode_lib->vba.OutputMultistreamEn[k] == true) {
2327                                 if (mode_lib->vba.OutputMultistreamId[k] == k
2328                                         && mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_na)
2329                                         mode_lib->vba.LinkRateForMultistreamNotIndicated = true;
2330                                 if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2331                                         mode_lib->vba.BPPForMultistreamNotIndicated = true;
2332                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2333                                         if (mode_lib->vba.OutputMultistreamId[k] == j && mode_lib->vba.OutputMultistreamEn[k]
2334                                                 && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2335                                                 mode_lib->vba.BPPForMultistreamNotIndicated = true;
2336                                 }
2337                         }
2338
2339                         if ((mode_lib->vba.Output[k] == dm_edp || mode_lib->vba.Output[k] == dm_hdmi)) {
2340                                 if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.OutputMultistreamEn[k])
2341                                         mode_lib->vba.MultistreamWithHDMIOreDP = true;
2342
2343                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2344                                         if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == j)
2345                                                 mode_lib->vba.MultistreamWithHDMIOreDP = true;
2346                                 }
2347                         }
2348
2349                         if (mode_lib->vba.Output[k] != dm_dp
2350                                         && (mode_lib->vba.ODMUse[k] == dm_odm_split_policy_1to2
2351                                                         || mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2352                                                         || mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4))
2353                                 mode_lib->vba.MSOOrODMSplitWithNonDPLink = true;
2354
2355                         if ((mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2356                                         && mode_lib->vba.OutputLinkDPLanes[k] < 2)
2357                                         || (mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4
2358                                                         && mode_lib->vba.OutputLinkDPLanes[k] < 4))
2359                                 mode_lib->vba.NotEnoughLanesForMSO = true;
2360                 }
2361         }
2362
2363         for (i = 0; i < v->soc.num_states; ++i) {
2364                 mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = false;
2365                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2366                         if (mode_lib->vba.BlendingAndTiming[k] == k
2367                                         && dml32_RequiredDTBCLK(mode_lib->vba.RequiresDSC[i][k],
2368                                                         mode_lib->vba.PixelClockBackEnd[k],
2369                                                         mode_lib->vba.OutputFormat[k],
2370                                                         mode_lib->vba.OutputBppPerState[i][k],
2371                                                         mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.HTotal[k],
2372                                                         mode_lib->vba.HActive[k], mode_lib->vba.AudioSampleRate[k],
2373                                                         mode_lib->vba.AudioSampleLayout[k])
2374                                                         > mode_lib->vba.DTBCLKPerState[i]) {
2375                                 mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = true;
2376                         }
2377                 }
2378         }
2379
2380         for (i = 0; i < v->soc.num_states; ++i) {
2381                 mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = true;
2382                 mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = true;
2383                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2384                         if (mode_lib->vba.BlendingAndTiming[k] == k
2385                                         && mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1
2386                                         && mode_lib->vba.Output[k] == dm_hdmi) {
2387                                 mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = false;
2388                         }
2389                         if (mode_lib->vba.BlendingAndTiming[k] == k
2390                                         && mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
2391                                         && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_edp
2392                                                         || mode_lib->vba.Output[k] == dm_hdmi)) {
2393                                 mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = false;
2394                         }
2395                 }
2396         }
2397
2398         for (i = 0; i < v->soc.num_states; i++) {
2399                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = false;
2400                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2401                         if (mode_lib->vba.BlendingAndTiming[k] == k) {
2402                                 if (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2403                                                 || mode_lib->vba.Output[k] == dm_edp) {
2404                                         if (mode_lib->vba.OutputFormat[k] == dm_420) {
2405                                                 mode_lib->vba.DSCFormatFactor = 2;
2406                                         } else if (mode_lib->vba.OutputFormat[k] == dm_444) {
2407                                                 mode_lib->vba.DSCFormatFactor = 1;
2408                                         } else if (mode_lib->vba.OutputFormat[k] == dm_n422) {
2409                                                 mode_lib->vba.DSCFormatFactor = 2;
2410                                         } else {
2411                                                 mode_lib->vba.DSCFormatFactor = 1;
2412                                         }
2413                                         if (mode_lib->vba.RequiresDSC[i][k] == true) {
2414                                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2415                                                                 == dm_odm_combine_mode_4to1) {
2416                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 12.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2417                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2418                                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2419                                                                 == dm_odm_combine_mode_2to1) {
2420                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2421                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2422                                                 } else {
2423                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2424                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2425                                                 }
2426                                         }
2427                                 }
2428                         }
2429                 }
2430         }
2431
2432         /* Check DSC Unit and Slices Support */
2433         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2434
2435         for (i = 0; i < v->soc.num_states; ++i) {
2436                 mode_lib->vba.NotEnoughDSCUnits[i] = false;
2437                 mode_lib->vba.NotEnoughDSCSlices[i] = false;
2438                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2439                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = true;
2440                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2441                         if (mode_lib->vba.RequiresDSC[i][k] == true) {
2442                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2443                                         if (mode_lib->vba.HActive[k]
2444                                                         > 4 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2445                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2446                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 4;
2447                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 16)
2448                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2449                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2450                                         if (mode_lib->vba.HActive[k]
2451                                                         > 2 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2452                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2453                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 2;
2454                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 8)
2455                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2456                                 } else {
2457                                         if (mode_lib->vba.HActive[k] > mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2458                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2459                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 1;
2460                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 4)
2461                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2462                                 }
2463                         }
2464                 }
2465                 if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC)
2466                         mode_lib->vba.NotEnoughDSCUnits[i] = true;
2467         }
2468
2469         /*DSC Delay per state*/
2470         for (i = 0; i < v->soc.num_states; ++i) {
2471                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2472                         mode_lib->vba.DSCDelayPerState[i][k] = dml32_DSCDelayRequirement(
2473                                         mode_lib->vba.RequiresDSC[i][k], mode_lib->vba.ODMCombineEnablePerState[i][k],
2474                                         mode_lib->vba.DSCInputBitPerComponent[k],
2475                                         mode_lib->vba.OutputBppPerState[i][k], mode_lib->vba.HActive[k],
2476                                         mode_lib->vba.HTotal[k], mode_lib->vba.NumberOfDSCSlices[k],
2477                                         mode_lib->vba.OutputFormat[k], mode_lib->vba.Output[k],
2478                                         mode_lib->vba.PixelClock[k], mode_lib->vba.PixelClockBackEnd[k]);
2479                 }
2480
2481                 m = 0;
2482
2483                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2484                         for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2485                                 for (j = 0; j <= mode_lib->vba.NumberOfActiveSurfaces - 1; j++) {
2486                                         if (mode_lib->vba.BlendingAndTiming[k] == m &&
2487                                                         mode_lib->vba.RequiresDSC[i][m] == true) {
2488                                                 mode_lib->vba.DSCDelayPerState[i][k] =
2489                                                         mode_lib->vba.DSCDelayPerState[i][m];
2490                                         }
2491                                 }
2492                         }
2493                 }
2494         }
2495
2496         //Calculate Swath, DET Configuration, DCFCLKDeepSleep
2497         //
2498         for (i = 0; i < (int) v->soc.num_states; ++i) {
2499                 for (j = 0; j <= 1; ++j) {
2500                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2501                                 mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2502                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2503                                 mode_lib->vba.ODMCombineEnableThisState[k] =
2504                                                 mode_lib->vba.ODMCombineEnablePerState[i][k];
2505                         }
2506
2507                         dml32_CalculateSwathAndDETConfiguration(
2508                                         mode_lib->vba.DETSizeOverride,
2509                                         mode_lib->vba.UsesMALLForPStateChange,
2510                                         mode_lib->vba.ConfigReturnBufferSizeInKByte,
2511                                         mode_lib->vba.MaxTotalDETInKByte,
2512                                         mode_lib->vba.MinCompressedBufferSizeInKByte,
2513                                         false, /* ForceSingleDPP */
2514                                         mode_lib->vba.NumberOfActiveSurfaces,
2515                                         mode_lib->vba.nomDETInKByte,
2516                                         mode_lib->vba.UseUnboundedRequesting,
2517                                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
2518                                         mode_lib->vba.ip.pixel_chunk_size_kbytes,
2519                                         mode_lib->vba.ip.rob_buffer_size_kbytes,
2520                                         mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
2521                                         mode_lib->vba.Output,
2522                                         mode_lib->vba.ReadBandwidthLuma,
2523                                         mode_lib->vba.ReadBandwidthChroma,
2524                                         mode_lib->vba.MaximumSwathWidthLuma,
2525                                         mode_lib->vba.MaximumSwathWidthChroma,
2526                                         mode_lib->vba.SourceRotation,
2527                                         mode_lib->vba.ViewportStationary,
2528                                         mode_lib->vba.SourcePixelFormat,
2529                                         mode_lib->vba.SurfaceTiling,
2530                                         mode_lib->vba.ViewportWidth,
2531                                         mode_lib->vba.ViewportHeight,
2532                                         mode_lib->vba.ViewportXStartY,
2533                                         mode_lib->vba.ViewportYStartY,
2534                                         mode_lib->vba.ViewportXStartC,
2535                                         mode_lib->vba.ViewportYStartC,
2536                                         mode_lib->vba.SurfaceWidthY,
2537                                         mode_lib->vba.SurfaceWidthC,
2538                                         mode_lib->vba.SurfaceHeightY,
2539                                         mode_lib->vba.SurfaceHeightC,
2540                                         mode_lib->vba.Read256BlockHeightY,
2541                                         mode_lib->vba.Read256BlockHeightC,
2542                                         mode_lib->vba.Read256BlockWidthY,
2543                                         mode_lib->vba.Read256BlockWidthC,
2544                                         mode_lib->vba.ODMCombineEnableThisState,
2545                                         mode_lib->vba.BlendingAndTiming,
2546                                         mode_lib->vba.BytePerPixelY,
2547                                         mode_lib->vba.BytePerPixelC,
2548                                         mode_lib->vba.BytePerPixelInDETY,
2549                                         mode_lib->vba.BytePerPixelInDETC,
2550                                         mode_lib->vba.HActive,
2551                                         mode_lib->vba.HRatio,
2552                                         mode_lib->vba.HRatioChroma,
2553                                         mode_lib->vba.NoOfDPPThisState,
2554                                         /* Output */
2555                                         mode_lib->vba.swath_width_luma_ub_this_state,
2556                                         mode_lib->vba.swath_width_chroma_ub_this_state,
2557                                         mode_lib->vba.SwathWidthYThisState,
2558                                         mode_lib->vba.SwathWidthCThisState,
2559                                         mode_lib->vba.SwathHeightYThisState,
2560                                         mode_lib->vba.SwathHeightCThisState,
2561                                         mode_lib->vba.DETBufferSizeInKByteThisState,
2562                                         mode_lib->vba.DETBufferSizeYThisState,
2563                                         mode_lib->vba.DETBufferSizeCThisState,
2564                                         &mode_lib->vba.UnboundedRequestEnabledThisState,
2565                                         &mode_lib->vba.CompressedBufferSizeInkByteThisState,
2566                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], /* Long CompBufReservedSpaceKBytes */
2567                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean[0], /* bool CompBufReservedSpaceNeedAdjustment */
2568                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0],
2569                                         &mode_lib->vba.ViewportSizeSupport[i][j]);
2570
2571                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2572                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k] =
2573                                                 mode_lib->vba.swath_width_luma_ub_this_state[k];
2574                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k] =
2575                                                 mode_lib->vba.swath_width_chroma_ub_this_state[k];
2576                                 mode_lib->vba.SwathWidthYAllStates[i][j][k] = mode_lib->vba.SwathWidthYThisState[k];
2577                                 mode_lib->vba.SwathWidthCAllStates[i][j][k] = mode_lib->vba.SwathWidthCThisState[k];
2578                                 mode_lib->vba.SwathHeightYAllStates[i][j][k] = mode_lib->vba.SwathHeightYThisState[k];
2579                                 mode_lib->vba.SwathHeightCAllStates[i][j][k] = mode_lib->vba.SwathHeightCThisState[k];
2580                                 mode_lib->vba.UnboundedRequestEnabledAllStates[i][j] =
2581                                                 mode_lib->vba.UnboundedRequestEnabledThisState;
2582                                 mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j] =
2583                                                 mode_lib->vba.CompressedBufferSizeInkByteThisState;
2584                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k] =
2585                                                 mode_lib->vba.DETBufferSizeInKByteThisState[k];
2586                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k] =
2587                                                 mode_lib->vba.DETBufferSizeYThisState[k];
2588                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k] =
2589                                                 mode_lib->vba.DETBufferSizeCThisState[k];
2590                         }
2591                 }
2592         }
2593
2594         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2595                 mode_lib->vba.cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0]
2596                                 * mode_lib->vba.CursorBPP[k][0] / 8.0
2597                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
2598         }
2599
2600         dml32_CalculateSurfaceSizeInMall(
2601                         mode_lib->vba.NumberOfActiveSurfaces,
2602                         mode_lib->vba.MALLAllocatedForDCNFinal,
2603                         mode_lib->vba.UseMALLForStaticScreen,
2604                         mode_lib->vba.DCCEnable,
2605                         mode_lib->vba.ViewportStationary,
2606                         mode_lib->vba.ViewportXStartY,
2607                         mode_lib->vba.ViewportYStartY,
2608                         mode_lib->vba.ViewportXStartC,
2609                         mode_lib->vba.ViewportYStartC,
2610                         mode_lib->vba.ViewportWidth,
2611                         mode_lib->vba.ViewportHeight,
2612                         mode_lib->vba.BytePerPixelY,
2613                         mode_lib->vba.ViewportWidthChroma,
2614                         mode_lib->vba.ViewportHeightChroma,
2615                         mode_lib->vba.BytePerPixelC,
2616                         mode_lib->vba.SurfaceWidthY,
2617                         mode_lib->vba.SurfaceWidthC,
2618                         mode_lib->vba.SurfaceHeightY,
2619                         mode_lib->vba.SurfaceHeightC,
2620                         mode_lib->vba.Read256BlockWidthY,
2621                         mode_lib->vba.Read256BlockWidthC,
2622                         mode_lib->vba.Read256BlockHeightY,
2623                         mode_lib->vba.Read256BlockHeightC,
2624                         mode_lib->vba.MacroTileWidthY,
2625                         mode_lib->vba.MacroTileWidthC,
2626                         mode_lib->vba.MacroTileHeightY,
2627                         mode_lib->vba.MacroTileHeightC,
2628
2629                         /* Output */
2630                         mode_lib->vba.SurfaceSizeInMALL,
2631                         &mode_lib->vba.ExceededMALLSize);
2632
2633         for (i = 0; i < v->soc.num_states; i++) {
2634                 for (j = 0; j < 2; j++) {
2635                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2636                                 mode_lib->vba.swath_width_luma_ub_this_state[k] =
2637                                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
2638                                 mode_lib->vba.swath_width_chroma_ub_this_state[k] =
2639                                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
2640                                 mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
2641                                 mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
2642                                 mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
2643                                 mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
2644                                 mode_lib->vba.DETBufferSizeInKByteThisState[k] =
2645                                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
2646                                 mode_lib->vba.DETBufferSizeYThisState[k] =
2647                                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
2648                                 mode_lib->vba.DETBufferSizeCThisState[k] =
2649                                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
2650                                 mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2651                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2652                         }
2653
2654                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] = 0;
2655                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2656                                 if (mode_lib->vba.DCCEnable[k] == true) {
2657                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] =
2658                                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
2659                                                                         + mode_lib->vba.NoOfDPP[i][j][k];
2660                                 }
2661                         }
2662
2663
2664                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2665                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
2666                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
2667                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
2668                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
2669                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
2670                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
2671                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
2672                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
2673                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
2674                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthY = mode_lib->vba.MacroTileWidthY[k];
2675                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightY = mode_lib->vba.MacroTileHeightY[k];
2676                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthC = mode_lib->vba.MacroTileWidthC[k];
2677                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightC = mode_lib->vba.MacroTileHeightC[k];
2678                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
2679                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].HTotal = mode_lib->vba.HTotal[k];
2680                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
2681                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
2682                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
2683                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
2684                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
2685                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ProgressiveToInterlaceUnitInOPP =
2686                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
2687                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatio = mode_lib->vba.VRatio[k];
2688                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
2689                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTaps = mode_lib->vba.vtaps[k];
2690                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
2691                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchY = mode_lib->vba.PitchY[k];
2692                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
2693                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchC = mode_lib->vba.PitchC[k];
2694                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
2695                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
2696                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
2697                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
2698                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
2699                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
2700                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
2701                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightY = mode_lib->vba.SwathHeightYThisState[k];
2702                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightC = mode_lib->vba.SwathHeightCThisState[k];
2703                         }
2704
2705                         {
2706                                 dml32_CalculateVMRowAndSwath(
2707                                                 mode_lib->vba.NumberOfActiveSurfaces,
2708                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters,
2709                                                 mode_lib->vba.SurfaceSizeInMALL,
2710                                                 mode_lib->vba.PTEBufferSizeInRequestsLuma,
2711                                                 mode_lib->vba.PTEBufferSizeInRequestsChroma,
2712                                                 mode_lib->vba.DCCMetaBufferSizeBytes,
2713                                                 mode_lib->vba.UseMALLForStaticScreen,
2714                                                 mode_lib->vba.UsesMALLForPStateChange,
2715                                                 mode_lib->vba.MALLAllocatedForDCNFinal,
2716                                                 mode_lib->vba.SwathWidthYThisState,
2717                                                 mode_lib->vba.SwathWidthCThisState,
2718                                                 mode_lib->vba.GPUVMEnable,
2719                                                 mode_lib->vba.HostVMEnable,
2720                                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
2721                                                 mode_lib->vba.GPUVMMaxPageTableLevels,
2722                                                 mode_lib->vba.GPUVMMinPageSizeKBytes,
2723                                                 mode_lib->vba.HostVMMinPageSize,
2724
2725                                                 /* Output */
2726                                                 mode_lib->vba.PTEBufferSizeNotExceededPerState,
2727                                                 mode_lib->vba.DCCMetaBufferSizeNotExceededPerState,
2728                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0],
2729                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1],
2730                                                 mode_lib->vba.dpte_row_height,
2731                                                 mode_lib->vba.dpte_row_height_chroma,
2732                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2],
2733                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3],
2734                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4],
2735                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5],
2736                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6],
2737                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7],
2738                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[8],
2739                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[9],
2740                                                 mode_lib->vba.meta_row_height,
2741                                                 mode_lib->vba.meta_row_height_chroma,
2742                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[10],
2743                                                 mode_lib->vba.dpte_group_bytes,
2744                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[11],
2745                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[12],
2746                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[13],
2747                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[14],
2748                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[15],
2749                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[16],
2750                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[17],
2751                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[18],
2752                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[19],
2753                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[20],
2754                                                 mode_lib->vba.PrefetchLinesYThisState,
2755                                                 mode_lib->vba.PrefetchLinesCThisState,
2756                                                 mode_lib->vba.PrefillY,
2757                                                 mode_lib->vba.PrefillC,
2758                                                 mode_lib->vba.MaxNumSwY,
2759                                                 mode_lib->vba.MaxNumSwC,
2760                                                 mode_lib->vba.meta_row_bandwidth_this_state,
2761                                                 mode_lib->vba.dpte_row_bandwidth_this_state,
2762                                                 mode_lib->vba.DPTEBytesPerRowThisState,
2763                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState,
2764                                                 mode_lib->vba.MetaRowBytesThisState,
2765                                                 mode_lib->vba.use_one_row_for_frame_this_state,
2766                                                 mode_lib->vba.use_one_row_for_frame_flip_this_state,
2767                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0], // Boolean UsesMALLForStaticScreen[]
2768                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1], // Boolean PTE_BUFFER_MODE[]
2769                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[21]); // Long BIGK_FRAGMENT_SIZE[]
2770                         }
2771
2772                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2773                                 mode_lib->vba.PrefetchLinesY[i][j][k] = mode_lib->vba.PrefetchLinesYThisState[k];
2774                                 mode_lib->vba.PrefetchLinesC[i][j][k] = mode_lib->vba.PrefetchLinesCThisState[k];
2775                                 mode_lib->vba.meta_row_bandwidth[i][j][k] =
2776                                                 mode_lib->vba.meta_row_bandwidth_this_state[k];
2777                                 mode_lib->vba.dpte_row_bandwidth[i][j][k] =
2778                                                 mode_lib->vba.dpte_row_bandwidth_this_state[k];
2779                                 mode_lib->vba.DPTEBytesPerRow[i][j][k] = mode_lib->vba.DPTEBytesPerRowThisState[k];
2780                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k] =
2781                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState[k];
2782                                 mode_lib->vba.MetaRowBytes[i][j][k] = mode_lib->vba.MetaRowBytesThisState[k];
2783                                 mode_lib->vba.use_one_row_for_frame[i][j][k] =
2784                                                 mode_lib->vba.use_one_row_for_frame_this_state[k];
2785                                 mode_lib->vba.use_one_row_for_frame_flip[i][j][k] =
2786                                                 mode_lib->vba.use_one_row_for_frame_flip_this_state[k];
2787                         }
2788
2789                         mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = true;
2790                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2791                                 if (mode_lib->vba.PTEBufferSizeNotExceededPerState[k] == false)
2792                                         mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = false;
2793                         }
2794
2795                         mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = true;
2796                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2797                                 if (mode_lib->vba.DCCMetaBufferSizeNotExceededPerState[k] == false)
2798                                         mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = false;
2799                         }
2800
2801                         mode_lib->vba.UrgLatency[i] = dml32_CalculateUrgentLatency(
2802                                         mode_lib->vba.UrgentLatencyPixelDataOnly,
2803                                         mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
2804                                         mode_lib->vba.UrgentLatencyVMDataOnly, mode_lib->vba.DoUrgentLatencyAdjustment,
2805                                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
2806                                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
2807                                         mode_lib->vba.FabricClockPerState[i]);
2808
2809                         //bool   NotUrgentLatencyHiding[DC__NUM_DPP__MAX];
2810                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2811                                 dml32_CalculateUrgentBurstFactor(
2812                                                 mode_lib->vba.UsesMALLForPStateChange[k],
2813                                                 mode_lib->vba.swath_width_luma_ub_this_state[k],
2814                                                 mode_lib->vba.swath_width_chroma_ub_this_state[k],
2815                                                 mode_lib->vba.SwathHeightYThisState[k],
2816                                                 mode_lib->vba.SwathHeightCThisState[k],
2817                                                 (double) mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2818                                                 mode_lib->vba.UrgLatency[i],
2819                                                 mode_lib->vba.CursorBufferSize,
2820                                                 mode_lib->vba.CursorWidth[k][0],
2821                                                 mode_lib->vba.CursorBPP[k][0],
2822                                                 mode_lib->vba.VRatio[k],
2823                                                 mode_lib->vba.VRatioChroma[k],
2824                                                 mode_lib->vba.BytePerPixelInDETY[k],
2825                                                 mode_lib->vba.BytePerPixelInDETC[k],
2826                                                 mode_lib->vba.DETBufferSizeYThisState[k],
2827                                                 mode_lib->vba.DETBufferSizeCThisState[k],
2828                                                 /* Output */
2829                                                 &mode_lib->vba.UrgentBurstFactorCursor[k],
2830                                                 &mode_lib->vba.UrgentBurstFactorLuma[k],
2831                                                 &mode_lib->vba.UrgentBurstFactorChroma[k],
2832                                                 &mode_lib->vba.NoUrgentLatencyHiding[k]);
2833                         }
2834
2835                         dml32_CalculateDCFCLKDeepSleep(
2836                                         mode_lib->vba.NumberOfActiveSurfaces,
2837                                         mode_lib->vba.BytePerPixelY,
2838                                         mode_lib->vba.BytePerPixelC,
2839                                         mode_lib->vba.VRatio,
2840                                         mode_lib->vba.VRatioChroma,
2841                                         mode_lib->vba.SwathWidthYThisState,
2842                                         mode_lib->vba.SwathWidthCThisState,
2843                                         mode_lib->vba.NoOfDPPThisState,
2844                                         mode_lib->vba.HRatio,
2845                                         mode_lib->vba.HRatioChroma,
2846                                         mode_lib->vba.PixelClock,
2847                                         mode_lib->vba.PSCL_FACTOR,
2848                                         mode_lib->vba.PSCL_FACTOR_CHROMA,
2849                                         mode_lib->vba.RequiredDPPCLKThisState,
2850                                         mode_lib->vba.ReadBandwidthLuma,
2851                                         mode_lib->vba.ReadBandwidthChroma,
2852                                         mode_lib->vba.ReturnBusWidth,
2853
2854                                         /* Output */
2855                                         &mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j]);
2856                 }
2857         }
2858
2859         m = 0;
2860
2861         //Calculate Return BW
2862         for (i = 0; i < (int) v->soc.num_states; ++i) {
2863                 for (j = 0; j <= 1; ++j) {
2864                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2865                                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2866                                         if (mode_lib->vba.WritebackEnable[k] == true) {
2867                                                 mode_lib->vba.WritebackDelayTime[k] =
2868                                                         mode_lib->vba.WritebackLatency
2869                                                 + dml32_CalculateWriteBackDelay(
2870                                                         mode_lib->vba.WritebackPixelFormat[k],
2871                                                         mode_lib->vba.WritebackHRatio[k],
2872                                                         mode_lib->vba.WritebackVRatio[k],
2873                                                         mode_lib->vba.WritebackVTaps[k],
2874                                                         mode_lib->vba.WritebackDestinationWidth[k],
2875                                                         mode_lib->vba.WritebackDestinationHeight[k],
2876                                                         mode_lib->vba.WritebackSourceHeight[k],
2877                                                         mode_lib->vba.HTotal[k])
2878                                                         / mode_lib->vba.RequiredDISPCLK[i][j];
2879                                         } else {
2880                                                 mode_lib->vba.WritebackDelayTime[k] = 0.0;
2881                                         }
2882                                         for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2883                                                 if (mode_lib->vba.BlendingAndTiming[m]
2884                                                                 == k && mode_lib->vba.WritebackEnable[m] == true) {
2885                                                         mode_lib->vba.WritebackDelayTime[k] =
2886                                                                 dml_max(mode_lib->vba.WritebackDelayTime[k],
2887                                                                         mode_lib->vba.WritebackLatency
2888                                                                 + dml32_CalculateWriteBackDelay(
2889                                                                         mode_lib->vba.WritebackPixelFormat[m],
2890                                                                         mode_lib->vba.WritebackHRatio[m],
2891                                                                         mode_lib->vba.WritebackVRatio[m],
2892                                                                         mode_lib->vba.WritebackVTaps[m],
2893                                                                         mode_lib->vba.WritebackDestinationWidth[m],
2894                                                                         mode_lib->vba.WritebackDestinationHeight[m],
2895                                                                         mode_lib->vba.WritebackSourceHeight[m],
2896                                                                         mode_lib->vba.HTotal[m]) /
2897                                                                         mode_lib->vba.RequiredDISPCLK[i][j]);
2898                                                 }
2899                                         }
2900                                 }
2901                         }
2902                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2903                                 for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2904                                         if (mode_lib->vba.BlendingAndTiming[k] == m) {
2905                                                 mode_lib->vba.WritebackDelayTime[k] =
2906                                                                 mode_lib->vba.WritebackDelayTime[m];
2907                                         }
2908                                 }
2909                         }
2910                         mode_lib->vba.MaxMaxVStartup[i][j] = 0;
2911                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2912                                 mode_lib->vba.MaximumVStartup[i][j][k] = ((mode_lib->vba.Interlace[k] &&
2913                                                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
2914                                                                 dml_floor((mode_lib->vba.VTotal[k] -
2915                                                                         mode_lib->vba.VActive[k]) / 2.0, 1.0) :
2916                                                                 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k])
2917                                                                 - dml_max(1.0, dml_ceil(1.0 *
2918                                                                         mode_lib->vba.WritebackDelayTime[k] /
2919                                                                         (mode_lib->vba.HTotal[k] /
2920                                                                         mode_lib->vba.PixelClock[k]), 1.0));
2921
2922                                 // Clamp to max OTG vstartup register limit
2923                                 if (mode_lib->vba.MaximumVStartup[i][j][k] > 1023)
2924                                         mode_lib->vba.MaximumVStartup[i][j][k] = 1023;
2925
2926                                 mode_lib->vba.MaxMaxVStartup[i][j] = dml_max(mode_lib->vba.MaxMaxVStartup[i][j],
2927                                                 mode_lib->vba.MaximumVStartup[i][j][k]);
2928                         }
2929                 }
2930         }
2931
2932         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes = mode_lib->vba.NumberOfChannels
2933                         * dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2934                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2935                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
2936
2937         dml32_CalculateMinAndMaxPrefetchMode(mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
2938                         &mode_lib->vba.MinPrefetchMode,
2939                         &mode_lib->vba.MaxPrefetchMode);
2940
2941         for (i = 0; i < (int) v->soc.num_states; ++i) {
2942                 for (j = 0; j <= 1; ++j)
2943                         mode_lib->vba.DCFCLKState[i][j] = mode_lib->vba.DCFCLKPerState[i];
2944         }
2945
2946         /* Immediate Flip and MALL parameters */
2947         mode_lib->vba.ImmediateFlipRequiredFinal = false;
2948         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2949                 mode_lib->vba.ImmediateFlipRequiredFinal = mode_lib->vba.ImmediateFlipRequiredFinal
2950                                 || (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
2951         }
2952
2953         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
2954         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2955                 mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
2956                                 mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
2957                                                 || ((mode_lib->vba.ImmediateFlipRequirement[k]
2958                                                                 != dm_immediate_flip_required)
2959                                                                 && (mode_lib->vba.ImmediateFlipRequirement[k]
2960                                                                                 != dm_immediate_flip_not_required));
2961         }
2962         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
2963                         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
2964                                         && mode_lib->vba.ImmediateFlipRequiredFinal;
2965
2966         mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
2967         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2968                 mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
2969                         mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe ||
2970                         ((mode_lib->vba.HostVMEnable == true || mode_lib->vba.ImmediateFlipRequirement[k] !=
2971                                         dm_immediate_flip_not_required) &&
2972                         (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame ||
2973                         mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe));
2974         }
2975
2976         mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
2977         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2978                 mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen =
2979                         mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
2980                         || ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable
2981                         || mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
2982                         && (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe))
2983                         || ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_disable
2984                         || mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
2985                         && (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame));
2986         }
2987
2988         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = false;
2989         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = false;
2990         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = false;
2991
2992         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2993                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame)
2994                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = true;
2995                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport)
2996                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = true;
2997                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe)
2998                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = true;
2999         }
3000         mode_lib->vba.InvalidCombinationOfMALLUseForPState = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod
3001                         != v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod) || (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod);
3002
3003         if (mode_lib->vba.UseMinimumRequiredDCFCLK == true) {
3004                 dml32_UseMinimumDCFCLK(
3005                                 mode_lib->vba.UsesMALLForPStateChange,
3006                                 mode_lib->vba.DRRDisplay,
3007                                 mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3008                                 mode_lib->vba.MaxInterDCNTileRepeaters,
3009                                 mode_lib->vba.MaxPrefetchMode,
3010                                 mode_lib->vba.DRAMClockChangeLatency,
3011                                 mode_lib->vba.FCLKChangeLatency,
3012                                 mode_lib->vba.SREnterPlusExitTime,
3013                                 mode_lib->vba.ReturnBusWidth,
3014                                 mode_lib->vba.RoundTripPingLatencyCycles,
3015                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
3016                                 mode_lib->vba.PixelChunkSizeInKByte,
3017                                 mode_lib->vba.MetaChunkSize,
3018                                 mode_lib->vba.GPUVMEnable,
3019                                 mode_lib->vba.GPUVMMaxPageTableLevels,
3020                                 mode_lib->vba.HostVMEnable,
3021                                 mode_lib->vba.NumberOfActiveSurfaces,
3022                                 mode_lib->vba.HostVMMinPageSize,
3023                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3024                                 mode_lib->vba.DynamicMetadataVMEnabled,
3025                                 mode_lib->vba.ImmediateFlipRequiredFinal,
3026                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
3027                                 mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
3028                                 mode_lib->vba.PercentOfIdealFabricAndSDPPortBWReceivedAfterUrgLatency,
3029                                 mode_lib->vba.VTotal,
3030                                 mode_lib->vba.VActive,
3031                                 mode_lib->vba.DynamicMetadataTransmittedBytes,
3032                                 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired,
3033                                 mode_lib->vba.Interlace,
3034                                 mode_lib->vba.RequiredDPPCLK,
3035                                 mode_lib->vba.RequiredDISPCLK,
3036                                 mode_lib->vba.UrgLatency,
3037                                 mode_lib->vba.NoOfDPP,
3038                                 mode_lib->vba.ProjectedDCFCLKDeepSleep,
3039                                 mode_lib->vba.MaximumVStartup,
3040                                 mode_lib->vba.TotalNumberOfActiveDPP,
3041                                 mode_lib->vba.TotalNumberOfDCCActiveDPP,
3042                                 mode_lib->vba.dpte_group_bytes,
3043                                 mode_lib->vba.PrefetchLinesY,
3044                                 mode_lib->vba.PrefetchLinesC,
3045                                 mode_lib->vba.swath_width_luma_ub_all_states,
3046                                 mode_lib->vba.swath_width_chroma_ub_all_states,
3047                                 mode_lib->vba.BytePerPixelY,
3048                                 mode_lib->vba.BytePerPixelC,
3049                                 mode_lib->vba.HTotal,
3050                                 mode_lib->vba.PixelClock,
3051                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrame,
3052                                 mode_lib->vba.DPTEBytesPerRow,
3053                                 mode_lib->vba.MetaRowBytes,
3054                                 mode_lib->vba.DynamicMetadataEnable,
3055                                 mode_lib->vba.ReadBandwidthLuma,
3056                                 mode_lib->vba.ReadBandwidthChroma,
3057                                 mode_lib->vba.DCFCLKPerState,
3058
3059                                 /* Output */
3060                                 mode_lib->vba.DCFCLKState);
3061         } // UseMinimumRequiredDCFCLK == true
3062
3063         for (i = 0; i < (int) v->soc.num_states; ++i) {
3064                 for (j = 0; j <= 1; ++j) {
3065                         mode_lib->vba.ReturnBWPerState[i][j] = dml32_get_return_bw_mbps(&mode_lib->vba.soc, i,
3066                                         mode_lib->vba.HostVMEnable, mode_lib->vba.DCFCLKState[i][j],
3067                                         mode_lib->vba.FabricClockPerState[i], mode_lib->vba.DRAMSpeedPerState[i]);
3068                 }
3069         }
3070
3071         //Re-ordering Buffer Support Check
3072         for (i = 0; i < (int) v->soc.num_states; ++i) {
3073                 for (j = 0; j <= 1; ++j) {
3074                         if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024
3075                                         / mode_lib->vba.ReturnBWPerState[i][j]
3076                                         > (mode_lib->vba.RoundTripPingLatencyCycles + 32)
3077                                                         / mode_lib->vba.DCFCLKState[i][j]
3078                                                         + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes / mode_lib->vba.ReturnBWPerState[i][j]) {
3079                                 mode_lib->vba.ROBSupport[i][j] = true;
3080                         } else {
3081                                 mode_lib->vba.ROBSupport[i][j] = false;
3082                         }
3083                 }
3084         }
3085
3086         //Vertical Active BW support check
3087         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth = 0;
3088
3089         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3090                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth += mode_lib->vba.ReadBandwidthLuma[k]
3091                                 + mode_lib->vba.ReadBandwidthChroma[k];
3092         }
3093
3094         for (i = 0; i < (int) v->soc.num_states; ++i) {
3095                 for (j = 0; j <= 1; ++j) {
3096                         mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j] =
3097                                 dml_min3(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKState[i][j]
3098                                         * mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
3099                                         mode_lib->vba.FabricClockPerState[i]
3100                                         * mode_lib->vba.FabricDatapathToDCNDataReturn
3101                                         * mode_lib->vba.MaxAveragePercentOfIdealFabricBWDisplayCanUseInNormalSystemOperation / 100,
3102                                         mode_lib->vba.DRAMSpeedPerState[i]
3103                                         * mode_lib->vba.NumberOfChannels
3104                                         * mode_lib->vba.DRAMChannelWidth
3105                                         * (i < 2 ? mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperationSTROBE : mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation) / 100);
3106
3107                         if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth
3108                                         <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
3109                                 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = true;
3110                         } else {
3111                                 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = false;
3112                         }
3113                 }
3114         }
3115
3116         /* Prefetch Check */
3117
3118         for (i = 0; i < (int) v->soc.num_states; ++i) {
3119                 for (j = 0; j <= 1; ++j) {
3120
3121                         mode_lib->vba.TimeCalc = 24 / mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3122
3123                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3124                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
3125                                 mode_lib->vba.swath_width_luma_ub_this_state[k] =
3126                                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
3127                                 mode_lib->vba.swath_width_chroma_ub_this_state[k] =
3128                                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
3129                                 mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
3130                                 mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
3131                                 mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
3132                                 mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
3133                                 mode_lib->vba.UnboundedRequestEnabledThisState =
3134                                                 mode_lib->vba.UnboundedRequestEnabledAllStates[i][j];
3135                                 mode_lib->vba.CompressedBufferSizeInkByteThisState =
3136                                                 mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j];
3137                                 mode_lib->vba.DETBufferSizeInKByteThisState[k] =
3138                                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
3139                                 mode_lib->vba.DETBufferSizeYThisState[k] =
3140                                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
3141                                 mode_lib->vba.DETBufferSizeCThisState[k] =
3142                                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
3143                         }
3144
3145                         mode_lib->vba.VActiveBandwithSupport[i][j] = dml32_CalculateVActiveBandwithSupport(
3146                                         mode_lib->vba.NumberOfActiveSurfaces,
3147                                         mode_lib->vba.ReturnBWPerState[i][j],
3148                                         mode_lib->vba.NoUrgentLatencyHiding,
3149                                         mode_lib->vba.ReadBandwidthLuma,
3150                                         mode_lib->vba.ReadBandwidthChroma,
3151                                         mode_lib->vba.cursor_bw,
3152                                         mode_lib->vba.meta_row_bandwidth_this_state,
3153                                         mode_lib->vba.dpte_row_bandwidth_this_state,
3154                                         mode_lib->vba.NoOfDPPThisState,
3155                                         mode_lib->vba.UrgentBurstFactorLuma,
3156                                         mode_lib->vba.UrgentBurstFactorChroma,
3157                                         mode_lib->vba.UrgentBurstFactorCursor);
3158
3159                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState = dml32_get_return_bw_mbps_vm_only(&mode_lib->vba.soc, i,
3160                                         mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.FabricClockPerState[i],
3161                                         mode_lib->vba.DRAMSpeedPerState[i]);
3162                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = 1;
3163
3164                         if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
3165                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = mode_lib->vba.ReturnBWPerState[i][j]
3166                                                 / v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState;
3167
3168                         mode_lib->vba.ExtraLatency = dml32_CalculateExtraLatency(
3169                                         mode_lib->vba.RoundTripPingLatencyCycles, v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
3170                                         mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.TotalNumberOfActiveDPP[i][j],
3171                                         mode_lib->vba.PixelChunkSizeInKByte,
3172                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j], mode_lib->vba.MetaChunkSize,
3173                                         mode_lib->vba.ReturnBWPerState[i][j], mode_lib->vba.GPUVMEnable,
3174                                         mode_lib->vba.HostVMEnable, mode_lib->vba.NumberOfActiveSurfaces,
3175                                         mode_lib->vba.NoOfDPPThisState, mode_lib->vba.dpte_group_bytes,
3176                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor, mode_lib->vba.HostVMMinPageSize,
3177                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
3178
3179                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = mode_lib->vba.MinPrefetchMode;
3180
3181                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3182
3183                         do {
3184                                 mode_lib->vba.PrefetchModePerState[i][j] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState;
3185                                 mode_lib->vba.MaxVStartup = mode_lib->vba.NextMaxVStartup;
3186
3187                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3188                                         mode_lib->vba.TWait = dml32_CalculateTWait(
3189                                                         mode_lib->vba.PrefetchModePerState[i][j],
3190                                                         mode_lib->vba.UsesMALLForPStateChange[k],
3191                                                         mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3192                                                         mode_lib->vba.DRRDisplay[k],
3193                                                         mode_lib->vba.DRAMClockChangeLatency,
3194                                                         mode_lib->vba.FCLKChangeLatency, mode_lib->vba.UrgLatency[i],
3195                                                         mode_lib->vba.SREnterPlusExitTime);
3196
3197                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dppclk = mode_lib->vba.RequiredDPPCLK[i][j][k];
3198                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dispclk = mode_lib->vba.RequiredDISPCLK[i][j];
3199                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
3200                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCFClkDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3201                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
3202                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
3203                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
3204                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
3205                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
3206                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
3207                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
3208                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
3209                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
3210                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
3211                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HTotal = mode_lib->vba.HTotal[k];
3212                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HActive = mode_lib->vba.HActive[k];
3213                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
3214                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ODMMode = mode_lib->vba.ODMCombineEnablePerState[i][k];
3215                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
3216                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
3217                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
3218                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ProgressiveToInterlaceUnitInOPP =
3219                                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
3220
3221                                         mode_lib->vba.NoTimeForPrefetch[i][j][k] =
3222                                                 dml32_CalculatePrefetchSchedule(
3223                                                         v,
3224                                                         k,
3225                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3226                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe,
3227                                                         v->DSCDelayPerState[i][k],
3228                                                         v->SwathWidthYThisState[k] / v->HRatio[k],
3229                                                         dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
3230                                                         v->MaximumVStartup[i][j][k],
3231                                                         v->UrgLatency[i],
3232                                                         v->ExtraLatency,
3233                                                         v->TimeCalc,
3234                                                         v->PDEAndMetaPTEBytesPerFrame[i][j][k],
3235                                                         v->MetaRowBytes[i][j][k],
3236                                                         v->DPTEBytesPerRow[i][j][k],
3237                                                         v->PrefetchLinesY[i][j][k],
3238                                                         v->SwathWidthYThisState[k],
3239                                                         v->PrefillY[k],
3240                                                         v->MaxNumSwY[k],
3241                                                         v->PrefetchLinesC[i][j][k],
3242                                                         v->SwathWidthCThisState[k],
3243                                                         v->PrefillC[k],
3244                                                         v->MaxNumSwC[k],
3245                                                         v->swath_width_luma_ub_this_state[k],
3246                                                         v->swath_width_chroma_ub_this_state[k],
3247                                                         v->SwathHeightYThisState[k],
3248                                                         v->SwathHeightCThisState[k], v->TWait,
3249
3250                                                         /* Output */
3251                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler[k],
3252                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler[k],
3253                                                         &v->LineTimesForPrefetch[k],
3254                                                         &v->PrefetchBW[k],
3255                                                         &v->LinesForMetaPTE[k],
3256                                                         &v->LinesForMetaAndDPTERow[k],
3257                                                         &v->VRatioPreY[i][j][k],
3258                                                         &v->VRatioPreC[i][j][k],
3259                                                         &v->RequiredPrefetchPixelDataBWLuma[0][0][k],
3260                                                         &v->RequiredPrefetchPixelDataBWChroma[0][0][k],
3261                                                         &v->NoTimeForDynamicMetadata[i][j][k],
3262                                                         &v->Tno_bw[k],
3263                                                         &v->prefetch_vmrow_bw[k],
3264                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],         // double *Tdmdl_vm
3265                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],         // double *Tdmdl
3266                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[2],         // double *TSetup
3267                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0],                                                                // unsigned int   *VUpdateOffsetPix
3268                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[3],         // unsigned int   *VUpdateWidthPix
3269                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[4]);        // unsigned int   *VReadyOffsetPix
3270                                 }
3271
3272                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3273                                         dml32_CalculateUrgentBurstFactor(
3274                                                         mode_lib->vba.UsesMALLForPStateChange[k],
3275                                                         mode_lib->vba.swath_width_luma_ub_this_state[k],
3276                                                         mode_lib->vba.swath_width_chroma_ub_this_state[k],
3277                                                         mode_lib->vba.SwathHeightYThisState[k],
3278                                                         mode_lib->vba.SwathHeightCThisState[k],
3279                                                         mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
3280                                                         mode_lib->vba.UrgLatency[i], mode_lib->vba.CursorBufferSize,
3281                                                         mode_lib->vba.CursorWidth[k][0], mode_lib->vba.CursorBPP[k][0],
3282                                                         mode_lib->vba.VRatioPreY[i][j][k],
3283                                                         mode_lib->vba.VRatioPreC[i][j][k],
3284                                                         mode_lib->vba.BytePerPixelInDETY[k],
3285                                                         mode_lib->vba.BytePerPixelInDETC[k],
3286                                                         mode_lib->vba.DETBufferSizeYThisState[k],
3287                                                         mode_lib->vba.DETBufferSizeCThisState[k],
3288                                                         /* Output */
3289                                                         &mode_lib->vba.UrgentBurstFactorCursorPre[k],
3290                                                         &mode_lib->vba.UrgentBurstFactorLumaPre[k],
3291                                                         &mode_lib->vba.UrgentBurstFactorChroma[k],
3292                                                         &mode_lib->vba.NotUrgentLatencyHidingPre[k]);
3293                                 }
3294
3295                                 {
3296                                         dml32_CalculatePrefetchBandwithSupport(
3297                                                         mode_lib->vba.NumberOfActiveSurfaces,
3298                                                         mode_lib->vba.ReturnBWPerState[i][j],
3299                                                         mode_lib->vba.NotUrgentLatencyHidingPre,
3300                                                         mode_lib->vba.ReadBandwidthLuma,
3301                                                         mode_lib->vba.ReadBandwidthChroma,
3302                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3303                                                         mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3304                                                         mode_lib->vba.cursor_bw,
3305                                                         mode_lib->vba.meta_row_bandwidth_this_state,
3306                                                         mode_lib->vba.dpte_row_bandwidth_this_state,
3307                                                         mode_lib->vba.cursor_bw_pre,
3308                                                         mode_lib->vba.prefetch_vmrow_bw,
3309                                                         mode_lib->vba.NoOfDPPThisState,
3310                                                         mode_lib->vba.UrgentBurstFactorLuma,
3311                                                         mode_lib->vba.UrgentBurstFactorChroma,
3312                                                         mode_lib->vba.UrgentBurstFactorCursor,
3313                                                         mode_lib->vba.UrgentBurstFactorLumaPre,
3314                                                         mode_lib->vba.UrgentBurstFactorChromaPre,
3315                                                         mode_lib->vba.UrgentBurstFactorCursorPre,
3316
3317                                                         /* output */
3318                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],   // Single  *PrefetchBandwidth
3319                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],   // Single  *FractionOfUrgentBandwidth
3320                                                         &mode_lib->vba.PrefetchSupported[i][j]);
3321                                 }
3322
3323                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3324                                         if (mode_lib->vba.LineTimesForPrefetch[k]
3325                                                         < 2.0 || mode_lib->vba.LinesForMetaPTE[k] >= 32.0
3326                                                         || mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16.0
3327                                                         || mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3328                                                 mode_lib->vba.PrefetchSupported[i][j] = false;
3329                                         }
3330                                 }
3331
3332                                 mode_lib->vba.DynamicMetadataSupported[i][j] = true;
3333                                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3334                                         if (mode_lib->vba.NoTimeForDynamicMetadata[i][j][k] == true)
3335                                                 mode_lib->vba.DynamicMetadataSupported[i][j] = false;
3336                                 }
3337
3338                                 mode_lib->vba.VRatioInPrefetchSupported[i][j] = true;
3339                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3340                                         if (mode_lib->vba.VRatioPreY[i][j][k] > __DML_MAX_VRATIO_PRE__
3341                                                         || mode_lib->vba.VRatioPreC[i][j][k] > __DML_MAX_VRATIO_PRE__
3342                                                         || mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3343                                                 mode_lib->vba.VRatioInPrefetchSupported[i][j] = false;
3344                                         }
3345                                 }
3346                                 mode_lib->vba.AnyLinesForVMOrRowTooLarge = false;
3347                                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3348                                         if (mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16
3349                                                         || mode_lib->vba.LinesForMetaPTE[k] >= 32) {
3350                                                 mode_lib->vba.AnyLinesForVMOrRowTooLarge = true;
3351                                         }
3352                                 }
3353
3354                                 if (mode_lib->vba.PrefetchSupported[i][j] == true
3355                                                 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
3356                                         mode_lib->vba.BandwidthAvailableForImmediateFlip =
3357                                                         dml32_CalculateBandwidthAvailableForImmediateFlip(
3358                                                         mode_lib->vba.NumberOfActiveSurfaces,
3359                                                         mode_lib->vba.ReturnBWPerState[i][j],
3360                                                         mode_lib->vba.ReadBandwidthLuma,
3361                                                         mode_lib->vba.ReadBandwidthChroma,
3362                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3363                                                         mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3364                                                         mode_lib->vba.cursor_bw,
3365                                                         mode_lib->vba.cursor_bw_pre,
3366                                                         mode_lib->vba.NoOfDPPThisState,
3367                                                         mode_lib->vba.UrgentBurstFactorLuma,
3368                                                         mode_lib->vba.UrgentBurstFactorChroma,
3369                                                         mode_lib->vba.UrgentBurstFactorCursor,
3370                                                         mode_lib->vba.UrgentBurstFactorLumaPre,
3371                                                         mode_lib->vba.UrgentBurstFactorChromaPre,
3372                                                         mode_lib->vba.UrgentBurstFactorCursorPre);
3373
3374                                         mode_lib->vba.TotImmediateFlipBytes = 0.0;
3375                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3376                                                 if (!(mode_lib->vba.ImmediateFlipRequirement[k] ==
3377                                                                 dm_immediate_flip_not_required)) {
3378                                                         mode_lib->vba.TotImmediateFlipBytes =
3379                                                                         mode_lib->vba.TotImmediateFlipBytes
3380                                                                 + mode_lib->vba.NoOfDPP[i][j][k]
3381                                                                 * mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k]
3382                                                                 + mode_lib->vba.MetaRowBytes[i][j][k];
3383                                                         if (mode_lib->vba.use_one_row_for_frame_flip[i][j][k]) {
3384                                                                 mode_lib->vba.TotImmediateFlipBytes =
3385                                                                         mode_lib->vba.TotImmediateFlipBytes + 2
3386                                                                 * mode_lib->vba.DPTEBytesPerRow[i][j][k];
3387                                                         } else {
3388                                                                 mode_lib->vba.TotImmediateFlipBytes =
3389                                                                         mode_lib->vba.TotImmediateFlipBytes
3390                                                                 + mode_lib->vba.DPTEBytesPerRow[i][j][k];
3391                                                         }
3392                                                 }
3393                                         }
3394
3395                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3396                                                 dml32_CalculateFlipSchedule(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3397                                                         mode_lib->vba.ExtraLatency,
3398                                                         mode_lib->vba.UrgLatency[i],
3399                                                         mode_lib->vba.GPUVMMaxPageTableLevels,
3400                                                         mode_lib->vba.HostVMEnable,
3401                                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3402                                                         mode_lib->vba.GPUVMEnable,
3403                                                         mode_lib->vba.HostVMMinPageSize,
3404                                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k],
3405                                                         mode_lib->vba.MetaRowBytes[i][j][k],
3406                                                         mode_lib->vba.DPTEBytesPerRow[i][j][k],
3407                                                         mode_lib->vba.BandwidthAvailableForImmediateFlip,
3408                                                         mode_lib->vba.TotImmediateFlipBytes,
3409                                                         mode_lib->vba.SourcePixelFormat[k],
3410                                                         (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]),
3411                                                         mode_lib->vba.VRatio[k],
3412                                                         mode_lib->vba.VRatioChroma[k],
3413                                                         mode_lib->vba.Tno_bw[k],
3414                                                                 mode_lib->vba.DCCEnable[k],
3415                                                         mode_lib->vba.dpte_row_height[k],
3416                                                         mode_lib->vba.meta_row_height[k],
3417                                                         mode_lib->vba.dpte_row_height_chroma[k],
3418                                                         mode_lib->vba.meta_row_height_chroma[k],
3419                                                         mode_lib->vba.use_one_row_for_frame_flip[i][j][k], // 24
3420
3421                                                         /* Output */
3422                                                         &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
3423                                                         &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
3424                                                         &mode_lib->vba.final_flip_bw[k],
3425                                                         &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
3426                                         }
3427
3428                                         {
3429                                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
3430                                                                 mode_lib->vba.ReturnBWPerState[i][j],
3431                                                                 mode_lib->vba.ImmediateFlipRequirement,
3432                                                                 mode_lib->vba.final_flip_bw,
3433                                                                 mode_lib->vba.ReadBandwidthLuma,
3434                                                                 mode_lib->vba.ReadBandwidthChroma,
3435                                                                 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3436                                                                 mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3437                                                                 mode_lib->vba.cursor_bw,
3438                                                                 mode_lib->vba.meta_row_bandwidth_this_state,
3439                                                                 mode_lib->vba.dpte_row_bandwidth_this_state,
3440                                                                 mode_lib->vba.cursor_bw_pre,
3441                                                                 mode_lib->vba.prefetch_vmrow_bw,
3442                                                                 mode_lib->vba.DPPPerPlane,
3443                                                                 mode_lib->vba.UrgentBurstFactorLuma,
3444                                                                 mode_lib->vba.UrgentBurstFactorChroma,
3445                                                                 mode_lib->vba.UrgentBurstFactorCursor,
3446                                                                 mode_lib->vba.UrgentBurstFactorLumaPre,
3447                                                                 mode_lib->vba.UrgentBurstFactorChromaPre,
3448                                                                 mode_lib->vba.UrgentBurstFactorCursorPre,
3449
3450                                                                 /* output */
3451                                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0], //  Single  *TotalBandwidth
3452                                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1], //  Single  *FractionOfUrgentBandwidth
3453                                                                 &mode_lib->vba.ImmediateFlipSupportedForState[i][j]); // Boolean *ImmediateFlipBandwidthSupport
3454                                         }
3455
3456                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3457                                                 if (!(mode_lib->vba.ImmediateFlipRequirement[k]
3458                                                                 == dm_immediate_flip_not_required)
3459                                                                 && (mode_lib->vba.ImmediateFlipSupportedForPipe[k]
3460                                                                                 == false))
3461                                                         mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3462                                         }
3463                                 } else { // if prefetch not support, assume iflip not supported
3464                                         mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3465                                 }
3466
3467                                 if (mode_lib->vba.MaxVStartup <= __DML_VBA_MIN_VSTARTUP__
3468                                                 || mode_lib->vba.AnyLinesForVMOrRowTooLarge == false) {
3469                                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3470                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState + 1;
3471                                 } else {
3472                                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.NextMaxVStartup - 1;
3473                                 }
3474                         } while (!((mode_lib->vba.PrefetchSupported[i][j] == true
3475                                         && mode_lib->vba.DynamicMetadataSupported[i][j] == true
3476                                         && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true &&
3477                                         // consider flip support is okay if when there is no hostvm and the
3478                                         // user does't require a iflip OR the flip bw is ok
3479                                         // If there is hostvm, DCN needs to support iflip for invalidation
3480                                         ((mode_lib->vba.HostVMEnable == false
3481                                                         && !mode_lib->vba.ImmediateFlipRequiredFinal)
3482                                                         || mode_lib->vba.ImmediateFlipSupportedForState[i][j] == true))
3483                                         || (mode_lib->vba.NextMaxVStartup == mode_lib->vba.MaxMaxVStartup[i][j]
3484                                                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState > mode_lib->vba.MaxPrefetchMode)));
3485
3486                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3487                                 mode_lib->vba.use_one_row_for_frame_this_state[k] =
3488                                                 mode_lib->vba.use_one_row_for_frame[i][j][k];
3489                         }
3490
3491
3492                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.UrgentLatency = mode_lib->vba.UrgLatency[i];
3493                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.ExtraLatency = mode_lib->vba.ExtraLatency;
3494                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
3495                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
3496                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
3497                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
3498                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
3499                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
3500                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
3501                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
3502                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
3503
3504                         {
3505                                 dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
3506                                                 v,
3507                                                 v->PrefetchModePerState[i][j],
3508                                                 v->DCFCLKState[i][j],
3509                                                 v->ReturnBWPerState[i][j],
3510                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters,
3511                                                 v->SOCCLKPerState[i],
3512                                                 v->ProjectedDCFCLKDeepSleep[i][j],
3513                                                 v->DETBufferSizeYThisState,
3514                                                 v->DETBufferSizeCThisState,
3515                                                 v->SwathHeightYThisState,
3516                                                 v->SwathHeightCThisState,
3517                                                 v->SwathWidthYThisState, // 24
3518                                                 v->SwathWidthCThisState,
3519                                                 v->NoOfDPPThisState,
3520                                                 v->BytePerPixelInDETY,
3521                                                 v->BytePerPixelInDETC,
3522                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler,
3523                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler,
3524                                                 v->UnboundedRequestEnabledThisState,
3525                                                 v->CompressedBufferSizeInkByteThisState,
3526
3527                                                 /* Output */
3528                                                 &v->DRAMClockChangeSupport[i][j],
3529                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[0], // double *MaxActiveDRAMClockChangeLatencySupported
3530                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], // Long SubViewportLinesNeededInMALL[]
3531                                                 &v->FCLKChangeSupport[i][j],
3532                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[1], // double *MinActiveFCLKChangeLatencySupported
3533                                                 &mode_lib->vba.USRRetrainingSupport[i][j],
3534                                                 mode_lib->vba.ActiveDRAMClockChangeLatencyMarginPerState[i][j]);
3535                         }
3536                 }
3537         } // End of Prefetch Check
3538
3539         /*Cursor Support Check*/
3540         mode_lib->vba.CursorSupport = true;
3541         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3542                 if (mode_lib->vba.CursorWidth[k][0] > 0.0) {
3543                         if (mode_lib->vba.CursorBPP[k][0] == 64 && mode_lib->vba.Cursor64BppSupport == false)
3544                                 mode_lib->vba.CursorSupport = false;
3545                 }
3546         }
3547
3548         /*Valid Pitch Check*/
3549         mode_lib->vba.PitchSupport = true;
3550         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3551                 mode_lib->vba.AlignedYPitch[k] = dml_ceil(
3552                                 dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3553                                 mode_lib->vba.MacroTileWidthY[k]);
3554                 if (mode_lib->vba.DCCEnable[k] == true) {
3555                         mode_lib->vba.AlignedDCCMetaPitchY[k] = dml_ceil(
3556                                         dml_max(mode_lib->vba.DCCMetaPitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3557                                         64.0 * mode_lib->vba.Read256BlockWidthY[k]);
3558                 } else {
3559                         mode_lib->vba.AlignedDCCMetaPitchY[k] = mode_lib->vba.DCCMetaPitchY[k];
3560                 }
3561                 if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3562                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3563                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3564                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
3565                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
3566                         mode_lib->vba.AlignedCPitch[k] = dml_ceil(
3567                                         dml_max(mode_lib->vba.PitchC[k], mode_lib->vba.SurfaceWidthC[k]),
3568                                         mode_lib->vba.MacroTileWidthC[k]);
3569                         if (mode_lib->vba.DCCEnable[k] == true) {
3570                                 mode_lib->vba.AlignedDCCMetaPitchC[k] = dml_ceil(
3571                                                 dml_max(mode_lib->vba.DCCMetaPitchC[k],
3572                                                                 mode_lib->vba.SurfaceWidthC[k]),
3573                                                 64.0 * mode_lib->vba.Read256BlockWidthC[k]);
3574                         } else {
3575                                 mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3576                         }
3577                 } else {
3578                         mode_lib->vba.AlignedCPitch[k] = mode_lib->vba.PitchC[k];
3579                         mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3580                 }
3581                 if (mode_lib->vba.AlignedYPitch[k] > mode_lib->vba.PitchY[k]
3582                                 || mode_lib->vba.AlignedCPitch[k] > mode_lib->vba.PitchC[k]
3583                                 || mode_lib->vba.AlignedDCCMetaPitchY[k] > mode_lib->vba.DCCMetaPitchY[k]
3584                                 || mode_lib->vba.AlignedDCCMetaPitchC[k] > mode_lib->vba.DCCMetaPitchC[k]) {
3585                         mode_lib->vba.PitchSupport = false;
3586                 }
3587         }
3588
3589         mode_lib->vba.ViewportExceedsSurface = false;
3590         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3591                 if (mode_lib->vba.ViewportWidth[k] > mode_lib->vba.SurfaceWidthY[k]
3592                                 || mode_lib->vba.ViewportHeight[k] > mode_lib->vba.SurfaceHeightY[k]) {
3593                         mode_lib->vba.ViewportExceedsSurface = true;
3594                         if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3595                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3596                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3597                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3598                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_8
3599                                         && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe) {
3600                                 if (mode_lib->vba.ViewportWidthChroma[k] > mode_lib->vba.SurfaceWidthC[k]
3601                                                 || mode_lib->vba.ViewportHeightChroma[k]
3602                                                                 > mode_lib->vba.SurfaceHeightC[k]) {
3603                                         mode_lib->vba.ViewportExceedsSurface = true;
3604                                 }
3605                         }
3606                 }
3607         }
3608
3609         /*Mode Support, Voltage State and SOC Configuration*/
3610         mode_support_configuration(v, mode_lib);
3611
3612         MaximumMPCCombine = 0;
3613
3614         for (i = v->soc.num_states; i >= 0; i--) {
3615                 if (i == v->soc.num_states || mode_lib->vba.ModeSupport[i][0] == true ||
3616                                 mode_lib->vba.ModeSupport[i][1] == true) {
3617                         mode_lib->vba.VoltageLevel = i;
3618                         mode_lib->vba.ModeIsSupported = mode_lib->vba.ModeSupport[i][0] == true
3619                                         || mode_lib->vba.ModeSupport[i][1] == true;
3620
3621                         if (mode_lib->vba.ModeSupport[i][0] == true) {
3622                                 MaximumMPCCombine = 0;
3623                         } else {
3624                                 MaximumMPCCombine = 1;
3625                         }
3626                 }
3627         }
3628
3629         mode_lib->vba.ImmediateFlipSupport =
3630                         mode_lib->vba.ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3631         mode_lib->vba.UnboundedRequestEnabled =
3632                         mode_lib->vba.UnboundedRequestEnabledAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3633         mode_lib->vba.CompressedBufferSizeInkByte =
3634                         mode_lib->vba.CompressedBufferSizeInkByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; // Not used, informational
3635
3636         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3637                 mode_lib->vba.MPCCombineEnable[k] =
3638                                 mode_lib->vba.MPCCombine[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3639                 mode_lib->vba.DPPPerPlane[k] = mode_lib->vba.NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3640                 mode_lib->vba.SwathHeightY[k] =
3641                                 mode_lib->vba.SwathHeightYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3642                 mode_lib->vba.SwathHeightC[k] =
3643                                 mode_lib->vba.SwathHeightCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3644                 mode_lib->vba.DETBufferSizeInKByte[k] =
3645                         mode_lib->vba.DETBufferSizeInKByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3646                 mode_lib->vba.DETBufferSizeY[k] =
3647                                 mode_lib->vba.DETBufferSizeYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3648                 mode_lib->vba.DETBufferSizeC[k] =
3649                                 mode_lib->vba.DETBufferSizeCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3650                 mode_lib->vba.OutputType[k] = mode_lib->vba.OutputTypePerState[mode_lib->vba.VoltageLevel][k];
3651                 mode_lib->vba.OutputRate[k] = mode_lib->vba.OutputRatePerState[mode_lib->vba.VoltageLevel][k];
3652         }
3653
3654         mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3655         mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
3656         mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
3657         mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
3658         mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBWPerState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3659         mode_lib->vba.DISPCLK = mode_lib->vba.RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3660         mode_lib->vba.maxMpcComb = MaximumMPCCombine;
3661
3662         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3663                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
3664                         mode_lib->vba.ODMCombineEnabled[k] =
3665                                         mode_lib->vba.ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
3666                 } else {
3667                         mode_lib->vba.ODMCombineEnabled[k] = dm_odm_combine_mode_disabled;
3668                 }
3669
3670                 mode_lib->vba.DSCEnabled[k] = mode_lib->vba.RequiresDSC[mode_lib->vba.VoltageLevel][k];
3671                 mode_lib->vba.FECEnable[k] = mode_lib->vba.RequiresFEC[mode_lib->vba.VoltageLevel][k];
3672                 mode_lib->vba.OutputBpp[k] = mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k];
3673         }
3674
3675         mode_lib->vba.UrgentWatermark = mode_lib->vba.Watermark.UrgentWatermark;
3676         mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.Watermark.StutterEnterPlusExitWatermark;
3677         mode_lib->vba.StutterExitWatermark = mode_lib->vba.Watermark.StutterExitWatermark;
3678         mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.Watermark.WritebackDRAMClockChangeWatermark;
3679         mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.Watermark.DRAMClockChangeWatermark;
3680         mode_lib->vba.UrgentLatency = mode_lib->vba.UrgLatency[mode_lib->vba.VoltageLevel];
3681         mode_lib->vba.DCFCLKDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3682
3683         /* VBA has Error type to Error Msg output here, but not necessary for DML-C */
3684 } // ModeSupportAndSystemConfigurationFull