Move stack variables to dummy structure.

Signed-off-by: Alex Deucher <alexander.deuc...@amd.com>
Cc: Stephen Rothwell <s...@canb.auug.org.au>
---
 .../dc/dml/dcn32/display_mode_vba_32.c        |   3 +
 .../dc/dml/dcn32/display_mode_vba_util_32.c   | 121 +++++++++---------
 .../dc/dml/dcn32/display_mode_vba_util_32.h   |   2 +
 .../drm/amd/display/dc/dml/display_mode_vba.h |  15 +++
 4 files changed, 77 insertions(+), 64 deletions(-)

diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c 
b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c
index 9c2003fbe8fa..c0e537731c1f 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c
+++ b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c
@@ -221,6 +221,7 @@ static void 
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman
                // VBA_DELTA
                // Calculate DET size, swath height
                dml32_CalculateSwathAndDETConfiguration(
+                               
&v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
                                mode_lib->vba.DETSizeOverride,
                                mode_lib->vba.UsesMALLForPStateChange,
                                mode_lib->vba.ConfigReturnBufferSizeInKByte,
@@ -1878,6 +1879,7 @@ void dml32_ModeSupportAndSystemConfigurationFull(struct 
display_mode_lib *mode_l
        }
 
        dml32_CalculateSwathAndDETConfiguration(
+                       &v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
                        mode_lib->vba.DETSizeOverride,
                        mode_lib->vba.UsesMALLForPStateChange,
                        mode_lib->vba.ConfigReturnBufferSizeInKByte,
@@ -2474,6 +2476,7 @@ void dml32_ModeSupportAndSystemConfigurationFull(struct 
display_mode_lib *mode_l
                        }
 
                        dml32_CalculateSwathAndDETConfiguration(
+                                       
&v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
                                        mode_lib->vba.DETSizeOverride,
                                        mode_lib->vba.UsesMALLForPStateChange,
                                        
mode_lib->vba.ConfigReturnBufferSizeInKByte,
diff --git 
a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.c 
b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.c
index c8a3f367d622..da5befd7fdec 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.c
+++ b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.c
@@ -391,6 +391,7 @@ void dml32_CalculateBytePerPixelAndBlockSizes(
 } // CalculateBytePerPixelAndBlockSizes
 
 void dml32_CalculateSwathAndDETConfiguration(
+               struct dml32_CalculateSwathAndDETConfiguration *st_vars,
                unsigned int DETSizeOverride[],
                enum dm_use_mall_for_pstate_change_mode 
UseMALLForPStateChange[],
                unsigned int ConfigReturnBufferSizeInKByte,
@@ -455,18 +456,10 @@ void dml32_CalculateSwathAndDETConfiguration(
                bool ViewportSizeSupportPerSurface[],
                bool *ViewportSizeSupport)
 {
-       unsigned int MaximumSwathHeightY[DC__NUM_DPP__MAX];
-       unsigned int MaximumSwathHeightC[DC__NUM_DPP__MAX];
-       unsigned int RoundedUpMaxSwathSizeBytesY[DC__NUM_DPP__MAX];
-       unsigned int RoundedUpMaxSwathSizeBytesC[DC__NUM_DPP__MAX];
-       unsigned int RoundedUpSwathSizeBytesY;
-       unsigned int RoundedUpSwathSizeBytesC;
-       double SwathWidthdoubleDPP[DC__NUM_DPP__MAX];
-       double SwathWidthdoubleDPPChroma[DC__NUM_DPP__MAX];
        unsigned int k;
-       unsigned int TotalActiveDPP = 0;
-       bool NoChromaSurfaces = true;
-       unsigned int DETBufferSizeInKByteForSwathCalculation;
+
+       st_vars->TotalActiveDPP = 0;
+       st_vars->NoChromaSurfaces = true;
 
 #ifdef __DML_VBA_DEBUG__
        dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP);
@@ -501,43 +494,43 @@ void dml32_CalculateSwathAndDETConfiguration(
                        DPPPerSurface,
 
                        /* Output */
-                       SwathWidthdoubleDPP,
-                       SwathWidthdoubleDPPChroma,
+                       st_vars->SwathWidthdoubleDPP,
+                       st_vars->SwathWidthdoubleDPPChroma,
                        SwathWidth,
                        SwathWidthChroma,
-                       MaximumSwathHeightY,
-                       MaximumSwathHeightC,
+                       st_vars->MaximumSwathHeightY,
+                       st_vars->MaximumSwathHeightC,
                        swath_width_luma_ub,
                        swath_width_chroma_ub);
 
        for (k = 0; k < NumberOfActiveSurfaces; ++k) {
-               RoundedUpMaxSwathSizeBytesY[k] = swath_width_luma_ub[k] * 
BytePerPixDETY[k] * MaximumSwathHeightY[k];
-               RoundedUpMaxSwathSizeBytesC[k] = swath_width_chroma_ub[k] * 
BytePerPixDETC[k] * MaximumSwathHeightC[k];
+               st_vars->RoundedUpMaxSwathSizeBytesY[k] = 
swath_width_luma_ub[k] * BytePerPixDETY[k] * st_vars->MaximumSwathHeightY[k];
+               st_vars->RoundedUpMaxSwathSizeBytesC[k] = 
swath_width_chroma_ub[k] * BytePerPixDETC[k] * st_vars->MaximumSwathHeightC[k];
 #ifdef __DML_VBA_DEBUG__
                dml_print("DML::%s: k=%0d DPPPerSurface = %d\n", __func__, k, 
DPPPerSurface[k]);
                dml_print("DML::%s: k=%0d swath_width_luma_ub = %d\n", 
__func__, k, swath_width_luma_ub[k]);
                dml_print("DML::%s: k=%0d BytePerPixDETY = %f\n", __func__, k, 
BytePerPixDETY[k]);
-               dml_print("DML::%s: k=%0d MaximumSwathHeightY = %d\n", 
__func__, k, MaximumSwathHeightY[k]);
+               dml_print("DML::%s: k=%0d MaximumSwathHeightY = %d\n", 
__func__, k, st_vars->MaximumSwathHeightY[k]);
                dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", 
__func__, k,
-                               RoundedUpMaxSwathSizeBytesY[k]);
+                               st_vars->RoundedUpMaxSwathSizeBytesY[k]);
                dml_print("DML::%s: k=%0d swath_width_chroma_ub = %d\n", 
__func__, k, swath_width_chroma_ub[k]);
                dml_print("DML::%s: k=%0d BytePerPixDETC = %f\n", __func__, k, 
BytePerPixDETC[k]);
-               dml_print("DML::%s: k=%0d MaximumSwathHeightC = %d\n", 
__func__, k, MaximumSwathHeightC[k]);
+               dml_print("DML::%s: k=%0d MaximumSwathHeightC = %d\n", 
__func__, k, st_vars->MaximumSwathHeightC[k]);
                dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", 
__func__, k,
-                               RoundedUpMaxSwathSizeBytesC[k]);
+                               st_vars->RoundedUpMaxSwathSizeBytesC[k]);
 #endif
 
                if (SourcePixelFormat[k] == dm_420_10) {
-                       RoundedUpMaxSwathSizeBytesY[k] = dml_ceil((unsigned 
int) RoundedUpMaxSwathSizeBytesY[k], 256);
-                       RoundedUpMaxSwathSizeBytesC[k] = dml_ceil((unsigned 
int) RoundedUpMaxSwathSizeBytesC[k], 256);
+                       st_vars->RoundedUpMaxSwathSizeBytesY[k] = 
dml_ceil((unsigned int) st_vars->RoundedUpMaxSwathSizeBytesY[k], 256);
+                       st_vars->RoundedUpMaxSwathSizeBytesC[k] = 
dml_ceil((unsigned int) st_vars->RoundedUpMaxSwathSizeBytesC[k], 256);
                }
        }
 
        for (k = 0; k < NumberOfActiveSurfaces; ++k) {
-               TotalActiveDPP = TotalActiveDPP + (ForceSingleDPP ? 1 : 
DPPPerSurface[k]);
+               st_vars->TotalActiveDPP = st_vars->TotalActiveDPP + 
(ForceSingleDPP ? 1 : DPPPerSurface[k]);
                if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == 
dm_420_10 ||
                                SourcePixelFormat[k] == dm_420_12 || 
SourcePixelFormat[k] == dm_rgbe_alpha) {
-                       NoChromaSurfaces = false;
+                       st_vars->NoChromaSurfaces = false;
                }
        }
 
@@ -547,10 +540,10 @@ void dml32_CalculateSwathAndDETConfiguration(
        // if unbounded req is enabled, program reserved space such that the 
ROB will not hold more than 8 swaths worth of data
        // - assume worst-case compression rate of 4. [ROB size - 8 * 
swath_size / max_compression ratio]
        // - assume for "narrow" vp case in which the ROB can fit 8 swaths, the 
DET should be big enough to do full size req
-       *CompBufReservedSpaceNeedAdjustment = ((int) ROBSizeKBytes - (int) 
*CompBufReservedSpaceKBytes) > (int) (RoundedUpMaxSwathSizeBytesY[0]/512);
+       *CompBufReservedSpaceNeedAdjustment = ((int) ROBSizeKBytes - (int) 
*CompBufReservedSpaceKBytes) > (int) 
(st_vars->RoundedUpMaxSwathSizeBytesY[0]/512);
 
        if (*CompBufReservedSpaceNeedAdjustment == 1) {
-               *CompBufReservedSpaceKBytes = ROBSizeKBytes - 
RoundedUpMaxSwathSizeBytesY[0]/512;
+               *CompBufReservedSpaceKBytes = ROBSizeKBytes - 
st_vars->RoundedUpMaxSwathSizeBytesY[0]/512;
        }
 
        #ifdef __DML_VBA_DEBUG__
@@ -558,7 +551,7 @@ void dml32_CalculateSwathAndDETConfiguration(
                dml_print("DML::%s: CompBufReservedSpaceNeedAdjustment  = 
%d\n",  __func__, *CompBufReservedSpaceNeedAdjustment);
        #endif
 
-       *UnboundedRequestEnabled = 
dml32_UnboundedRequest(UseUnboundedRequestingFinal, TotalActiveDPP, 
NoChromaSurfaces, Output[0], SurfaceTiling[0], 
*CompBufReservedSpaceNeedAdjustment, 
DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment);
+       *UnboundedRequestEnabled = 
dml32_UnboundedRequest(UseUnboundedRequestingFinal, st_vars->TotalActiveDPP, 
st_vars->NoChromaSurfaces, Output[0], SurfaceTiling[0], 
*CompBufReservedSpaceNeedAdjustment, 
DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment);
 
        dml32_CalculateDETBufferSize(DETSizeOverride,
                        UseMALLForPStateChange,
@@ -573,8 +566,8 @@ void dml32_CalculateSwathAndDETConfiguration(
                        SourcePixelFormat,
                        ReadBandwidthLuma,
                        ReadBandwidthChroma,
-                       RoundedUpMaxSwathSizeBytesY,
-                       RoundedUpMaxSwathSizeBytesC,
+                       st_vars->RoundedUpMaxSwathSizeBytesY,
+                       st_vars->RoundedUpMaxSwathSizeBytesC,
                        DPPPerSurface,
 
                        /* Output */
@@ -582,7 +575,7 @@ void dml32_CalculateSwathAndDETConfiguration(
                        CompressedBufferSizeInkByte);
 
 #ifdef __DML_VBA_DEBUG__
-       dml_print("DML::%s: TotalActiveDPP = %d\n", __func__, TotalActiveDPP);
+       dml_print("DML::%s: TotalActiveDPP = %d\n", __func__, 
st_vars->TotalActiveDPP);
        dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte);
        dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %d\n", __func__, 
ConfigReturnBufferSizeInKByte);
        dml_print("DML::%s: UseUnboundedRequestingFinal = %d\n", __func__, 
UseUnboundedRequestingFinal);
@@ -593,42 +586,42 @@ void dml32_CalculateSwathAndDETConfiguration(
        *ViewportSizeSupport = true;
        for (k = 0; k < NumberOfActiveSurfaces; ++k) {
 
-               DETBufferSizeInKByteForSwathCalculation = 
(UseMALLForPStateChange[k] ==
+               st_vars->DETBufferSizeInKByteForSwathCalculation = 
(UseMALLForPStateChange[k] ==
                                dm_use_mall_pstate_change_phantom_pipe ? 1024 : 
DETBufferSizeInKByte[k]);
 #ifdef __DML_VBA_DEBUG__
                dml_print("DML::%s: k=%0d 
DETBufferSizeInKByteForSwathCalculation = %d\n", __func__, k,
-                               DETBufferSizeInKByteForSwathCalculation);
+                               
st_vars->DETBufferSizeInKByteForSwathCalculation);
 #endif
 
-               if (RoundedUpMaxSwathSizeBytesY[k] + 
RoundedUpMaxSwathSizeBytesC[k] <=
-                               DETBufferSizeInKByteForSwathCalculation * 1024 
/ 2) {
-                       SwathHeightY[k] = MaximumSwathHeightY[k];
-                       SwathHeightC[k] = MaximumSwathHeightC[k];
-                       RoundedUpSwathSizeBytesY = 
RoundedUpMaxSwathSizeBytesY[k];
-                       RoundedUpSwathSizeBytesC = 
RoundedUpMaxSwathSizeBytesC[k];
-               } else if (RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * 
RoundedUpMaxSwathSizeBytesC[k] &&
-                               RoundedUpMaxSwathSizeBytesY[k] / 2 + 
RoundedUpMaxSwathSizeBytesC[k] <=
-                               DETBufferSizeInKByteForSwathCalculation * 1024 
/ 2) {
-                       SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
-                       SwathHeightC[k] = MaximumSwathHeightC[k];
-                       RoundedUpSwathSizeBytesY = 
RoundedUpMaxSwathSizeBytesY[k] / 2;
-                       RoundedUpSwathSizeBytesC = 
RoundedUpMaxSwathSizeBytesC[k];
-               } else if (RoundedUpMaxSwathSizeBytesY[k] < 1.5 * 
RoundedUpMaxSwathSizeBytesC[k] &&
-                               RoundedUpMaxSwathSizeBytesY[k] + 
RoundedUpMaxSwathSizeBytesC[k] / 2 <=
-                               DETBufferSizeInKByteForSwathCalculation * 1024 
/ 2) {
-                       SwathHeightY[k] = MaximumSwathHeightY[k];
-                       SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
-                       RoundedUpSwathSizeBytesY = 
RoundedUpMaxSwathSizeBytesY[k];
-                       RoundedUpSwathSizeBytesC = 
RoundedUpMaxSwathSizeBytesC[k] / 2;
+               if (st_vars->RoundedUpMaxSwathSizeBytesY[k] + 
st_vars->RoundedUpMaxSwathSizeBytesC[k] <=
+                               
st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
+                       SwathHeightY[k] = st_vars->MaximumSwathHeightY[k];
+                       SwathHeightC[k] = st_vars->MaximumSwathHeightC[k];
+                       st_vars->RoundedUpSwathSizeBytesY = 
st_vars->RoundedUpMaxSwathSizeBytesY[k];
+                       st_vars->RoundedUpSwathSizeBytesC = 
st_vars->RoundedUpMaxSwathSizeBytesC[k];
+               } else if (st_vars->RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * 
st_vars->RoundedUpMaxSwathSizeBytesC[k] &&
+                               st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2 + 
st_vars->RoundedUpMaxSwathSizeBytesC[k] <=
+                               
st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
+                       SwathHeightY[k] = st_vars->MaximumSwathHeightY[k] / 2;
+                       SwathHeightC[k] = st_vars->MaximumSwathHeightC[k];
+                       st_vars->RoundedUpSwathSizeBytesY = 
st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2;
+                       st_vars->RoundedUpSwathSizeBytesC = 
st_vars->RoundedUpMaxSwathSizeBytesC[k];
+               } else if (st_vars->RoundedUpMaxSwathSizeBytesY[k] < 1.5 * 
st_vars->RoundedUpMaxSwathSizeBytesC[k] &&
+                               st_vars->RoundedUpMaxSwathSizeBytesY[k] + 
st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2 <=
+                               
st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
+                       SwathHeightY[k] = st_vars->MaximumSwathHeightY[k];
+                       SwathHeightC[k] = st_vars->MaximumSwathHeightC[k] / 2;
+                       st_vars->RoundedUpSwathSizeBytesY = 
st_vars->RoundedUpMaxSwathSizeBytesY[k];
+                       st_vars->RoundedUpSwathSizeBytesC = 
st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2;
                } else {
-                       SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
-                       SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
-                       RoundedUpSwathSizeBytesY = 
RoundedUpMaxSwathSizeBytesY[k] / 2;
-                       RoundedUpSwathSizeBytesC = 
RoundedUpMaxSwathSizeBytesC[k] / 2;
+                       SwathHeightY[k] = st_vars->MaximumSwathHeightY[k] / 2;
+                       SwathHeightC[k] = st_vars->MaximumSwathHeightC[k] / 2;
+                       st_vars->RoundedUpSwathSizeBytesY = 
st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2;
+                       st_vars->RoundedUpSwathSizeBytesC = 
st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2;
                }
 
-               if ((RoundedUpMaxSwathSizeBytesY[k] / 2 + 
RoundedUpMaxSwathSizeBytesC[k] / 2 >
-                               DETBufferSizeInKByteForSwathCalculation * 1024 
/ 2)
+               if ((st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2 + 
st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2 >
+                               
st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2)
                                || SwathWidth[k] > MaximumSwathWidthLuma[k] || 
(SwathHeightC[k] > 0 &&
                                                SwathWidthChroma[k] > 
MaximumSwathWidthChroma[k])) {
                        *ViewportSizeSupport = false;
@@ -643,7 +636,7 @@ void dml32_CalculateSwathAndDETConfiguration(
 #endif
                        DETBufferSizeY[k] = DETBufferSizeInKByte[k] * 1024;
                        DETBufferSizeC[k] = 0;
-               } else if (RoundedUpSwathSizeBytesY <= 1.5 * 
RoundedUpSwathSizeBytesC) {
+               } else if (st_vars->RoundedUpSwathSizeBytesY <= 1.5 * 
st_vars->RoundedUpSwathSizeBytesC) {
 #ifdef __DML_VBA_DEBUG__
                        dml_print("DML::%s: k=%0d Half DET for plane0, half for 
plane1\n", __func__, k);
 #endif
@@ -661,11 +654,11 @@ void dml32_CalculateSwathAndDETConfiguration(
                dml_print("DML::%s: k=%0d SwathHeightY = %d\n", __func__, k, 
SwathHeightY[k]);
                dml_print("DML::%s: k=%0d SwathHeightC = %d\n", __func__, k, 
SwathHeightC[k]);
                dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", 
__func__,
-                               k, RoundedUpMaxSwathSizeBytesY[k]);
+                               k, st_vars->RoundedUpMaxSwathSizeBytesY[k]);
                dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", 
__func__,
-                               k, RoundedUpMaxSwathSizeBytesC[k]);
-               dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesY = %d\n", 
__func__, k, RoundedUpSwathSizeBytesY);
-               dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesC = %d\n", 
__func__, k, RoundedUpSwathSizeBytesC);
+                               k, st_vars->RoundedUpMaxSwathSizeBytesC[k]);
+               dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesY = %d\n", 
__func__, k, st_vars->RoundedUpSwathSizeBytesY);
+               dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesC = %d\n", 
__func__, k, st_vars->RoundedUpSwathSizeBytesC);
                dml_print("DML::%s: k=%0d DETBufferSizeInKByte = %d\n", 
__func__, k, DETBufferSizeInKByte[k]);
                dml_print("DML::%s: k=%0d DETBufferSizeY = %d\n", __func__, k, 
DETBufferSizeY[k]);
                dml_print("DML::%s: k=%0d DETBufferSizeC = %d\n", __func__, k, 
DETBufferSizeC[k]);
diff --git 
a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.h 
b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.h
index d293856ba906..158cfa2af1af 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.h
+++ b/drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_util_32.h
@@ -30,6 +30,7 @@
 #include "os_types.h"
 #include "../dc_features.h"
 #include "../display_mode_structs.h"
+#include "dml/display_mode_vba.h"
 
 unsigned int dml32_dscceComputeDelay(
                unsigned int bpc,
@@ -81,6 +82,7 @@ void dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(
                double *DPPCLKUsingSingleDPP);
 
 void dml32_CalculateSwathAndDETConfiguration(
+               struct dml32_CalculateSwathAndDETConfiguration *st_vars,
                unsigned int DETSizeOverride[],
                enum dm_use_mall_for_pstate_change_mode 
UseMALLForPStateChange[],
                unsigned int ConfigReturnBufferSizeInKByte,
diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h 
b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h
index 492aec634b68..6cf814c2cc8d 100644
--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h
+++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.h
@@ -182,6 +182,20 @@ void Calculate256BBlockSizes(
                unsigned int *BlockWidth256BytesY,
                unsigned int *BlockWidth256BytesC);
 
+struct dml32_CalculateSwathAndDETConfiguration {
+       unsigned int MaximumSwathHeightY[DC__NUM_DPP__MAX];
+       unsigned int MaximumSwathHeightC[DC__NUM_DPP__MAX];
+       unsigned int RoundedUpMaxSwathSizeBytesY[DC__NUM_DPP__MAX];
+       unsigned int RoundedUpMaxSwathSizeBytesC[DC__NUM_DPP__MAX];
+       unsigned int RoundedUpSwathSizeBytesY;
+       unsigned int RoundedUpSwathSizeBytesC;
+       double SwathWidthdoubleDPP[DC__NUM_DPP__MAX];
+       double SwathWidthdoubleDPPChroma[DC__NUM_DPP__MAX];
+       unsigned int TotalActiveDPP;
+       bool NoChromaSurfaces;
+       unsigned int DETBufferSizeInKByteForSwathCalculation;
+};
+
 struct 
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 {
        unsigned int dummy_integer_array[2][DC__NUM_DPP__MAX];
        double dummy_single_array[2][DC__NUM_DPP__MAX];
@@ -253,6 +267,7 @@ struct dummy_vars {
        struct 
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
        
DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation;
        struct dml32_ModeSupportAndSystemConfigurationFull 
dml32_ModeSupportAndSystemConfigurationFull;
+       struct dml32_CalculateSwathAndDETConfiguration 
dml32_CalculateSwathAndDETConfiguration;
 };
 
 struct vba_vars_st {
-- 
2.35.3

Reply via email to