1dda4fb85SAurabindo Pillai /* 2dda4fb85SAurabindo Pillai * Copyright 2022 Advanced Micro Devices, Inc. 3dda4fb85SAurabindo Pillai * 4dda4fb85SAurabindo Pillai * Permission is hereby granted, free of charge, to any person obtaining a 5dda4fb85SAurabindo Pillai * copy of this software and associated documentation files (the "Software"), 6dda4fb85SAurabindo Pillai * to deal in the Software without restriction, including without limitation 7dda4fb85SAurabindo Pillai * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8dda4fb85SAurabindo Pillai * and/or sell copies of the Software, and to permit persons to whom the 9dda4fb85SAurabindo Pillai * Software is furnished to do so, subject to the following conditions: 10dda4fb85SAurabindo Pillai * 11dda4fb85SAurabindo Pillai * The above copyright notice and this permission notice shall be included in 12dda4fb85SAurabindo Pillai * all copies or substantial portions of the Software. 13dda4fb85SAurabindo Pillai * 14dda4fb85SAurabindo Pillai * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15dda4fb85SAurabindo Pillai * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16dda4fb85SAurabindo Pillai * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17dda4fb85SAurabindo Pillai * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18dda4fb85SAurabindo Pillai * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19dda4fb85SAurabindo Pillai * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20dda4fb85SAurabindo Pillai * OTHER DEALINGS IN THE SOFTWARE. 21dda4fb85SAurabindo Pillai * 22dda4fb85SAurabindo Pillai * Authors: AMD 23dda4fb85SAurabindo Pillai * 24dda4fb85SAurabindo Pillai */ 25dda4fb85SAurabindo Pillai #include "display_mode_vba_util_32.h" 26dda4fb85SAurabindo Pillai #include "../dml_inline_defs.h" 27dda4fb85SAurabindo Pillai #include "display_mode_vba_32.h" 28dda4fb85SAurabindo Pillai #include "../display_mode_lib.h" 29dda4fb85SAurabindo Pillai 30dda4fb85SAurabindo Pillai unsigned int dml32_dscceComputeDelay( 31dda4fb85SAurabindo Pillai unsigned int bpc, 32dda4fb85SAurabindo Pillai double BPP, 33dda4fb85SAurabindo Pillai unsigned int sliceWidth, 34dda4fb85SAurabindo Pillai unsigned int numSlices, 35dda4fb85SAurabindo Pillai enum output_format_class pixelFormat, 36dda4fb85SAurabindo Pillai enum output_encoder_class Output) 37dda4fb85SAurabindo Pillai { 38dda4fb85SAurabindo Pillai // valid bpc = source bits per component in the set of {8, 10, 12} 39dda4fb85SAurabindo Pillai // valid bpp = increments of 1/16 of a bit 40dda4fb85SAurabindo Pillai // min = 6/7/8 in N420/N422/444, respectively 41dda4fb85SAurabindo Pillai // max = such that compression is 1:1 42dda4fb85SAurabindo Pillai //valid sliceWidth = number of pixels per slice line, 43dda4fb85SAurabindo Pillai // must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode) 44dda4fb85SAurabindo Pillai //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4} 45dda4fb85SAurabindo Pillai //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420} 46dda4fb85SAurabindo Pillai 47dda4fb85SAurabindo Pillai // fixed value 48dda4fb85SAurabindo Pillai unsigned int rcModelSize = 8192; 49dda4fb85SAurabindo Pillai 50dda4fb85SAurabindo Pillai // N422/N420 operate at 2 pixels per clock 51dda4fb85SAurabindo Pillai unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, L, 52dda4fb85SAurabindo Pillai Delay, pixels; 53dda4fb85SAurabindo Pillai 54dda4fb85SAurabindo Pillai if (pixelFormat == dm_420) 55dda4fb85SAurabindo Pillai pixelsPerClock = 2; 56dda4fb85SAurabindo Pillai else if (pixelFormat == dm_n422) 57dda4fb85SAurabindo Pillai pixelsPerClock = 2; 58dda4fb85SAurabindo Pillai // #all other modes operate at 1 pixel per clock 59dda4fb85SAurabindo Pillai else 60dda4fb85SAurabindo Pillai pixelsPerClock = 1; 61dda4fb85SAurabindo Pillai 62dda4fb85SAurabindo Pillai //initial transmit delay as per PPS 63dda4fb85SAurabindo Pillai initalXmitDelay = dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock); 64dda4fb85SAurabindo Pillai 65dda4fb85SAurabindo Pillai //compute ssm delay 66dda4fb85SAurabindo Pillai if (bpc == 8) 67dda4fb85SAurabindo Pillai D = 81; 68dda4fb85SAurabindo Pillai else if (bpc == 10) 69dda4fb85SAurabindo Pillai D = 89; 70dda4fb85SAurabindo Pillai else 71dda4fb85SAurabindo Pillai D = 113; 72dda4fb85SAurabindo Pillai 73dda4fb85SAurabindo Pillai //divide by pixel per cycle to compute slice width as seen by DSC 74dda4fb85SAurabindo Pillai w = sliceWidth / pixelsPerClock; 75dda4fb85SAurabindo Pillai 76dda4fb85SAurabindo Pillai //422 mode has an additional cycle of delay 77dda4fb85SAurabindo Pillai if (pixelFormat == dm_420 || pixelFormat == dm_444 || pixelFormat == dm_n422) 78dda4fb85SAurabindo Pillai s = 0; 79dda4fb85SAurabindo Pillai else 80dda4fb85SAurabindo Pillai s = 1; 81dda4fb85SAurabindo Pillai 82dda4fb85SAurabindo Pillai //main calculation for the dscce 83dda4fb85SAurabindo Pillai ix = initalXmitDelay + 45; 84dda4fb85SAurabindo Pillai wx = (w + 2) / 3; 85dda4fb85SAurabindo Pillai p = 3 * wx - w; 86dda4fb85SAurabindo Pillai l0 = ix / w; 87dda4fb85SAurabindo Pillai a = ix + p * l0; 88dda4fb85SAurabindo Pillai ax = (a + 2) / 3 + D + 6 + 1; 89dda4fb85SAurabindo Pillai L = (ax + wx - 1) / wx; 90dda4fb85SAurabindo Pillai if ((ix % w) == 0 && p != 0) 91dda4fb85SAurabindo Pillai lstall = 1; 92dda4fb85SAurabindo Pillai else 93dda4fb85SAurabindo Pillai lstall = 0; 94dda4fb85SAurabindo Pillai Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22; 95dda4fb85SAurabindo Pillai 96dda4fb85SAurabindo Pillai //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels 97dda4fb85SAurabindo Pillai pixels = Delay * 3 * pixelsPerClock; 98dda4fb85SAurabindo Pillai 99dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 100dda4fb85SAurabindo Pillai dml_print("DML::%s: bpc: %d\n", __func__, bpc); 101dda4fb85SAurabindo Pillai dml_print("DML::%s: BPP: %f\n", __func__, BPP); 102dda4fb85SAurabindo Pillai dml_print("DML::%s: sliceWidth: %d\n", __func__, sliceWidth); 103dda4fb85SAurabindo Pillai dml_print("DML::%s: numSlices: %d\n", __func__, numSlices); 104dda4fb85SAurabindo Pillai dml_print("DML::%s: pixelFormat: %d\n", __func__, pixelFormat); 105dda4fb85SAurabindo Pillai dml_print("DML::%s: Output: %d\n", __func__, Output); 106dda4fb85SAurabindo Pillai dml_print("DML::%s: pixels: %d\n", __func__, pixels); 107dda4fb85SAurabindo Pillai #endif 108dda4fb85SAurabindo Pillai 109dda4fb85SAurabindo Pillai return pixels; 110dda4fb85SAurabindo Pillai } 111dda4fb85SAurabindo Pillai 112dda4fb85SAurabindo Pillai unsigned int dml32_dscComputeDelay(enum output_format_class pixelFormat, enum output_encoder_class Output) 113dda4fb85SAurabindo Pillai { 114dda4fb85SAurabindo Pillai unsigned int Delay = 0; 115dda4fb85SAurabindo Pillai 116dda4fb85SAurabindo Pillai if (pixelFormat == dm_420) { 117dda4fb85SAurabindo Pillai // sfr 118dda4fb85SAurabindo Pillai Delay = Delay + 2; 119dda4fb85SAurabindo Pillai // dsccif 120dda4fb85SAurabindo Pillai Delay = Delay + 0; 121dda4fb85SAurabindo Pillai // dscc - input deserializer 122dda4fb85SAurabindo Pillai Delay = Delay + 3; 123dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle 124dda4fb85SAurabindo Pillai Delay = Delay + 2; 125dda4fb85SAurabindo Pillai // dscc - input cdc fifo 126dda4fb85SAurabindo Pillai Delay = Delay + 12; 127dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle 128dda4fb85SAurabindo Pillai Delay = Delay + 13; 129dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 130dda4fb85SAurabindo Pillai Delay = Delay + 2; 131dda4fb85SAurabindo Pillai // dscc - output cdc fifo 132dda4fb85SAurabindo Pillai Delay = Delay + 7; 133dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle 134dda4fb85SAurabindo Pillai Delay = Delay + 3; 135dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 136dda4fb85SAurabindo Pillai Delay = Delay + 2; 137dda4fb85SAurabindo Pillai // dscc - output serializer 138dda4fb85SAurabindo Pillai Delay = Delay + 1; 139dda4fb85SAurabindo Pillai // sft 140dda4fb85SAurabindo Pillai Delay = Delay + 1; 141dda4fb85SAurabindo Pillai } else if (pixelFormat == dm_n422 || (pixelFormat != dm_444)) { 142dda4fb85SAurabindo Pillai // sfr 143dda4fb85SAurabindo Pillai Delay = Delay + 2; 144dda4fb85SAurabindo Pillai // dsccif 145dda4fb85SAurabindo Pillai Delay = Delay + 1; 146dda4fb85SAurabindo Pillai // dscc - input deserializer 147dda4fb85SAurabindo Pillai Delay = Delay + 5; 148dda4fb85SAurabindo Pillai // dscc - input cdc fifo 149dda4fb85SAurabindo Pillai Delay = Delay + 25; 150dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 151dda4fb85SAurabindo Pillai Delay = Delay + 2; 152dda4fb85SAurabindo Pillai // dscc - output cdc fifo 153dda4fb85SAurabindo Pillai Delay = Delay + 10; 154dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 155dda4fb85SAurabindo Pillai Delay = Delay + 2; 156dda4fb85SAurabindo Pillai // dscc - output serializer 157dda4fb85SAurabindo Pillai Delay = Delay + 1; 158dda4fb85SAurabindo Pillai // sft 159dda4fb85SAurabindo Pillai Delay = Delay + 1; 160dda4fb85SAurabindo Pillai } else { 161dda4fb85SAurabindo Pillai // sfr 162dda4fb85SAurabindo Pillai Delay = Delay + 2; 163dda4fb85SAurabindo Pillai // dsccif 164dda4fb85SAurabindo Pillai Delay = Delay + 0; 165dda4fb85SAurabindo Pillai // dscc - input deserializer 166dda4fb85SAurabindo Pillai Delay = Delay + 3; 167dda4fb85SAurabindo Pillai // dscc - input cdc fifo 168dda4fb85SAurabindo Pillai Delay = Delay + 12; 169dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 170dda4fb85SAurabindo Pillai Delay = Delay + 2; 171dda4fb85SAurabindo Pillai // dscc - output cdc fifo 172dda4fb85SAurabindo Pillai Delay = Delay + 7; 173dda4fb85SAurabindo Pillai // dscc - output serializer 174dda4fb85SAurabindo Pillai Delay = Delay + 1; 175dda4fb85SAurabindo Pillai // dscc - cdc uncertainty 176dda4fb85SAurabindo Pillai Delay = Delay + 2; 177dda4fb85SAurabindo Pillai // sft 178dda4fb85SAurabindo Pillai Delay = Delay + 1; 179dda4fb85SAurabindo Pillai } 180dda4fb85SAurabindo Pillai 181dda4fb85SAurabindo Pillai return Delay; 182dda4fb85SAurabindo Pillai } 183dda4fb85SAurabindo Pillai 184dda4fb85SAurabindo Pillai 185dda4fb85SAurabindo Pillai bool IsVertical(enum dm_rotation_angle Scan) 186dda4fb85SAurabindo Pillai { 187dda4fb85SAurabindo Pillai bool is_vert = false; 188dda4fb85SAurabindo Pillai 189dda4fb85SAurabindo Pillai if (Scan == dm_rotation_90 || Scan == dm_rotation_90m || Scan == dm_rotation_270 || Scan == dm_rotation_270m) 190dda4fb85SAurabindo Pillai is_vert = true; 191dda4fb85SAurabindo Pillai else 192dda4fb85SAurabindo Pillai is_vert = false; 193dda4fb85SAurabindo Pillai return is_vert; 194dda4fb85SAurabindo Pillai } 195dda4fb85SAurabindo Pillai 196dda4fb85SAurabindo Pillai void dml32_CalculateSinglePipeDPPCLKAndSCLThroughput( 197dda4fb85SAurabindo Pillai double HRatio, 198dda4fb85SAurabindo Pillai double HRatioChroma, 199dda4fb85SAurabindo Pillai double VRatio, 200dda4fb85SAurabindo Pillai double VRatioChroma, 201dda4fb85SAurabindo Pillai double MaxDCHUBToPSCLThroughput, 202dda4fb85SAurabindo Pillai double MaxPSCLToLBThroughput, 203dda4fb85SAurabindo Pillai double PixelClock, 204dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 205dda4fb85SAurabindo Pillai unsigned int HTaps, 206dda4fb85SAurabindo Pillai unsigned int HTapsChroma, 207dda4fb85SAurabindo Pillai unsigned int VTaps, 208dda4fb85SAurabindo Pillai unsigned int VTapsChroma, 209dda4fb85SAurabindo Pillai 210dda4fb85SAurabindo Pillai /* output */ 211dda4fb85SAurabindo Pillai double *PSCL_THROUGHPUT, 212dda4fb85SAurabindo Pillai double *PSCL_THROUGHPUT_CHROMA, 213dda4fb85SAurabindo Pillai double *DPPCLKUsingSingleDPP) 214dda4fb85SAurabindo Pillai { 215dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPPLuma; 216dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPPChroma; 217dda4fb85SAurabindo Pillai 218dda4fb85SAurabindo Pillai if (HRatio > 1) { 219dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatio / 220dda4fb85SAurabindo Pillai dml_ceil((double) HTaps / 6.0, 1.0)); 221dda4fb85SAurabindo Pillai } else { 222dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput); 223dda4fb85SAurabindo Pillai } 224dda4fb85SAurabindo Pillai 225dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPLuma = PixelClock * dml_max3(VTaps / 6 * dml_min(1, HRatio), HRatio * VRatio / 226dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT, 1); 227dda4fb85SAurabindo Pillai 228dda4fb85SAurabindo Pillai if ((HTaps > 6 || VTaps > 6) && DPPCLKUsingSingleDPPLuma < 2 * PixelClock) 229dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPLuma = 2 * PixelClock; 230dda4fb85SAurabindo Pillai 231dda4fb85SAurabindo Pillai if ((SourcePixelFormat != dm_420_8 && SourcePixelFormat != dm_420_10 && SourcePixelFormat != dm_420_12 && 232dda4fb85SAurabindo Pillai SourcePixelFormat != dm_rgbe_alpha)) { 233dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = 0; 234dda4fb85SAurabindo Pillai *DPPCLKUsingSingleDPP = DPPCLKUsingSingleDPPLuma; 235dda4fb85SAurabindo Pillai } else { 236dda4fb85SAurabindo Pillai if (HRatioChroma > 1) { 237dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * 238dda4fb85SAurabindo Pillai HRatioChroma / dml_ceil((double) HTapsChroma / 6.0, 1.0)); 239dda4fb85SAurabindo Pillai } else { 240dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput); 241dda4fb85SAurabindo Pillai } 242dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPChroma = PixelClock * dml_max3(VTapsChroma / 6 * dml_min(1, HRatioChroma), 243dda4fb85SAurabindo Pillai HRatioChroma * VRatioChroma / *PSCL_THROUGHPUT_CHROMA, 1); 244dda4fb85SAurabindo Pillai if ((HTapsChroma > 6 || VTapsChroma > 6) && DPPCLKUsingSingleDPPChroma < 2 * PixelClock) 245dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPChroma = 2 * PixelClock; 246dda4fb85SAurabindo Pillai *DPPCLKUsingSingleDPP = dml_max(DPPCLKUsingSingleDPPLuma, DPPCLKUsingSingleDPPChroma); 247dda4fb85SAurabindo Pillai } 248dda4fb85SAurabindo Pillai } 249dda4fb85SAurabindo Pillai 250dda4fb85SAurabindo Pillai void dml32_CalculateBytePerPixelAndBlockSizes( 251dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 252dda4fb85SAurabindo Pillai enum dm_swizzle_mode SurfaceTiling, 253dda4fb85SAurabindo Pillai 254dda4fb85SAurabindo Pillai /* Output */ 255dda4fb85SAurabindo Pillai unsigned int *BytePerPixelY, 256dda4fb85SAurabindo Pillai unsigned int *BytePerPixelC, 257dda4fb85SAurabindo Pillai double *BytePerPixelDETY, 258dda4fb85SAurabindo Pillai double *BytePerPixelDETC, 259dda4fb85SAurabindo Pillai unsigned int *BlockHeight256BytesY, 260dda4fb85SAurabindo Pillai unsigned int *BlockHeight256BytesC, 261dda4fb85SAurabindo Pillai unsigned int *BlockWidth256BytesY, 262dda4fb85SAurabindo Pillai unsigned int *BlockWidth256BytesC, 263dda4fb85SAurabindo Pillai unsigned int *MacroTileHeightY, 264dda4fb85SAurabindo Pillai unsigned int *MacroTileHeightC, 265dda4fb85SAurabindo Pillai unsigned int *MacroTileWidthY, 266dda4fb85SAurabindo Pillai unsigned int *MacroTileWidthC) 267dda4fb85SAurabindo Pillai { 268dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_444_64) { 269dda4fb85SAurabindo Pillai *BytePerPixelDETY = 8; 270dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0; 271dda4fb85SAurabindo Pillai *BytePerPixelY = 8; 272dda4fb85SAurabindo Pillai *BytePerPixelC = 0; 273dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_444_32 || SourcePixelFormat == dm_rgbe) { 274dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4; 275dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0; 276dda4fb85SAurabindo Pillai *BytePerPixelY = 4; 277dda4fb85SAurabindo Pillai *BytePerPixelC = 0; 27834ce1a6aSZhongjun Tan } else if (SourcePixelFormat == dm_444_16) { 279dda4fb85SAurabindo Pillai *BytePerPixelDETY = 2; 280dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0; 281dda4fb85SAurabindo Pillai *BytePerPixelY = 2; 282dda4fb85SAurabindo Pillai *BytePerPixelC = 0; 283dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_444_8) { 284dda4fb85SAurabindo Pillai *BytePerPixelDETY = 1; 285dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0; 286dda4fb85SAurabindo Pillai *BytePerPixelY = 1; 287dda4fb85SAurabindo Pillai *BytePerPixelC = 0; 288dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_rgbe_alpha) { 289dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4; 290dda4fb85SAurabindo Pillai *BytePerPixelDETC = 1; 291dda4fb85SAurabindo Pillai *BytePerPixelY = 4; 292dda4fb85SAurabindo Pillai *BytePerPixelC = 1; 293dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8) { 294dda4fb85SAurabindo Pillai *BytePerPixelDETY = 1; 295dda4fb85SAurabindo Pillai *BytePerPixelDETC = 2; 296dda4fb85SAurabindo Pillai *BytePerPixelY = 1; 297dda4fb85SAurabindo Pillai *BytePerPixelC = 2; 298dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_12) { 299dda4fb85SAurabindo Pillai *BytePerPixelDETY = 2; 300dda4fb85SAurabindo Pillai *BytePerPixelDETC = 4; 301dda4fb85SAurabindo Pillai *BytePerPixelY = 2; 302dda4fb85SAurabindo Pillai *BytePerPixelC = 4; 303dda4fb85SAurabindo Pillai } else { 304dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4.0 / 3; 305dda4fb85SAurabindo Pillai *BytePerPixelDETC = 8.0 / 3; 306dda4fb85SAurabindo Pillai *BytePerPixelY = 2; 307dda4fb85SAurabindo Pillai *BytePerPixelC = 4; 308dda4fb85SAurabindo Pillai } 309dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 310dda4fb85SAurabindo Pillai dml_print("DML::%s: SourcePixelFormat = %d\n", __func__, SourcePixelFormat); 311dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelDETY = %f\n", __func__, *BytePerPixelDETY); 312dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelDETC = %f\n", __func__, *BytePerPixelDETC); 313dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, *BytePerPixelY); 314dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelC = %d\n", __func__, *BytePerPixelC); 315dda4fb85SAurabindo Pillai #endif 316dda4fb85SAurabindo Pillai if ((SourcePixelFormat == dm_444_64 || SourcePixelFormat == dm_444_32 317dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_444_16 318dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_444_8 319dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_mono_16 320dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_mono_8 321dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_rgbe)) { 322dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) 323dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 1; 324dda4fb85SAurabindo Pillai else if (SourcePixelFormat == dm_444_64) 325dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 4; 326dda4fb85SAurabindo Pillai else if (SourcePixelFormat == dm_444_8) 327dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 16; 328dda4fb85SAurabindo Pillai else 329dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8; 330dda4fb85SAurabindo Pillai 331dda4fb85SAurabindo Pillai *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY; 332dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 0; 333dda4fb85SAurabindo Pillai *BlockWidth256BytesC = 0; 334dda4fb85SAurabindo Pillai } else { 335dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) { 336dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 1; 337dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 1; 338dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_rgbe_alpha) { 339dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8; 340dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 16; 341dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8) { 342dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 16; 343dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 8; 344dda4fb85SAurabindo Pillai } else { 345dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8; 346dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 8; 347dda4fb85SAurabindo Pillai } 348dda4fb85SAurabindo Pillai *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY; 349dda4fb85SAurabindo Pillai *BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC; 350dda4fb85SAurabindo Pillai } 351dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 352dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256BytesY = %d\n", __func__, *BlockWidth256BytesY); 353dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256BytesY = %d\n", __func__, *BlockHeight256BytesY); 354dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256BytesC = %d\n", __func__, *BlockWidth256BytesC); 355dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256BytesC = %d\n", __func__, *BlockHeight256BytesC); 356dda4fb85SAurabindo Pillai #endif 357dda4fb85SAurabindo Pillai 358dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) { 359dda4fb85SAurabindo Pillai *MacroTileHeightY = *BlockHeight256BytesY; 360dda4fb85SAurabindo Pillai *MacroTileWidthY = 256 / *BytePerPixelY / *MacroTileHeightY; 361dda4fb85SAurabindo Pillai *MacroTileHeightC = *BlockHeight256BytesC; 362dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0) 363dda4fb85SAurabindo Pillai *MacroTileWidthC = 0; 364dda4fb85SAurabindo Pillai else 365dda4fb85SAurabindo Pillai *MacroTileWidthC = 256 / *BytePerPixelC / *MacroTileHeightC; 366dda4fb85SAurabindo Pillai } else if (SurfaceTiling == dm_sw_64kb_d || SurfaceTiling == dm_sw_64kb_d_t || 367dda4fb85SAurabindo Pillai SurfaceTiling == dm_sw_64kb_d_x || SurfaceTiling == dm_sw_64kb_r_x) { 368dda4fb85SAurabindo Pillai *MacroTileHeightY = 16 * *BlockHeight256BytesY; 369dda4fb85SAurabindo Pillai *MacroTileWidthY = 65536 / *BytePerPixelY / *MacroTileHeightY; 370dda4fb85SAurabindo Pillai *MacroTileHeightC = 16 * *BlockHeight256BytesC; 371dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0) 372dda4fb85SAurabindo Pillai *MacroTileWidthC = 0; 373dda4fb85SAurabindo Pillai else 374dda4fb85SAurabindo Pillai *MacroTileWidthC = 65536 / *BytePerPixelC / *MacroTileHeightC; 375dda4fb85SAurabindo Pillai } else { 376dda4fb85SAurabindo Pillai *MacroTileHeightY = 32 * *BlockHeight256BytesY; 377dda4fb85SAurabindo Pillai *MacroTileWidthY = 65536 * 4 / *BytePerPixelY / *MacroTileHeightY; 378dda4fb85SAurabindo Pillai *MacroTileHeightC = 32 * *BlockHeight256BytesC; 379dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0) 380dda4fb85SAurabindo Pillai *MacroTileWidthC = 0; 381dda4fb85SAurabindo Pillai else 382dda4fb85SAurabindo Pillai *MacroTileWidthC = 65536 * 4 / *BytePerPixelC / *MacroTileHeightC; 383dda4fb85SAurabindo Pillai } 384dda4fb85SAurabindo Pillai 385dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 386dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidthY = %d\n", __func__, *MacroTileWidthY); 387dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeightY = %d\n", __func__, *MacroTileHeightY); 388dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidthC = %d\n", __func__, *MacroTileWidthC); 389dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeightC = %d\n", __func__, *MacroTileHeightC); 390dda4fb85SAurabindo Pillai #endif 391dda4fb85SAurabindo Pillai } // CalculateBytePerPixelAndBlockSizes 392dda4fb85SAurabindo Pillai 393dda4fb85SAurabindo Pillai void dml32_CalculateSwathAndDETConfiguration( 394bac4b41dSAlex Deucher struct dml32_CalculateSwathAndDETConfiguration *st_vars, 395dda4fb85SAurabindo Pillai unsigned int DETSizeOverride[], 396dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 397dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte, 398dda4fb85SAurabindo Pillai unsigned int MaxTotalDETInKByte, 399dda4fb85SAurabindo Pillai unsigned int MinCompressedBufferSizeInKByte, 400dda4fb85SAurabindo Pillai double ForceSingleDPP, 401dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 402dda4fb85SAurabindo Pillai unsigned int nomDETInKByte, 403dda4fb85SAurabindo Pillai enum unbounded_requesting_policy UseUnboundedRequestingFinal, 404f4b4e41aSJun Lei bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment, 405f4b4e41aSJun Lei unsigned int PixelChunkSizeKBytes, 406f4b4e41aSJun Lei unsigned int ROBSizeKBytes, 407dda4fb85SAurabindo Pillai unsigned int CompressedBufferSegmentSizeInkByteFinal, 408dda4fb85SAurabindo Pillai enum output_encoder_class Output[], 409dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 410dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 411dda4fb85SAurabindo Pillai double MaximumSwathWidthLuma[], 412dda4fb85SAurabindo Pillai double MaximumSwathWidthChroma[], 413dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[], 414dda4fb85SAurabindo Pillai bool ViewportStationary[], 415dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[], 416dda4fb85SAurabindo Pillai enum dm_swizzle_mode SurfaceTiling[], 417dda4fb85SAurabindo Pillai unsigned int ViewportWidth[], 418dda4fb85SAurabindo Pillai unsigned int ViewportHeight[], 419dda4fb85SAurabindo Pillai unsigned int ViewportXStart[], 420dda4fb85SAurabindo Pillai unsigned int ViewportYStart[], 421dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[], 422dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[], 423dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[], 424dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[], 425dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[], 426dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[], 427dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[], 428dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[], 429dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[], 430dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[], 431dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode[], 432dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[], 433dda4fb85SAurabindo Pillai unsigned int BytePerPixY[], 434dda4fb85SAurabindo Pillai unsigned int BytePerPixC[], 435dda4fb85SAurabindo Pillai double BytePerPixDETY[], 436dda4fb85SAurabindo Pillai double BytePerPixDETC[], 437dda4fb85SAurabindo Pillai unsigned int HActive[], 438dda4fb85SAurabindo Pillai double HRatio[], 439dda4fb85SAurabindo Pillai double HRatioChroma[], 440dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 441dda4fb85SAurabindo Pillai 442dda4fb85SAurabindo Pillai /* Output */ 443dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[], 444dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[], 445dda4fb85SAurabindo Pillai double SwathWidth[], 446dda4fb85SAurabindo Pillai double SwathWidthChroma[], 447dda4fb85SAurabindo Pillai unsigned int SwathHeightY[], 448dda4fb85SAurabindo Pillai unsigned int SwathHeightC[], 449dda4fb85SAurabindo Pillai unsigned int DETBufferSizeInKByte[], 450dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[], 451dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC[], 452dda4fb85SAurabindo Pillai bool *UnboundedRequestEnabled, 453dda4fb85SAurabindo Pillai unsigned int *CompressedBufferSizeInkByte, 454f4b4e41aSJun Lei unsigned int *CompBufReservedSpaceKBytes, 455f4b4e41aSJun Lei bool *CompBufReservedSpaceNeedAdjustment, 456dda4fb85SAurabindo Pillai bool ViewportSizeSupportPerSurface[], 457dda4fb85SAurabindo Pillai bool *ViewportSizeSupport) 458dda4fb85SAurabindo Pillai { 459dda4fb85SAurabindo Pillai unsigned int k; 460bac4b41dSAlex Deucher 461bac4b41dSAlex Deucher st_vars->TotalActiveDPP = 0; 462bac4b41dSAlex Deucher st_vars->NoChromaSurfaces = true; 463dda4fb85SAurabindo Pillai 464dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 465dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP); 466f4b4e41aSJun Lei dml_print("DML::%s: ROBSizeKBytes = %d\n", __func__, ROBSizeKBytes); 467f4b4e41aSJun Lei dml_print("DML::%s: PixelChunkSizeKBytes = %d\n", __func__, PixelChunkSizeKBytes); 468dda4fb85SAurabindo Pillai #endif 469dda4fb85SAurabindo Pillai dml32_CalculateSwathWidth(ForceSingleDPP, 470dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, 471dda4fb85SAurabindo Pillai SourcePixelFormat, 472dda4fb85SAurabindo Pillai SourceRotation, 473dda4fb85SAurabindo Pillai ViewportStationary, 474dda4fb85SAurabindo Pillai ViewportWidth, 475dda4fb85SAurabindo Pillai ViewportHeight, 476dda4fb85SAurabindo Pillai ViewportXStart, 477dda4fb85SAurabindo Pillai ViewportYStart, 478dda4fb85SAurabindo Pillai ViewportXStartC, 479dda4fb85SAurabindo Pillai ViewportYStartC, 480dda4fb85SAurabindo Pillai SurfaceWidthY, 481dda4fb85SAurabindo Pillai SurfaceWidthC, 482dda4fb85SAurabindo Pillai SurfaceHeightY, 483dda4fb85SAurabindo Pillai SurfaceHeightC, 484dda4fb85SAurabindo Pillai ODMMode, 485dda4fb85SAurabindo Pillai BytePerPixY, 486dda4fb85SAurabindo Pillai BytePerPixC, 487dda4fb85SAurabindo Pillai Read256BytesBlockHeightY, 488dda4fb85SAurabindo Pillai Read256BytesBlockHeightC, 489dda4fb85SAurabindo Pillai Read256BytesBlockWidthY, 490dda4fb85SAurabindo Pillai Read256BytesBlockWidthC, 491dda4fb85SAurabindo Pillai BlendingAndTiming, 492dda4fb85SAurabindo Pillai HActive, 493dda4fb85SAurabindo Pillai HRatio, 494dda4fb85SAurabindo Pillai DPPPerSurface, 495dda4fb85SAurabindo Pillai 496dda4fb85SAurabindo Pillai /* Output */ 497bac4b41dSAlex Deucher st_vars->SwathWidthdoubleDPP, 498bac4b41dSAlex Deucher st_vars->SwathWidthdoubleDPPChroma, 499dda4fb85SAurabindo Pillai SwathWidth, 500dda4fb85SAurabindo Pillai SwathWidthChroma, 501bac4b41dSAlex Deucher st_vars->MaximumSwathHeightY, 502bac4b41dSAlex Deucher st_vars->MaximumSwathHeightC, 503dda4fb85SAurabindo Pillai swath_width_luma_ub, 504dda4fb85SAurabindo Pillai swath_width_chroma_ub); 505dda4fb85SAurabindo Pillai 506dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 507bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY[k] = swath_width_luma_ub[k] * BytePerPixDETY[k] * st_vars->MaximumSwathHeightY[k]; 508bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesC[k] = swath_width_chroma_ub[k] * BytePerPixDETC[k] * st_vars->MaximumSwathHeightC[k]; 509dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 510dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]); 511dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d swath_width_luma_ub = %d\n", __func__, k, swath_width_luma_ub[k]); 512dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d BytePerPixDETY = %f\n", __func__, k, BytePerPixDETY[k]); 513bac4b41dSAlex Deucher dml_print("DML::%s: k=%0d MaximumSwathHeightY = %d\n", __func__, k, st_vars->MaximumSwathHeightY[k]); 514dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__, k, 515bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY[k]); 516dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d swath_width_chroma_ub = %d\n", __func__, k, swath_width_chroma_ub[k]); 517dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d BytePerPixDETC = %f\n", __func__, k, BytePerPixDETC[k]); 518bac4b41dSAlex Deucher dml_print("DML::%s: k=%0d MaximumSwathHeightC = %d\n", __func__, k, st_vars->MaximumSwathHeightC[k]); 519dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__, k, 520bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesC[k]); 521dda4fb85SAurabindo Pillai #endif 522dda4fb85SAurabindo Pillai 523dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_10) { 524bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY[k] = dml_ceil((unsigned int) st_vars->RoundedUpMaxSwathSizeBytesY[k], 256); 525bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesC[k] = dml_ceil((unsigned int) st_vars->RoundedUpMaxSwathSizeBytesC[k], 256); 526dda4fb85SAurabindo Pillai } 527dda4fb85SAurabindo Pillai } 528dda4fb85SAurabindo Pillai 529dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 530bac4b41dSAlex Deucher st_vars->TotalActiveDPP = st_vars->TotalActiveDPP + (ForceSingleDPP ? 1 : DPPPerSurface[k]); 531dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 || 532dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12 || SourcePixelFormat[k] == dm_rgbe_alpha) { 533bac4b41dSAlex Deucher st_vars->NoChromaSurfaces = false; 534dda4fb85SAurabindo Pillai } 535dda4fb85SAurabindo Pillai } 536dda4fb85SAurabindo Pillai 537f4b4e41aSJun Lei // By default, just set the reserved space to 2 pixel chunks size 538f4b4e41aSJun Lei *CompBufReservedSpaceKBytes = PixelChunkSizeKBytes * 2; 539f4b4e41aSJun Lei 540f4b4e41aSJun Lei // if unbounded req is enabled, program reserved space such that the ROB will not hold more than 8 swaths worth of data 541f4b4e41aSJun Lei // - assume worst-case compression rate of 4. [ROB size - 8 * swath_size / max_compression ratio] 542f4b4e41aSJun Lei // - assume for "narrow" vp case in which the ROB can fit 8 swaths, the DET should be big enough to do full size req 543bac4b41dSAlex Deucher *CompBufReservedSpaceNeedAdjustment = ((int) ROBSizeKBytes - (int) *CompBufReservedSpaceKBytes) > (int) (st_vars->RoundedUpMaxSwathSizeBytesY[0]/512); 544f4b4e41aSJun Lei 545f4b4e41aSJun Lei if (*CompBufReservedSpaceNeedAdjustment == 1) { 546bac4b41dSAlex Deucher *CompBufReservedSpaceKBytes = ROBSizeKBytes - st_vars->RoundedUpMaxSwathSizeBytesY[0]/512; 547f4b4e41aSJun Lei } 548f4b4e41aSJun Lei 549f4b4e41aSJun Lei #ifdef __DML_VBA_DEBUG__ 550f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceKBytes = %d\n", __func__, *CompBufReservedSpaceKBytes); 551f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceNeedAdjustment = %d\n", __func__, *CompBufReservedSpaceNeedAdjustment); 552f4b4e41aSJun Lei #endif 553f4b4e41aSJun Lei 554bac4b41dSAlex Deucher *UnboundedRequestEnabled = dml32_UnboundedRequest(UseUnboundedRequestingFinal, st_vars->TotalActiveDPP, st_vars->NoChromaSurfaces, Output[0], SurfaceTiling[0], *CompBufReservedSpaceNeedAdjustment, DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment); 555dda4fb85SAurabindo Pillai 556dda4fb85SAurabindo Pillai dml32_CalculateDETBufferSize(DETSizeOverride, 557dda4fb85SAurabindo Pillai UseMALLForPStateChange, 558dda4fb85SAurabindo Pillai ForceSingleDPP, 559dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, 560dda4fb85SAurabindo Pillai *UnboundedRequestEnabled, 561dda4fb85SAurabindo Pillai nomDETInKByte, 562dda4fb85SAurabindo Pillai MaxTotalDETInKByte, 563dda4fb85SAurabindo Pillai ConfigReturnBufferSizeInKByte, 564dda4fb85SAurabindo Pillai MinCompressedBufferSizeInKByte, 565dda4fb85SAurabindo Pillai CompressedBufferSegmentSizeInkByteFinal, 566dda4fb85SAurabindo Pillai SourcePixelFormat, 567dda4fb85SAurabindo Pillai ReadBandwidthLuma, 568dda4fb85SAurabindo Pillai ReadBandwidthChroma, 569bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY, 570bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesC, 571dda4fb85SAurabindo Pillai DPPPerSurface, 572dda4fb85SAurabindo Pillai 573dda4fb85SAurabindo Pillai /* Output */ 574dda4fb85SAurabindo Pillai DETBufferSizeInKByte, // per hubp pipe 575dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte); 576dda4fb85SAurabindo Pillai 577dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 578bac4b41dSAlex Deucher dml_print("DML::%s: TotalActiveDPP = %d\n", __func__, st_vars->TotalActiveDPP); 579dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte); 580dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %d\n", __func__, ConfigReturnBufferSizeInKByte); 581dda4fb85SAurabindo Pillai dml_print("DML::%s: UseUnboundedRequestingFinal = %d\n", __func__, UseUnboundedRequestingFinal); 582dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, *UnboundedRequestEnabled); 583dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, *CompressedBufferSizeInkByte); 584dda4fb85SAurabindo Pillai #endif 585dda4fb85SAurabindo Pillai 586dda4fb85SAurabindo Pillai *ViewportSizeSupport = true; 587dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 588dda4fb85SAurabindo Pillai 589bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation = (UseMALLForPStateChange[k] == 590dda4fb85SAurabindo Pillai dm_use_mall_pstate_change_phantom_pipe ? 1024 : DETBufferSizeInKByte[k]); 591dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 592dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeInKByteForSwathCalculation = %d\n", __func__, k, 593bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation); 594dda4fb85SAurabindo Pillai #endif 595dda4fb85SAurabindo Pillai 596bac4b41dSAlex Deucher if (st_vars->RoundedUpMaxSwathSizeBytesY[k] + st_vars->RoundedUpMaxSwathSizeBytesC[k] <= 597bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) { 598bac4b41dSAlex Deucher SwathHeightY[k] = st_vars->MaximumSwathHeightY[k]; 599bac4b41dSAlex Deucher SwathHeightC[k] = st_vars->MaximumSwathHeightC[k]; 600bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesY = st_vars->RoundedUpMaxSwathSizeBytesY[k]; 601bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesC = st_vars->RoundedUpMaxSwathSizeBytesC[k]; 602bac4b41dSAlex Deucher } else if (st_vars->RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * st_vars->RoundedUpMaxSwathSizeBytesC[k] && 603bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2 + st_vars->RoundedUpMaxSwathSizeBytesC[k] <= 604bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) { 605bac4b41dSAlex Deucher SwathHeightY[k] = st_vars->MaximumSwathHeightY[k] / 2; 606bac4b41dSAlex Deucher SwathHeightC[k] = st_vars->MaximumSwathHeightC[k]; 607bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesY = st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2; 608bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesC = st_vars->RoundedUpMaxSwathSizeBytesC[k]; 609bac4b41dSAlex Deucher } else if (st_vars->RoundedUpMaxSwathSizeBytesY[k] < 1.5 * st_vars->RoundedUpMaxSwathSizeBytesC[k] && 610bac4b41dSAlex Deucher st_vars->RoundedUpMaxSwathSizeBytesY[k] + st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2 <= 611bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) { 612bac4b41dSAlex Deucher SwathHeightY[k] = st_vars->MaximumSwathHeightY[k]; 613bac4b41dSAlex Deucher SwathHeightC[k] = st_vars->MaximumSwathHeightC[k] / 2; 614bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesY = st_vars->RoundedUpMaxSwathSizeBytesY[k]; 615bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesC = st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2; 616dda4fb85SAurabindo Pillai } else { 617bac4b41dSAlex Deucher SwathHeightY[k] = st_vars->MaximumSwathHeightY[k] / 2; 618bac4b41dSAlex Deucher SwathHeightC[k] = st_vars->MaximumSwathHeightC[k] / 2; 619bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesY = st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2; 620bac4b41dSAlex Deucher st_vars->RoundedUpSwathSizeBytesC = st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2; 621dda4fb85SAurabindo Pillai } 622dda4fb85SAurabindo Pillai 623bac4b41dSAlex Deucher if ((st_vars->RoundedUpMaxSwathSizeBytesY[k] / 2 + st_vars->RoundedUpMaxSwathSizeBytesC[k] / 2 > 624bac4b41dSAlex Deucher st_vars->DETBufferSizeInKByteForSwathCalculation * 1024 / 2) 625dda4fb85SAurabindo Pillai || SwathWidth[k] > MaximumSwathWidthLuma[k] || (SwathHeightC[k] > 0 && 626dda4fb85SAurabindo Pillai SwathWidthChroma[k] > MaximumSwathWidthChroma[k])) { 627dda4fb85SAurabindo Pillai *ViewportSizeSupport = false; 628dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k] = false; 629dda4fb85SAurabindo Pillai } else { 630dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k] = true; 631dda4fb85SAurabindo Pillai } 632dda4fb85SAurabindo Pillai 633dda4fb85SAurabindo Pillai if (SwathHeightC[k] == 0) { 634dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 635dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d All DET for plane0\n", __func__, k); 636dda4fb85SAurabindo Pillai #endif 637dda4fb85SAurabindo Pillai DETBufferSizeY[k] = DETBufferSizeInKByte[k] * 1024; 638dda4fb85SAurabindo Pillai DETBufferSizeC[k] = 0; 639bac4b41dSAlex Deucher } else if (st_vars->RoundedUpSwathSizeBytesY <= 1.5 * st_vars->RoundedUpSwathSizeBytesC) { 640dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 641dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d Half DET for plane0, half for plane1\n", __func__, k); 642dda4fb85SAurabindo Pillai #endif 643dda4fb85SAurabindo Pillai DETBufferSizeY[k] = DETBufferSizeInKByte[k] * 1024 / 2; 644dda4fb85SAurabindo Pillai DETBufferSizeC[k] = DETBufferSizeInKByte[k] * 1024 / 2; 645dda4fb85SAurabindo Pillai } else { 646dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 647dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d 2/3 DET for plane0, 1/3 for plane1\n", __func__, k); 648dda4fb85SAurabindo Pillai #endif 649dda4fb85SAurabindo Pillai DETBufferSizeY[k] = dml_floor(DETBufferSizeInKByte[k] * 1024 * 2 / 3, 1024); 650dda4fb85SAurabindo Pillai DETBufferSizeC[k] = DETBufferSizeInKByte[k] * 1024 - DETBufferSizeY[k]; 651dda4fb85SAurabindo Pillai } 652dda4fb85SAurabindo Pillai 653dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 654dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d SwathHeightY = %d\n", __func__, k, SwathHeightY[k]); 655dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d SwathHeightC = %d\n", __func__, k, SwathHeightC[k]); 656dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__, 657bac4b41dSAlex Deucher k, st_vars->RoundedUpMaxSwathSizeBytesY[k]); 658dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__, 659bac4b41dSAlex Deucher k, st_vars->RoundedUpMaxSwathSizeBytesC[k]); 660bac4b41dSAlex Deucher dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesY = %d\n", __func__, k, st_vars->RoundedUpSwathSizeBytesY); 661bac4b41dSAlex Deucher dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesC = %d\n", __func__, k, st_vars->RoundedUpSwathSizeBytesC); 662dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]); 663dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]); 664dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeC = %d\n", __func__, k, DETBufferSizeC[k]); 665dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d ViewportSizeSupportPerSurface = %d\n", __func__, k, 666dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k]); 667dda4fb85SAurabindo Pillai #endif 668dda4fb85SAurabindo Pillai 669dda4fb85SAurabindo Pillai } 670dda4fb85SAurabindo Pillai } // CalculateSwathAndDETConfiguration 671dda4fb85SAurabindo Pillai 672dda4fb85SAurabindo Pillai void dml32_CalculateSwathWidth( 673dda4fb85SAurabindo Pillai bool ForceSingleDPP, 674dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 675dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[], 676dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[], 677dda4fb85SAurabindo Pillai bool ViewportStationary[], 678dda4fb85SAurabindo Pillai unsigned int ViewportWidth[], 679dda4fb85SAurabindo Pillai unsigned int ViewportHeight[], 680dda4fb85SAurabindo Pillai unsigned int ViewportXStart[], 681dda4fb85SAurabindo Pillai unsigned int ViewportYStart[], 682dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[], 683dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[], 684dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[], 685dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[], 686dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[], 687dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[], 688dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode[], 689dda4fb85SAurabindo Pillai unsigned int BytePerPixY[], 690dda4fb85SAurabindo Pillai unsigned int BytePerPixC[], 691dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[], 692dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[], 693dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[], 694dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[], 695dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[], 696dda4fb85SAurabindo Pillai unsigned int HActive[], 697dda4fb85SAurabindo Pillai double HRatio[], 698dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 699dda4fb85SAurabindo Pillai 700dda4fb85SAurabindo Pillai /* Output */ 701dda4fb85SAurabindo Pillai double SwathWidthdoubleDPPY[], 702dda4fb85SAurabindo Pillai double SwathWidthdoubleDPPC[], 703dda4fb85SAurabindo Pillai double SwathWidthY[], // per-pipe 704dda4fb85SAurabindo Pillai double SwathWidthC[], // per-pipe 705dda4fb85SAurabindo Pillai unsigned int MaximumSwathHeightY[], 706dda4fb85SAurabindo Pillai unsigned int MaximumSwathHeightC[], 707dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[], // per-pipe 708dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[]) // per-pipe 709dda4fb85SAurabindo Pillai { 710dda4fb85SAurabindo Pillai unsigned int k, j; 711dda4fb85SAurabindo Pillai enum odm_combine_mode MainSurfaceODMMode; 712dda4fb85SAurabindo Pillai 713dda4fb85SAurabindo Pillai unsigned int surface_width_ub_l; 714dda4fb85SAurabindo Pillai unsigned int surface_height_ub_l; 715dda4fb85SAurabindo Pillai unsigned int surface_width_ub_c; 716dda4fb85SAurabindo Pillai unsigned int surface_height_ub_c; 717dda4fb85SAurabindo Pillai 718dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 719dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP); 720dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces); 721dda4fb85SAurabindo Pillai #endif 722dda4fb85SAurabindo Pillai 723dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 724dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) 725dda4fb85SAurabindo Pillai SwathWidthdoubleDPPY[k] = ViewportWidth[k]; 726dda4fb85SAurabindo Pillai else 727dda4fb85SAurabindo Pillai SwathWidthdoubleDPPY[k] = ViewportHeight[k]; 728dda4fb85SAurabindo Pillai 729dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 730dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d ViewportWidth=%d\n", __func__, k, ViewportWidth[k]); 731dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d ViewportHeight=%d\n", __func__, k, ViewportHeight[k]); 732dda4fb85SAurabindo Pillai #endif 733dda4fb85SAurabindo Pillai 734dda4fb85SAurabindo Pillai MainSurfaceODMMode = ODMMode[k]; 735dda4fb85SAurabindo Pillai for (j = 0; j < NumberOfActiveSurfaces; ++j) { 736dda4fb85SAurabindo Pillai if (BlendingAndTiming[k] == j) 737dda4fb85SAurabindo Pillai MainSurfaceODMMode = ODMMode[j]; 738dda4fb85SAurabindo Pillai } 739dda4fb85SAurabindo Pillai 740dda4fb85SAurabindo Pillai if (ForceSingleDPP) { 741dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k]; 742dda4fb85SAurabindo Pillai } else { 743dda4fb85SAurabindo Pillai if (MainSurfaceODMMode == dm_odm_combine_mode_4to1) { 744dda4fb85SAurabindo Pillai SwathWidthY[k] = dml_min(SwathWidthdoubleDPPY[k], 745dda4fb85SAurabindo Pillai dml_round(HActive[k] / 4.0 * HRatio[k])); 746dda4fb85SAurabindo Pillai } else if (MainSurfaceODMMode == dm_odm_combine_mode_2to1) { 747dda4fb85SAurabindo Pillai SwathWidthY[k] = dml_min(SwathWidthdoubleDPPY[k], 748dda4fb85SAurabindo Pillai dml_round(HActive[k] / 2.0 * HRatio[k])); 749dda4fb85SAurabindo Pillai } else if (DPPPerSurface[k] == 2) { 750dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k] / 2; 751dda4fb85SAurabindo Pillai } else { 752dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k]; 753dda4fb85SAurabindo Pillai } 754dda4fb85SAurabindo Pillai } 755dda4fb85SAurabindo Pillai 756dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 757dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d HActive=%d\n", __func__, k, HActive[k]); 758dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d HRatio=%f\n", __func__, k, HRatio[k]); 759dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MainSurfaceODMMode=%d\n", __func__, k, MainSurfaceODMMode); 760dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d SwathWidthdoubleDPPY=%d\n", __func__, k, SwathWidthdoubleDPPY[k]); 761dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d SwathWidthY=%d\n", __func__, k, SwathWidthY[k]); 762dda4fb85SAurabindo Pillai #endif 763dda4fb85SAurabindo Pillai 764dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 || 765dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12) { 766dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthY[k] / 2; 767dda4fb85SAurabindo Pillai SwathWidthdoubleDPPC[k] = SwathWidthdoubleDPPY[k] / 2; 768dda4fb85SAurabindo Pillai } else { 769dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthY[k]; 770dda4fb85SAurabindo Pillai SwathWidthdoubleDPPC[k] = SwathWidthdoubleDPPY[k]; 771dda4fb85SAurabindo Pillai } 772dda4fb85SAurabindo Pillai 773dda4fb85SAurabindo Pillai if (ForceSingleDPP == true) { 774dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k]; 775dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthdoubleDPPC[k]; 776dda4fb85SAurabindo Pillai } 777dda4fb85SAurabindo Pillai 778dda4fb85SAurabindo Pillai surface_width_ub_l = dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]); 779dda4fb85SAurabindo Pillai surface_height_ub_l = dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]); 780dda4fb85SAurabindo Pillai surface_width_ub_c = dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]); 781dda4fb85SAurabindo Pillai surface_height_ub_c = dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]); 782dda4fb85SAurabindo Pillai 783dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 784dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d surface_width_ub_l=%0d\n", __func__, k, surface_width_ub_l); 785dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d surface_height_ub_l=%0d\n", __func__, k, surface_height_ub_l); 786dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d surface_width_ub_c=%0d\n", __func__, k, surface_width_ub_c); 787dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d surface_height_ub_c=%0d\n", __func__, k, surface_height_ub_c); 788dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d Read256BytesBlockWidthY=%0d\n", __func__, k, Read256BytesBlockWidthY[k]); 789dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d Read256BytesBlockHeightY=%0d\n", __func__, k, Read256BytesBlockHeightY[k]); 790dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d Read256BytesBlockWidthC=%0d\n", __func__, k, Read256BytesBlockWidthC[k]); 791dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d Read256BytesBlockHeightC=%0d\n", __func__, k, Read256BytesBlockHeightC[k]); 792dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d ViewportStationary=%0d\n", __func__, k, ViewportStationary[k]); 793dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DPPPerSurface=%0d\n", __func__, k, DPPPerSurface[k]); 794dda4fb85SAurabindo Pillai #endif 795dda4fb85SAurabindo Pillai 796dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) { 797dda4fb85SAurabindo Pillai MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k]; 798dda4fb85SAurabindo Pillai MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k]; 799dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) { 800dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_width_ub_l, 801dda4fb85SAurabindo Pillai dml_floor(ViewportXStart[k] + 802dda4fb85SAurabindo Pillai SwathWidthY[k] + 803dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1, 804dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) - 805dda4fb85SAurabindo Pillai dml_floor(ViewportXStart[k], 806dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k])); 807dda4fb85SAurabindo Pillai } else { 808dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_width_ub_l, 809dda4fb85SAurabindo Pillai dml_ceil(SwathWidthY[k] - 1, 810dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) + 811dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]); 812dda4fb85SAurabindo Pillai } 813dda4fb85SAurabindo Pillai if (BytePerPixC[k] > 0) { 814dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) { 815dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_width_ub_c, 816dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + SwathWidthC[k] + 817dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k] - 1, 818dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) - 819dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k], 820dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k])); 821dda4fb85SAurabindo Pillai } else { 822dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_width_ub_c, 823dda4fb85SAurabindo Pillai dml_ceil(SwathWidthC[k] - 1, 824dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) + 825dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]); 826dda4fb85SAurabindo Pillai } 827dda4fb85SAurabindo Pillai } else { 828dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = 0; 829dda4fb85SAurabindo Pillai } 830dda4fb85SAurabindo Pillai } else { 831dda4fb85SAurabindo Pillai MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k]; 832dda4fb85SAurabindo Pillai MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k]; 833dda4fb85SAurabindo Pillai 834dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) { 835dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_height_ub_l, dml_floor(ViewportYStart[k] + 836dda4fb85SAurabindo Pillai SwathWidthY[k] + Read256BytesBlockHeightY[k] - 1, 837dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) - 838dda4fb85SAurabindo Pillai dml_floor(ViewportYStart[k], Read256BytesBlockHeightY[k])); 839dda4fb85SAurabindo Pillai } else { 840dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_height_ub_l, dml_ceil(SwathWidthY[k] - 1, 841dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]); 842dda4fb85SAurabindo Pillai } 843dda4fb85SAurabindo Pillai if (BytePerPixC[k] > 0) { 844dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) { 845dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_height_ub_c, 846dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + SwathWidthC[k] + 847dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k] - 1, 848dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) - 849dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k], 850dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k])); 851dda4fb85SAurabindo Pillai } else { 852dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_height_ub_c, 853dda4fb85SAurabindo Pillai dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockHeightC[k]) + 854dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]); 855dda4fb85SAurabindo Pillai } 856dda4fb85SAurabindo Pillai } else { 857dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = 0; 858dda4fb85SAurabindo Pillai } 859dda4fb85SAurabindo Pillai } 860dda4fb85SAurabindo Pillai 861dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 862dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d swath_width_luma_ub=%0d\n", __func__, k, swath_width_luma_ub[k]); 863dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d swath_width_chroma_ub=%0d\n", __func__, k, swath_width_chroma_ub[k]); 864dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MaximumSwathHeightY=%0d\n", __func__, k, MaximumSwathHeightY[k]); 865dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MaximumSwathHeightC=%0d\n", __func__, k, MaximumSwathHeightC[k]); 866dda4fb85SAurabindo Pillai #endif 867dda4fb85SAurabindo Pillai 868dda4fb85SAurabindo Pillai } 869dda4fb85SAurabindo Pillai } // CalculateSwathWidth 870dda4fb85SAurabindo Pillai 871dda4fb85SAurabindo Pillai bool dml32_UnboundedRequest(enum unbounded_requesting_policy UseUnboundedRequestingFinal, 872dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP, 873dda4fb85SAurabindo Pillai bool NoChroma, 874f4b4e41aSJun Lei enum output_encoder_class Output, 875f4b4e41aSJun Lei enum dm_swizzle_mode SurfaceTiling, 876f4b4e41aSJun Lei bool CompBufReservedSpaceNeedAdjustment, 877f4b4e41aSJun Lei bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment) 878dda4fb85SAurabindo Pillai { 879dda4fb85SAurabindo Pillai bool ret_val = false; 880dda4fb85SAurabindo Pillai 881dda4fb85SAurabindo Pillai ret_val = (UseUnboundedRequestingFinal != dm_unbounded_requesting_disable && 882dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP == 1 && NoChroma); 883dda4fb85SAurabindo Pillai if (UseUnboundedRequestingFinal == dm_unbounded_requesting_edp_only && Output != dm_edp) 884dda4fb85SAurabindo Pillai ret_val = false; 885f4b4e41aSJun Lei 886f4b4e41aSJun Lei if (SurfaceTiling == dm_sw_linear) 887f4b4e41aSJun Lei ret_val = false; 888f4b4e41aSJun Lei 889f4b4e41aSJun Lei if (CompBufReservedSpaceNeedAdjustment == 1 && DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment) 890f4b4e41aSJun Lei ret_val = false; 891f4b4e41aSJun Lei 892f4b4e41aSJun Lei #ifdef __DML_VBA_DEBUG__ 893f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceNeedAdjustment = %d\n", __func__, CompBufReservedSpaceNeedAdjustment); 894f4b4e41aSJun Lei dml_print("DML::%s: DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment = %d\n", __func__, DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment); 895f4b4e41aSJun Lei dml_print("DML::%s: ret_val = %d\n", __func__, ret_val); 896f4b4e41aSJun Lei #endif 897f4b4e41aSJun Lei 898f4b4e41aSJun Lei return (ret_val); 899dda4fb85SAurabindo Pillai } 900dda4fb85SAurabindo Pillai 901dda4fb85SAurabindo Pillai void dml32_CalculateDETBufferSize( 902dda4fb85SAurabindo Pillai unsigned int DETSizeOverride[], 903dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 904dda4fb85SAurabindo Pillai bool ForceSingleDPP, 905dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 906dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled, 907dda4fb85SAurabindo Pillai unsigned int nomDETInKByte, 908dda4fb85SAurabindo Pillai unsigned int MaxTotalDETInKByte, 909dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte, 910dda4fb85SAurabindo Pillai unsigned int MinCompressedBufferSizeInKByte, 911dda4fb85SAurabindo Pillai unsigned int CompressedBufferSegmentSizeInkByteFinal, 912dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[], 913dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 914dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 915dda4fb85SAurabindo Pillai unsigned int RoundedUpMaxSwathSizeBytesY[], 916dda4fb85SAurabindo Pillai unsigned int RoundedUpMaxSwathSizeBytesC[], 917dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 918dda4fb85SAurabindo Pillai /* Output */ 919dda4fb85SAurabindo Pillai unsigned int DETBufferSizeInKByte[], 920dda4fb85SAurabindo Pillai unsigned int *CompressedBufferSizeInkByte) 921dda4fb85SAurabindo Pillai { 922dda4fb85SAurabindo Pillai unsigned int DETBufferSizePoolInKByte; 923dda4fb85SAurabindo Pillai unsigned int NextDETBufferPieceInKByte; 924dda4fb85SAurabindo Pillai bool DETPieceAssignedToThisSurfaceAlready[DC__NUM_DPP__MAX]; 925dda4fb85SAurabindo Pillai bool NextPotentialSurfaceToAssignDETPieceFound; 926dda4fb85SAurabindo Pillai unsigned int NextSurfaceToAssignDETPiece; 927dda4fb85SAurabindo Pillai double TotalBandwidth; 928dda4fb85SAurabindo Pillai double BandwidthOfSurfacesNotAssignedDETPiece; 929dda4fb85SAurabindo Pillai unsigned int max_minDET; 930dda4fb85SAurabindo Pillai unsigned int minDET; 931dda4fb85SAurabindo Pillai unsigned int minDET_pipe; 932dda4fb85SAurabindo Pillai unsigned int j, k; 933dda4fb85SAurabindo Pillai 934dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 935dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP); 936dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte); 937dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces); 938dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, UnboundedRequestEnabled); 939dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxTotalDETInKByte = %d\n", __func__, MaxTotalDETInKByte); 940dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %d\n", __func__, ConfigReturnBufferSizeInKByte); 941dda4fb85SAurabindo Pillai dml_print("DML::%s: MinCompressedBufferSizeInKByte = %d\n", __func__, MinCompressedBufferSizeInKByte); 942dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSegmentSizeInkByteFinal = %d\n", __func__, 943dda4fb85SAurabindo Pillai CompressedBufferSegmentSizeInkByteFinal); 944dda4fb85SAurabindo Pillai #endif 945dda4fb85SAurabindo Pillai 946dda4fb85SAurabindo Pillai // Note: Will use default det size if that fits 2 swaths 947dda4fb85SAurabindo Pillai if (UnboundedRequestEnabled) { 948dda4fb85SAurabindo Pillai if (DETSizeOverride[0] > 0) { 949dda4fb85SAurabindo Pillai DETBufferSizeInKByte[0] = DETSizeOverride[0]; 950dda4fb85SAurabindo Pillai } else { 951dda4fb85SAurabindo Pillai DETBufferSizeInKByte[0] = dml_max(nomDETInKByte, dml_ceil(2.0 * 952dda4fb85SAurabindo Pillai ((double) RoundedUpMaxSwathSizeBytesY[0] + 953dda4fb85SAurabindo Pillai (double) RoundedUpMaxSwathSizeBytesC[0]) / 1024.0, 64.0)); 954dda4fb85SAurabindo Pillai } 955dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = ConfigReturnBufferSizeInKByte - DETBufferSizeInKByte[0]; 956dda4fb85SAurabindo Pillai } else { 957dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = MaxTotalDETInKByte; 958dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 959dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = nomDETInKByte; 960dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 || 961dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12) { 962dda4fb85SAurabindo Pillai max_minDET = nomDETInKByte - 64; 963dda4fb85SAurabindo Pillai } else { 964dda4fb85SAurabindo Pillai max_minDET = nomDETInKByte; 965dda4fb85SAurabindo Pillai } 966dda4fb85SAurabindo Pillai minDET = 128; 967dda4fb85SAurabindo Pillai minDET_pipe = 0; 968dda4fb85SAurabindo Pillai 969dda4fb85SAurabindo Pillai // add DET resource until can hold 2 full swaths 970dda4fb85SAurabindo Pillai while (minDET <= max_minDET && minDET_pipe == 0) { 971dda4fb85SAurabindo Pillai if (2.0 * ((double) RoundedUpMaxSwathSizeBytesY[k] + 972dda4fb85SAurabindo Pillai (double) RoundedUpMaxSwathSizeBytesC[k]) / 1024.0 <= minDET) 973dda4fb85SAurabindo Pillai minDET_pipe = minDET; 974dda4fb85SAurabindo Pillai minDET = minDET + 64; 975dda4fb85SAurabindo Pillai } 976dda4fb85SAurabindo Pillai 977dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 978dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET = %d\n", __func__, k, minDET); 979dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d max_minDET = %d\n", __func__, k, max_minDET); 980dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET_pipe = %d\n", __func__, k, minDET_pipe); 981dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__, k, 982dda4fb85SAurabindo Pillai RoundedUpMaxSwathSizeBytesY[k]); 983dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__, k, 984dda4fb85SAurabindo Pillai RoundedUpMaxSwathSizeBytesC[k]); 985dda4fb85SAurabindo Pillai #endif 986dda4fb85SAurabindo Pillai 987dda4fb85SAurabindo Pillai if (minDET_pipe == 0) { 988dda4fb85SAurabindo Pillai minDET_pipe = dml_max(128, dml_ceil(((double)RoundedUpMaxSwathSizeBytesY[k] + 989dda4fb85SAurabindo Pillai (double)RoundedUpMaxSwathSizeBytesC[k]) / 1024.0, 64)); 990dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 991dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET_pipe = %d (assume each plane take half DET)\n", 992dda4fb85SAurabindo Pillai __func__, k, minDET_pipe); 993dda4fb85SAurabindo Pillai #endif 994dda4fb85SAurabindo Pillai } 995dda4fb85SAurabindo Pillai 996dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) { 997dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = 0; 998dda4fb85SAurabindo Pillai } else if (DETSizeOverride[k] > 0) { 999dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = DETSizeOverride[k]; 1000dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - 1001dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : DPPPerSurface[k]) * DETSizeOverride[k]; 1002dda4fb85SAurabindo Pillai } else if ((ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe <= DETBufferSizePoolInKByte) { 1003dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = minDET_pipe; 1004dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - 1005dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe; 1006dda4fb85SAurabindo Pillai } 1007dda4fb85SAurabindo Pillai 1008dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1009dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]); 1010dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETSizeOverride = %d\n", __func__, k, DETSizeOverride[k]); 1011dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]); 1012dda4fb85SAurabindo Pillai dml_print("DML::%s: DETBufferSizePoolInKByte = %d\n", __func__, DETBufferSizePoolInKByte); 1013dda4fb85SAurabindo Pillai #endif 1014dda4fb85SAurabindo Pillai } 1015dda4fb85SAurabindo Pillai 1016dda4fb85SAurabindo Pillai TotalBandwidth = 0; 1017dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1018dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) 1019dda4fb85SAurabindo Pillai TotalBandwidth = TotalBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k]; 1020dda4fb85SAurabindo Pillai } 1021dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1022dda4fb85SAurabindo Pillai dml_print("DML::%s: --- Before bandwidth adjustment ---\n", __func__); 1023dda4fb85SAurabindo Pillai for (uint k = 0; k < NumberOfActiveSurfaces; ++k) 1024dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]); 1025dda4fb85SAurabindo Pillai dml_print("DML::%s: --- DET allocation with bandwidth ---\n", __func__); 1026dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalBandwidth = %f\n", __func__, TotalBandwidth); 1027dda4fb85SAurabindo Pillai #endif 1028dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = TotalBandwidth; 1029dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1030dda4fb85SAurabindo Pillai 1031dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) { 1032dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = true; 1033dda4fb85SAurabindo Pillai } else if (DETSizeOverride[k] > 0 || (((double) (ForceSingleDPP ? 1 : DPPPerSurface[k]) * 1034dda4fb85SAurabindo Pillai (double) DETBufferSizeInKByte[k] / (double) MaxTotalDETInKByte) >= 1035dda4fb85SAurabindo Pillai ((ReadBandwidthLuma[k] + ReadBandwidthChroma[k]) / TotalBandwidth))) { 1036dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = true; 1037dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - 1038dda4fb85SAurabindo Pillai ReadBandwidthLuma[k] - ReadBandwidthChroma[k]; 1039dda4fb85SAurabindo Pillai } else { 1040dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = false; 1041dda4fb85SAurabindo Pillai } 1042dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1043dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETPieceAssignedToThisSurfaceAlready = %d\n", __func__, k, 1044dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k]); 1045dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, k, 1046dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece); 1047dda4fb85SAurabindo Pillai #endif 1048dda4fb85SAurabindo Pillai } 1049dda4fb85SAurabindo Pillai 1050dda4fb85SAurabindo Pillai for (j = 0; j < NumberOfActiveSurfaces; ++j) { 1051dda4fb85SAurabindo Pillai NextPotentialSurfaceToAssignDETPieceFound = false; 1052dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece = 0; 1053dda4fb85SAurabindo Pillai 1054dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1055dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1056dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthLuma[k] = %f\n", __func__, j, k, 1057dda4fb85SAurabindo Pillai ReadBandwidthLuma[k]); 1058dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthChroma[k] = %f\n", __func__, j, k, 1059dda4fb85SAurabindo Pillai ReadBandwidthChroma[k]); 1060dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthLuma[Next] = %f\n", __func__, j, k, 1061dda4fb85SAurabindo Pillai ReadBandwidthLuma[NextSurfaceToAssignDETPiece]); 1062dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthChroma[Next] = %f\n", __func__, j, k, 1063dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]); 1064dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, NextSurfaceToAssignDETPiece = %d\n", __func__, j, k, 1065dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece); 1066dda4fb85SAurabindo Pillai #endif 1067dda4fb85SAurabindo Pillai if (!DETPieceAssignedToThisSurfaceAlready[k] && 1068dda4fb85SAurabindo Pillai (!NextPotentialSurfaceToAssignDETPieceFound || 1069dda4fb85SAurabindo Pillai ReadBandwidthLuma[k] + ReadBandwidthChroma[k] < 1070dda4fb85SAurabindo Pillai ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + 1071dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece])) { 1072dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece = k; 1073dda4fb85SAurabindo Pillai NextPotentialSurfaceToAssignDETPieceFound = true; 1074dda4fb85SAurabindo Pillai } 1075dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1076dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, DETPieceAssignedToThisSurfaceAlready = %d\n", 1077dda4fb85SAurabindo Pillai __func__, j, k, DETPieceAssignedToThisSurfaceAlready[k]); 1078dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, NextPotentialSurfaceToAssignDETPieceFound = %d\n", 1079dda4fb85SAurabindo Pillai __func__, j, k, NextPotentialSurfaceToAssignDETPieceFound); 1080dda4fb85SAurabindo Pillai #endif 1081dda4fb85SAurabindo Pillai } 1082dda4fb85SAurabindo Pillai 1083dda4fb85SAurabindo Pillai if (NextPotentialSurfaceToAssignDETPieceFound) { 1084dda4fb85SAurabindo Pillai // Note: To show the banker's rounding behavior in VBA and also the fact 1085dda4fb85SAurabindo Pillai // that the DET buffer size varies due to precision issue 1086dda4fb85SAurabindo Pillai // 1087dda4fb85SAurabindo Pillai //double tmp1 = ((double) DETBufferSizePoolInKByte * 1088dda4fb85SAurabindo Pillai // (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + 1089dda4fb85SAurabindo Pillai // ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / 1090dda4fb85SAurabindo Pillai // BandwidthOfSurfacesNotAssignedDETPiece / 1091dda4fb85SAurabindo Pillai // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0)); 1092dda4fb85SAurabindo Pillai //double tmp2 = dml_round((double) DETBufferSizePoolInKByte * 1093dda4fb85SAurabindo Pillai // (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + 1094dda4fb85SAurabindo Pillai // ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / 1095dda4fb85SAurabindo Pillai //BandwidthOfSurfacesNotAssignedDETPiece / 1096dda4fb85SAurabindo Pillai // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0)); 1097dda4fb85SAurabindo Pillai // 1098dda4fb85SAurabindo Pillai //dml_print("DML::%s: j=%d, tmp1 = %f\n", __func__, j, tmp1); 1099dda4fb85SAurabindo Pillai //dml_print("DML::%s: j=%d, tmp2 = %f\n", __func__, j, tmp2); 1100dda4fb85SAurabindo Pillai 1101dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = dml_min( 1102dda4fb85SAurabindo Pillai dml_round((double) DETBufferSizePoolInKByte * 1103dda4fb85SAurabindo Pillai (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + 1104dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) / 1105dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece / 1106dda4fb85SAurabindo Pillai ((ForceSingleDPP ? 1 : 1107dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0)) * 1108dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : 1109dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0, 1110dda4fb85SAurabindo Pillai dml_floor((double) DETBufferSizePoolInKByte, 1111dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : 1112dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0)); 1113dda4fb85SAurabindo Pillai 1114dda4fb85SAurabindo Pillai // Above calculation can assign the entire DET buffer allocation to a single pipe. 1115dda4fb85SAurabindo Pillai // We should limit the per-pipe DET size to the nominal / max per pipe. 1116dda4fb85SAurabindo Pillai if (NextDETBufferPieceInKByte > nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k])) { 1117dda4fb85SAurabindo Pillai if (DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] < 1118dda4fb85SAurabindo Pillai nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k])) { 1119dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k]) - 1120dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]; 1121dda4fb85SAurabindo Pillai } else { 1122dda4fb85SAurabindo Pillai // Case where DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] 1123dda4fb85SAurabindo Pillai // already has the max per-pipe value 1124dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = 0; 1125dda4fb85SAurabindo Pillai } 1126dda4fb85SAurabindo Pillai } 1127dda4fb85SAurabindo Pillai 1128dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1129dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, DETBufferSizePoolInKByte = %d\n", __func__, j, 1130dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte); 1131dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, NextSurfaceToAssignDETPiece = %d\n", __func__, j, 1132dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece); 1133dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, ReadBandwidthLuma[%0d] = %f\n", __func__, j, 1134dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]); 1135dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, ReadBandwidthChroma[%0d] = %f\n", __func__, j, 1136dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]); 1137dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, BandwidthOfSurfacesNotAssignedDETPiece = %f\n", 1138dda4fb85SAurabindo Pillai __func__, j, BandwidthOfSurfacesNotAssignedDETPiece); 1139dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, NextDETBufferPieceInKByte = %d\n", __func__, j, 1140dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte); 1141dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, DETBufferSizeInKByte[%0d] increases from %0d ", 1142dda4fb85SAurabindo Pillai __func__, j, NextSurfaceToAssignDETPiece, 1143dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]); 1144dda4fb85SAurabindo Pillai #endif 1145dda4fb85SAurabindo Pillai 1146dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] = 1147dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] 1148dda4fb85SAurabindo Pillai + NextDETBufferPieceInKByte 1149dda4fb85SAurabindo Pillai / (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]); 1150dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1151dda4fb85SAurabindo Pillai dml_print("to %0d\n", DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]); 1152dda4fb85SAurabindo Pillai #endif 1153dda4fb85SAurabindo Pillai 1154dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - NextDETBufferPieceInKByte; 1155dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[NextSurfaceToAssignDETPiece] = true; 1156dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece - 1157dda4fb85SAurabindo Pillai (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] + 1158dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]); 1159dda4fb85SAurabindo Pillai } 1160dda4fb85SAurabindo Pillai } 1161dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = MinCompressedBufferSizeInKByte; 1162dda4fb85SAurabindo Pillai } 1163dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = *CompressedBufferSizeInkByte * CompressedBufferSegmentSizeInkByteFinal / 64; 1164dda4fb85SAurabindo Pillai 1165dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1166dda4fb85SAurabindo Pillai dml_print("DML::%s: --- After bandwidth adjustment ---\n", __func__); 1167dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, *CompressedBufferSizeInkByte); 1168dda4fb85SAurabindo Pillai for (uint k = 0; k < NumberOfActiveSurfaces; ++k) { 1169dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d (TotalReadBandWidth=%f)\n", 1170dda4fb85SAurabindo Pillai __func__, k, DETBufferSizeInKByte[k], ReadBandwidthLuma[k] + ReadBandwidthChroma[k]); 1171dda4fb85SAurabindo Pillai } 1172dda4fb85SAurabindo Pillai #endif 1173dda4fb85SAurabindo Pillai } // CalculateDETBufferSize 1174dda4fb85SAurabindo Pillai 1175dda4fb85SAurabindo Pillai void dml32_CalculateODMMode( 1176dda4fb85SAurabindo Pillai unsigned int MaximumPixelsPerLinePerDSCUnit, 1177dda4fb85SAurabindo Pillai unsigned int HActive, 1178dda4fb85SAurabindo Pillai enum output_encoder_class Output, 1179dda4fb85SAurabindo Pillai enum odm_combine_policy ODMUse, 1180dda4fb85SAurabindo Pillai double StateDispclk, 1181dda4fb85SAurabindo Pillai double MaxDispclk, 1182dda4fb85SAurabindo Pillai bool DSCEnable, 1183dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP, 1184dda4fb85SAurabindo Pillai unsigned int MaxNumDPP, 1185dda4fb85SAurabindo Pillai double PixelClock, 1186dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading, 1187dda4fb85SAurabindo Pillai double DISPCLKRampingMargin, 1188dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed, 1189dda4fb85SAurabindo Pillai 1190dda4fb85SAurabindo Pillai /* Output */ 1191dda4fb85SAurabindo Pillai bool *TotalAvailablePipesSupport, 1192dda4fb85SAurabindo Pillai unsigned int *NumberOfDPP, 1193dda4fb85SAurabindo Pillai enum odm_combine_mode *ODMMode, 1194dda4fb85SAurabindo Pillai double *RequiredDISPCLKPerSurface) 1195dda4fb85SAurabindo Pillai { 1196dda4fb85SAurabindo Pillai 1197dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithoutODMCombine; 1198dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithODMCombineTwoToOne; 1199dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithODMCombineFourToOne; 1200dda4fb85SAurabindo Pillai 1201dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithoutODMCombine = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_disabled, 1202dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, 1203dda4fb85SAurabindo Pillai MaxDispclk); 1204dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineTwoToOne = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_2to1, 1205dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, 1206dda4fb85SAurabindo Pillai MaxDispclk); 1207dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineFourToOne = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_4to1, 1208dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed, 1209dda4fb85SAurabindo Pillai MaxDispclk); 1210dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = true; 1211dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_disabled; // initialize as disable 1212dda4fb85SAurabindo Pillai 1213dda4fb85SAurabindo Pillai if (ODMUse == dm_odm_combine_policy_none) 1214dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_disabled; 1215dda4fb85SAurabindo Pillai 1216dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithoutODMCombine; 1217dda4fb85SAurabindo Pillai *NumberOfDPP = 0; 1218dda4fb85SAurabindo Pillai 1219dda4fb85SAurabindo Pillai // FIXME check ODMUse == "" condition does it mean bypass or Gabriel means something like don't care?? 1220dda4fb85SAurabindo Pillai // (ODMUse == "" || ODMUse == "CombineAsNeeded") 1221dda4fb85SAurabindo Pillai 1222dda4fb85SAurabindo Pillai if (!(Output == dm_hdmi || Output == dm_dp || Output == dm_edp) && (ODMUse == dm_odm_combine_policy_4to1 || 1223dda4fb85SAurabindo Pillai ((SurfaceRequiredDISPCLKWithODMCombineTwoToOne > StateDispclk || 1224dda4fb85SAurabindo Pillai (DSCEnable && (HActive > 2 * MaximumPixelsPerLinePerDSCUnit)))))) { 1225dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 4 <= MaxNumDPP) { 1226dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_4to1; 1227dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineFourToOne; 1228dda4fb85SAurabindo Pillai *NumberOfDPP = 4; 1229dda4fb85SAurabindo Pillai } else { 1230dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false; 1231dda4fb85SAurabindo Pillai } 1232dda4fb85SAurabindo Pillai } else if (Output != dm_hdmi && (ODMUse == dm_odm_combine_policy_2to1 || 1233dda4fb85SAurabindo Pillai (((SurfaceRequiredDISPCLKWithoutODMCombine > StateDispclk && 1234dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineTwoToOne <= StateDispclk) || 1235dda4fb85SAurabindo Pillai (DSCEnable && (HActive > MaximumPixelsPerLinePerDSCUnit)))))) { 1236dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 2 <= MaxNumDPP) { 1237dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_2to1; 1238dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineTwoToOne; 1239dda4fb85SAurabindo Pillai *NumberOfDPP = 2; 1240dda4fb85SAurabindo Pillai } else { 1241dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false; 1242dda4fb85SAurabindo Pillai } 1243dda4fb85SAurabindo Pillai } else { 1244dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 1 <= MaxNumDPP) 1245dda4fb85SAurabindo Pillai *NumberOfDPP = 1; 1246dda4fb85SAurabindo Pillai else 1247dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false; 1248dda4fb85SAurabindo Pillai } 1249dda4fb85SAurabindo Pillai } 1250dda4fb85SAurabindo Pillai 1251dda4fb85SAurabindo Pillai double dml32_CalculateRequiredDispclk( 1252dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode, 1253dda4fb85SAurabindo Pillai double PixelClock, 1254dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading, 1255dda4fb85SAurabindo Pillai double DISPCLKRampingMargin, 1256dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed, 1257dda4fb85SAurabindo Pillai double MaxDispclk) 1258dda4fb85SAurabindo Pillai { 1259dda4fb85SAurabindo Pillai double RequiredDispclk = 0.; 1260dda4fb85SAurabindo Pillai double PixelClockAfterODM; 1261dda4fb85SAurabindo Pillai double DISPCLKWithRampingRoundedToDFSGranularity; 1262dda4fb85SAurabindo Pillai double DISPCLKWithoutRampingRoundedToDFSGranularity; 1263dda4fb85SAurabindo Pillai double MaxDispclkRoundedDownToDFSGranularity; 1264dda4fb85SAurabindo Pillai 1265dda4fb85SAurabindo Pillai if (ODMMode == dm_odm_combine_mode_4to1) 1266dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock / 4; 1267dda4fb85SAurabindo Pillai else if (ODMMode == dm_odm_combine_mode_2to1) 1268dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock / 2; 1269dda4fb85SAurabindo Pillai else 1270dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock; 1271dda4fb85SAurabindo Pillai 1272dda4fb85SAurabindo Pillai 1273dda4fb85SAurabindo Pillai DISPCLKWithRampingRoundedToDFSGranularity = dml32_RoundToDFSGranularity( 1274dda4fb85SAurabindo Pillai PixelClockAfterODM * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100) 1275dda4fb85SAurabindo Pillai * (1 + DISPCLKRampingMargin / 100), 1, DISPCLKDPPCLKVCOSpeed); 1276dda4fb85SAurabindo Pillai 1277dda4fb85SAurabindo Pillai DISPCLKWithoutRampingRoundedToDFSGranularity = dml32_RoundToDFSGranularity( 1278dda4fb85SAurabindo Pillai PixelClockAfterODM * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100), 1, DISPCLKDPPCLKVCOSpeed); 1279dda4fb85SAurabindo Pillai 1280dda4fb85SAurabindo Pillai MaxDispclkRoundedDownToDFSGranularity = dml32_RoundToDFSGranularity(MaxDispclk, 0, DISPCLKDPPCLKVCOSpeed); 1281dda4fb85SAurabindo Pillai 1282dda4fb85SAurabindo Pillai if (DISPCLKWithoutRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) 1283dda4fb85SAurabindo Pillai RequiredDispclk = DISPCLKWithoutRampingRoundedToDFSGranularity; 1284dda4fb85SAurabindo Pillai else if (DISPCLKWithRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity) 1285dda4fb85SAurabindo Pillai RequiredDispclk = MaxDispclkRoundedDownToDFSGranularity; 1286dda4fb85SAurabindo Pillai else 1287dda4fb85SAurabindo Pillai RequiredDispclk = DISPCLKWithRampingRoundedToDFSGranularity; 1288dda4fb85SAurabindo Pillai 1289dda4fb85SAurabindo Pillai return RequiredDispclk; 1290dda4fb85SAurabindo Pillai } 1291dda4fb85SAurabindo Pillai 1292dda4fb85SAurabindo Pillai double dml32_RoundToDFSGranularity(double Clock, bool round_up, double VCOSpeed) 1293dda4fb85SAurabindo Pillai { 1294dda4fb85SAurabindo Pillai if (Clock <= 0.0) 1295dda4fb85SAurabindo Pillai return 0.0; 1296dda4fb85SAurabindo Pillai 1297dda4fb85SAurabindo Pillai if (round_up) 1298dda4fb85SAurabindo Pillai return VCOSpeed * 4.0 / dml_floor(VCOSpeed * 4.0 / Clock, 1.0); 1299dda4fb85SAurabindo Pillai else 1300dda4fb85SAurabindo Pillai return VCOSpeed * 4.0 / dml_ceil(VCOSpeed * 4.0 / Clock, 1.0); 1301dda4fb85SAurabindo Pillai } 1302dda4fb85SAurabindo Pillai 1303dda4fb85SAurabindo Pillai void dml32_CalculateOutputLink( 1304dda4fb85SAurabindo Pillai double PHYCLKPerState, 1305dda4fb85SAurabindo Pillai double PHYCLKD18PerState, 1306dda4fb85SAurabindo Pillai double PHYCLKD32PerState, 1307dda4fb85SAurabindo Pillai double Downspreading, 1308dda4fb85SAurabindo Pillai bool IsMainSurfaceUsingTheIndicatedTiming, 1309dda4fb85SAurabindo Pillai enum output_encoder_class Output, 1310dda4fb85SAurabindo Pillai enum output_format_class OutputFormat, 1311dda4fb85SAurabindo Pillai unsigned int HTotal, 1312dda4fb85SAurabindo Pillai unsigned int HActive, 1313dda4fb85SAurabindo Pillai double PixelClockBackEnd, 1314dda4fb85SAurabindo Pillai double ForcedOutputLinkBPP, 1315dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent, 1316dda4fb85SAurabindo Pillai unsigned int NumberOfDSCSlices, 1317dda4fb85SAurabindo Pillai double AudioSampleRate, 1318dda4fb85SAurabindo Pillai unsigned int AudioSampleLayout, 1319dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeNoDSC, 1320dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeDSC, 1321dda4fb85SAurabindo Pillai bool DSCEnable, 1322dda4fb85SAurabindo Pillai unsigned int OutputLinkDPLanes, 1323dda4fb85SAurabindo Pillai enum dm_output_link_dp_rate OutputLinkDPRate, 1324dda4fb85SAurabindo Pillai 1325dda4fb85SAurabindo Pillai /* Output */ 1326dda4fb85SAurabindo Pillai bool *RequiresDSC, 1327dda4fb85SAurabindo Pillai double *RequiresFEC, 1328dda4fb85SAurabindo Pillai double *OutBpp, 1329dda4fb85SAurabindo Pillai enum dm_output_type *OutputType, 1330dda4fb85SAurabindo Pillai enum dm_output_rate *OutputRate, 1331dda4fb85SAurabindo Pillai unsigned int *RequiredSlots) 1332dda4fb85SAurabindo Pillai { 1333dda4fb85SAurabindo Pillai bool LinkDSCEnable; 1334dda4fb85SAurabindo Pillai unsigned int dummy; 1335dda4fb85SAurabindo Pillai *RequiresDSC = false; 1336dda4fb85SAurabindo Pillai *RequiresFEC = false; 1337dda4fb85SAurabindo Pillai *OutBpp = 0; 1338dda4fb85SAurabindo Pillai *OutputType = dm_output_type_unknown; 1339dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_unknown; 1340dda4fb85SAurabindo Pillai 1341dda4fb85SAurabindo Pillai if (IsMainSurfaceUsingTheIndicatedTiming) { 1342dda4fb85SAurabindo Pillai if (Output == dm_hdmi) { 1343dda4fb85SAurabindo Pillai *RequiresDSC = false; 1344dda4fb85SAurabindo Pillai *RequiresFEC = false; 1345dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP(dml_min(600, PHYCLKPerState) * 10, 3, HTotal, HActive, 1346dda4fb85SAurabindo Pillai PixelClockBackEnd, ForcedOutputLinkBPP, false, Output, OutputFormat, 1347dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1348dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, &dummy); 1349dda4fb85SAurabindo Pillai //OutputTypeAndRate = "HDMI"; 1350dda4fb85SAurabindo Pillai *OutputType = dm_output_type_hdmi; 1351dda4fb85SAurabindo Pillai 1352dda4fb85SAurabindo Pillai } else if (Output == dm_dp || Output == dm_dp2p0 || Output == dm_edp) { 1353dda4fb85SAurabindo Pillai if (DSCEnable == true) { 1354dda4fb85SAurabindo Pillai *RequiresDSC = true; 1355dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1356dda4fb85SAurabindo Pillai if (Output == dm_dp || Output == dm_dp2p0) 1357dda4fb85SAurabindo Pillai *RequiresFEC = true; 1358dda4fb85SAurabindo Pillai else 1359dda4fb85SAurabindo Pillai *RequiresFEC = false; 1360dda4fb85SAurabindo Pillai } else { 1361dda4fb85SAurabindo Pillai *RequiresDSC = false; 1362dda4fb85SAurabindo Pillai LinkDSCEnable = false; 1363dda4fb85SAurabindo Pillai if (Output == dm_dp2p0) 1364dda4fb85SAurabindo Pillai *RequiresFEC = true; 1365dda4fb85SAurabindo Pillai else 1366dda4fb85SAurabindo Pillai *RequiresFEC = false; 1367dda4fb85SAurabindo Pillai } 1368dda4fb85SAurabindo Pillai if (Output == dm_dp2p0) { 1369dda4fb85SAurabindo Pillai *OutBpp = 0; 1370dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr10) && 1371dda4fb85SAurabindo Pillai PHYCLKD32PerState >= 10000 / 32) { 1372dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 10000, 1373dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1374dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat, 1375dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, 1376dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1377dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKD32PerState < 13500 / 32 && DSCEnable == true && 1378dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) { 1379dda4fb85SAurabindo Pillai *RequiresDSC = true; 1380dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1381dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 10000, 1382dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1383dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1384dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1385dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1386dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1387dda4fb85SAurabindo Pillai } 1388dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR10"; 1389dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0; 1390dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr10; 1391dda4fb85SAurabindo Pillai } 1392dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr13p5) && 1393dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKD32PerState >= 13500 / 32) { 1394dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 13500, 1395dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1396dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat, 1397dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, 1398dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1399dda4fb85SAurabindo Pillai 1400dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKD32PerState < 20000 / 32 && DSCEnable == true && 1401dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) { 1402dda4fb85SAurabindo Pillai *RequiresDSC = true; 1403dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1404dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 13500, 1405dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1406dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1407dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1408dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1409dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1410dda4fb85SAurabindo Pillai } 1411dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR13p5"; 1412dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0; 1413dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr13p5; 1414dda4fb85SAurabindo Pillai } 1415dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr20) && 1416dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKD32PerState >= 20000 / 32) { 1417dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 20000, 1418dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1419dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat, 1420dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, 1421dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1422dda4fb85SAurabindo Pillai if (*OutBpp == 0 && DSCEnable == true && ForcedOutputLinkBPP == 0) { 1423dda4fb85SAurabindo Pillai *RequiresDSC = true; 1424dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1425dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 20000, 1426dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1427dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1428dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1429dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1430dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1431dda4fb85SAurabindo Pillai } 1432dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR20"; 1433dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0; 1434dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr20; 1435dda4fb85SAurabindo Pillai } 1436dda4fb85SAurabindo Pillai } else { 1437dda4fb85SAurabindo Pillai *OutBpp = 0; 1438dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr) && 1439dda4fb85SAurabindo Pillai PHYCLKPerState >= 270) { 1440dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 2700, 1441dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1442dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat, 1443dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, 1444dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1445dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKPerState < 540 && DSCEnable == true && 1446dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) { 1447dda4fb85SAurabindo Pillai *RequiresDSC = true; 1448dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1449dda4fb85SAurabindo Pillai if (Output == dm_dp) 1450dda4fb85SAurabindo Pillai *RequiresFEC = true; 1451dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 2700, 1452dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1453dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1454dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1455dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1456dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1457dda4fb85SAurabindo Pillai } 1458dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR"; 1459dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp; 1460dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr; 1461dda4fb85SAurabindo Pillai } 1462dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr2) && 1463dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKPerState >= 540) { 1464dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 5400, 1465dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1466dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat, 1467dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, 1468dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1469dda4fb85SAurabindo Pillai 1470dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKPerState < 810 && DSCEnable == true && 1471dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) { 1472dda4fb85SAurabindo Pillai *RequiresDSC = true; 1473dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1474dda4fb85SAurabindo Pillai if (Output == dm_dp) 1475dda4fb85SAurabindo Pillai *RequiresFEC = true; 1476dda4fb85SAurabindo Pillai 1477dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 5400, 1478dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1479dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1480dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1481dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1482dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1483dda4fb85SAurabindo Pillai } 1484dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR2"; 1485dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp; 1486dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr2; 1487dda4fb85SAurabindo Pillai } 1488dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr3) && *OutBpp == 0 && PHYCLKPerState >= 810) { 1489dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 8100, 1490dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1491dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1492dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices, 1493dda4fb85SAurabindo Pillai AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, 1494dda4fb85SAurabindo Pillai RequiredSlots); 1495dda4fb85SAurabindo Pillai 1496dda4fb85SAurabindo Pillai if (*OutBpp == 0 && DSCEnable == true && ForcedOutputLinkBPP == 0) { 1497dda4fb85SAurabindo Pillai *RequiresDSC = true; 1498dda4fb85SAurabindo Pillai LinkDSCEnable = true; 1499dda4fb85SAurabindo Pillai if (Output == dm_dp) 1500dda4fb85SAurabindo Pillai *RequiresFEC = true; 1501dda4fb85SAurabindo Pillai 1502dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 8100, 1503dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd, 1504dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, 1505dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, 1506dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout, 1507dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots); 1508dda4fb85SAurabindo Pillai } 1509dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR3"; 1510dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp; 1511dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr3; 1512dda4fb85SAurabindo Pillai } 1513dda4fb85SAurabindo Pillai } 1514dda4fb85SAurabindo Pillai } 1515dda4fb85SAurabindo Pillai } 1516dda4fb85SAurabindo Pillai } 1517dda4fb85SAurabindo Pillai 1518dda4fb85SAurabindo Pillai void dml32_CalculateDPPCLK( 1519dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 1520dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading, 1521dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed, 1522dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPP[], 1523dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 1524dda4fb85SAurabindo Pillai 1525dda4fb85SAurabindo Pillai /* output */ 1526dda4fb85SAurabindo Pillai double *GlobalDPPCLK, 1527dda4fb85SAurabindo Pillai double Dppclk[]) 1528dda4fb85SAurabindo Pillai { 1529dda4fb85SAurabindo Pillai unsigned int k; 1530dda4fb85SAurabindo Pillai *GlobalDPPCLK = 0; 1531dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1532dda4fb85SAurabindo Pillai Dppclk[k] = DPPCLKUsingSingleDPP[k] / DPPPerSurface[k] * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100); 1533dda4fb85SAurabindo Pillai *GlobalDPPCLK = dml_max(*GlobalDPPCLK, Dppclk[k]); 1534dda4fb85SAurabindo Pillai } 1535dda4fb85SAurabindo Pillai *GlobalDPPCLK = dml32_RoundToDFSGranularity(*GlobalDPPCLK, 1, DISPCLKDPPCLKVCOSpeed); 1536dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) 1537dda4fb85SAurabindo Pillai Dppclk[k] = *GlobalDPPCLK / 255 * dml_ceil(Dppclk[k] * 255.0 / *GlobalDPPCLK, 1.0); 1538dda4fb85SAurabindo Pillai } 1539dda4fb85SAurabindo Pillai 1540dda4fb85SAurabindo Pillai double dml32_TruncToValidBPP( 1541dda4fb85SAurabindo Pillai double LinkBitRate, 1542dda4fb85SAurabindo Pillai unsigned int Lanes, 1543dda4fb85SAurabindo Pillai unsigned int HTotal, 1544dda4fb85SAurabindo Pillai unsigned int HActive, 1545dda4fb85SAurabindo Pillai double PixelClock, 1546dda4fb85SAurabindo Pillai double DesiredBPP, 1547dda4fb85SAurabindo Pillai bool DSCEnable, 1548dda4fb85SAurabindo Pillai enum output_encoder_class Output, 1549dda4fb85SAurabindo Pillai enum output_format_class Format, 1550dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent, 1551dda4fb85SAurabindo Pillai unsigned int DSCSlices, 1552dda4fb85SAurabindo Pillai unsigned int AudioRate, 1553dda4fb85SAurabindo Pillai unsigned int AudioLayout, 1554dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeNoDSC, 1555dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeDSC, 1556dda4fb85SAurabindo Pillai /* Output */ 1557dda4fb85SAurabindo Pillai unsigned int *RequiredSlots) 1558dda4fb85SAurabindo Pillai { 1559dda4fb85SAurabindo Pillai double MaxLinkBPP; 1560dda4fb85SAurabindo Pillai unsigned int MinDSCBPP; 1561dda4fb85SAurabindo Pillai double MaxDSCBPP; 1562dda4fb85SAurabindo Pillai unsigned int NonDSCBPP0; 1563dda4fb85SAurabindo Pillai unsigned int NonDSCBPP1; 1564dda4fb85SAurabindo Pillai unsigned int NonDSCBPP2; 1565dda4fb85SAurabindo Pillai unsigned int NonDSCBPP3; 1566dda4fb85SAurabindo Pillai 1567dda4fb85SAurabindo Pillai if (Format == dm_420) { 1568dda4fb85SAurabindo Pillai NonDSCBPP0 = 12; 1569dda4fb85SAurabindo Pillai NonDSCBPP1 = 15; 1570dda4fb85SAurabindo Pillai NonDSCBPP2 = 18; 1571dda4fb85SAurabindo Pillai MinDSCBPP = 6; 1572dda4fb85SAurabindo Pillai MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1 / 16; 1573dda4fb85SAurabindo Pillai } else if (Format == dm_444) { 1574dda4fb85SAurabindo Pillai NonDSCBPP0 = 18; 1575dda4fb85SAurabindo Pillai NonDSCBPP1 = 24; 1576dda4fb85SAurabindo Pillai NonDSCBPP2 = 30; 1577dda4fb85SAurabindo Pillai NonDSCBPP3 = 36; 1578dda4fb85SAurabindo Pillai MinDSCBPP = 8; 1579dda4fb85SAurabindo Pillai MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16; 1580dda4fb85SAurabindo Pillai } else { 1581dda4fb85SAurabindo Pillai if (Output == dm_hdmi) { 1582dda4fb85SAurabindo Pillai NonDSCBPP0 = 24; 1583dda4fb85SAurabindo Pillai NonDSCBPP1 = 24; 1584dda4fb85SAurabindo Pillai NonDSCBPP2 = 24; 1585dda4fb85SAurabindo Pillai } else { 1586dda4fb85SAurabindo Pillai NonDSCBPP0 = 16; 1587dda4fb85SAurabindo Pillai NonDSCBPP1 = 20; 1588dda4fb85SAurabindo Pillai NonDSCBPP2 = 24; 1589dda4fb85SAurabindo Pillai } 1590dda4fb85SAurabindo Pillai if (Format == dm_n422) { 1591dda4fb85SAurabindo Pillai MinDSCBPP = 7; 1592dda4fb85SAurabindo Pillai MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0; 1593dda4fb85SAurabindo Pillai } else { 1594dda4fb85SAurabindo Pillai MinDSCBPP = 8; 1595dda4fb85SAurabindo Pillai MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0; 1596dda4fb85SAurabindo Pillai } 1597dda4fb85SAurabindo Pillai } 1598dda4fb85SAurabindo Pillai if (Output == dm_dp2p0) { 1599dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate * Lanes / PixelClock * 128 / 132 * 383 / 384 * 65536 / 65540; 1600dda4fb85SAurabindo Pillai } else if (DSCEnable && Output == dm_dp) { 1601dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock * (1 - 2.4 / 100); 1602dda4fb85SAurabindo Pillai } else { 1603dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock; 1604dda4fb85SAurabindo Pillai } 1605dda4fb85SAurabindo Pillai 1606dda4fb85SAurabindo Pillai if (DSCEnable) { 1607dda4fb85SAurabindo Pillai if (ODMModeDSC == dm_odm_combine_mode_4to1) 1608dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 16); 1609dda4fb85SAurabindo Pillai else if (ODMModeDSC == dm_odm_combine_mode_2to1) 1610dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 32); 1611dda4fb85SAurabindo Pillai else if (ODMModeDSC == dm_odm_split_mode_1to2) 1612dda4fb85SAurabindo Pillai MaxLinkBPP = 2 * MaxLinkBPP; 1613dda4fb85SAurabindo Pillai } else { 1614dda4fb85SAurabindo Pillai if (ODMModeNoDSC == dm_odm_combine_mode_4to1) 1615dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 16); 1616dda4fb85SAurabindo Pillai else if (ODMModeNoDSC == dm_odm_combine_mode_2to1) 1617dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 32); 1618dda4fb85SAurabindo Pillai else if (ODMModeNoDSC == dm_odm_split_mode_1to2) 1619dda4fb85SAurabindo Pillai MaxLinkBPP = 2 * MaxLinkBPP; 1620dda4fb85SAurabindo Pillai } 1621dda4fb85SAurabindo Pillai 1622dda4fb85SAurabindo Pillai if (DesiredBPP == 0) { 1623dda4fb85SAurabindo Pillai if (DSCEnable) { 1624dda4fb85SAurabindo Pillai if (MaxLinkBPP < MinDSCBPP) 1625dda4fb85SAurabindo Pillai return BPP_INVALID; 1626dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= MaxDSCBPP) 1627dda4fb85SAurabindo Pillai return MaxDSCBPP; 1628dda4fb85SAurabindo Pillai else 1629dda4fb85SAurabindo Pillai return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0; 1630dda4fb85SAurabindo Pillai } else { 1631dda4fb85SAurabindo Pillai if (MaxLinkBPP >= NonDSCBPP3) 1632dda4fb85SAurabindo Pillai return NonDSCBPP3; 1633dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= NonDSCBPP2) 1634dda4fb85SAurabindo Pillai return NonDSCBPP2; 1635dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= NonDSCBPP1) 1636dda4fb85SAurabindo Pillai return NonDSCBPP1; 1637dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= NonDSCBPP0) 1638dda4fb85SAurabindo Pillai return 16.0; 1639dda4fb85SAurabindo Pillai else 1640dda4fb85SAurabindo Pillai return BPP_INVALID; 1641dda4fb85SAurabindo Pillai } 1642dda4fb85SAurabindo Pillai } else { 1643dda4fb85SAurabindo Pillai if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 || 1644dda4fb85SAurabindo Pillai DesiredBPP == NonDSCBPP0 || DesiredBPP == NonDSCBPP3)) || 1645dda4fb85SAurabindo Pillai (DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP))) 1646dda4fb85SAurabindo Pillai return BPP_INVALID; 1647dda4fb85SAurabindo Pillai else 1648dda4fb85SAurabindo Pillai return DesiredBPP; 1649dda4fb85SAurabindo Pillai } 1650dda4fb85SAurabindo Pillai 1651dda4fb85SAurabindo Pillai *RequiredSlots = dml_ceil(DesiredBPP / MaxLinkBPP * 64, 1); 1652dda4fb85SAurabindo Pillai 1653dda4fb85SAurabindo Pillai return BPP_INVALID; 1654dda4fb85SAurabindo Pillai } // TruncToValidBPP 1655dda4fb85SAurabindo Pillai 1656dda4fb85SAurabindo Pillai double dml32_RequiredDTBCLK( 1657dda4fb85SAurabindo Pillai bool DSCEnable, 1658dda4fb85SAurabindo Pillai double PixelClock, 1659dda4fb85SAurabindo Pillai enum output_format_class OutputFormat, 1660dda4fb85SAurabindo Pillai double OutputBpp, 1661dda4fb85SAurabindo Pillai unsigned int DSCSlices, 1662dda4fb85SAurabindo Pillai unsigned int HTotal, 1663dda4fb85SAurabindo Pillai unsigned int HActive, 1664dda4fb85SAurabindo Pillai unsigned int AudioRate, 1665dda4fb85SAurabindo Pillai unsigned int AudioLayout) 1666dda4fb85SAurabindo Pillai { 1667074293ddSRodrigo Siqueira double PixelWordRate; 1668074293ddSRodrigo Siqueira double HCActive; 1669074293ddSRodrigo Siqueira double HCBlank; 1670074293ddSRodrigo Siqueira double AverageTribyteRate; 1671074293ddSRodrigo Siqueira double HActiveTribyteRate; 1672dda4fb85SAurabindo Pillai 1673dda4fb85SAurabindo Pillai if (DSCEnable != true) 1674dda4fb85SAurabindo Pillai return dml_max(PixelClock / 4.0 * OutputBpp / 24.0, 25.0); 1675dda4fb85SAurabindo Pillai 1676074293ddSRodrigo Siqueira PixelWordRate = PixelClock / (OutputFormat == dm_444 ? 1 : 2); 1677074293ddSRodrigo Siqueira HCActive = dml_ceil(DSCSlices * dml_ceil(OutputBpp * 1678074293ddSRodrigo Siqueira dml_ceil(HActive / DSCSlices, 1) / 8.0, 1) / 3.0, 1); 1679074293ddSRodrigo Siqueira HCBlank = 64 + 32 * 1680074293ddSRodrigo Siqueira dml_ceil(AudioRate * (AudioLayout == 1 ? 1 : 0.25) * HTotal / (PixelClock * 1000), 1); 1681074293ddSRodrigo Siqueira AverageTribyteRate = PixelWordRate * (HCActive + HCBlank) / HTotal; 1682074293ddSRodrigo Siqueira HActiveTribyteRate = PixelWordRate * HCActive / HActive; 1683dda4fb85SAurabindo Pillai return dml_max4(PixelWordRate / 4.0, AverageTribyteRate / 4.0, HActiveTribyteRate / 4.0, 25.0) * 1.002; 1684dda4fb85SAurabindo Pillai } 1685dda4fb85SAurabindo Pillai 1686dda4fb85SAurabindo Pillai unsigned int dml32_DSCDelayRequirement(bool DSCEnabled, 1687dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode, 1688dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent, 1689dda4fb85SAurabindo Pillai double OutputBpp, 1690dda4fb85SAurabindo Pillai unsigned int HActive, 1691dda4fb85SAurabindo Pillai unsigned int HTotal, 1692dda4fb85SAurabindo Pillai unsigned int NumberOfDSCSlices, 1693dda4fb85SAurabindo Pillai enum output_format_class OutputFormat, 1694dda4fb85SAurabindo Pillai enum output_encoder_class Output, 1695dda4fb85SAurabindo Pillai double PixelClock, 1696dda4fb85SAurabindo Pillai double PixelClockBackEnd) 1697dda4fb85SAurabindo Pillai { 1698dda4fb85SAurabindo Pillai unsigned int DSCDelayRequirement_val; 1699dda4fb85SAurabindo Pillai 1700dda4fb85SAurabindo Pillai if (DSCEnabled == true && OutputBpp != 0) { 1701dda4fb85SAurabindo Pillai if (ODMMode == dm_odm_combine_mode_4to1) { 1702dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 4 * (dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, 1703dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices / 4, 1704dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output)); 1705dda4fb85SAurabindo Pillai } else if (ODMMode == dm_odm_combine_mode_2to1) { 1706dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 2 * (dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, 1707dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices / 2, 1708dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output)); 1709dda4fb85SAurabindo Pillai } else { 1710dda4fb85SAurabindo Pillai DSCDelayRequirement_val = dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp, 1711dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices, 1712dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output); 1713dda4fb85SAurabindo Pillai } 1714dda4fb85SAurabindo Pillai 1715dda4fb85SAurabindo Pillai DSCDelayRequirement_val = DSCDelayRequirement_val + (HTotal - HActive) * 1716dda4fb85SAurabindo Pillai dml_ceil(DSCDelayRequirement_val / HActive, 1); 1717dda4fb85SAurabindo Pillai 1718dda4fb85SAurabindo Pillai DSCDelayRequirement_val = DSCDelayRequirement_val * PixelClock / PixelClockBackEnd; 1719dda4fb85SAurabindo Pillai 1720dda4fb85SAurabindo Pillai } else { 1721dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 0; 1722dda4fb85SAurabindo Pillai } 1723dda4fb85SAurabindo Pillai 1724dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 1725dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCEnabled = %d\n", __func__, DSCEnabled); 1726dda4fb85SAurabindo Pillai dml_print("DML::%s: OutputBpp = %f\n", __func__, OutputBpp); 1727dda4fb85SAurabindo Pillai dml_print("DML::%s: HActive = %d\n", __func__, HActive); 1728dda4fb85SAurabindo Pillai dml_print("DML::%s: OutputFormat = %d\n", __func__, OutputFormat); 1729dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCInputBitPerComponent = %d\n", __func__, DSCInputBitPerComponent); 1730dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfDSCSlices = %d\n", __func__, NumberOfDSCSlices); 1731dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCDelayRequirement_val = %d\n", __func__, DSCDelayRequirement_val); 1732dda4fb85SAurabindo Pillai #endif 1733dda4fb85SAurabindo Pillai 1734dda4fb85SAurabindo Pillai return DSCDelayRequirement_val; 1735dda4fb85SAurabindo Pillai } 1736dda4fb85SAurabindo Pillai 1737dda4fb85SAurabindo Pillai void dml32_CalculateSurfaceSizeInMall( 1738dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 1739dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCN, 1740dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[], 1741dda4fb85SAurabindo Pillai bool DCCEnable[], 1742dda4fb85SAurabindo Pillai bool ViewportStationary[], 1743dda4fb85SAurabindo Pillai unsigned int ViewportXStartY[], 1744dda4fb85SAurabindo Pillai unsigned int ViewportYStartY[], 1745dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[], 1746dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[], 1747dda4fb85SAurabindo Pillai unsigned int ViewportWidthY[], 1748dda4fb85SAurabindo Pillai unsigned int ViewportHeightY[], 1749dda4fb85SAurabindo Pillai unsigned int BytesPerPixelY[], 1750dda4fb85SAurabindo Pillai unsigned int ViewportWidthC[], 1751dda4fb85SAurabindo Pillai unsigned int ViewportHeightC[], 1752dda4fb85SAurabindo Pillai unsigned int BytesPerPixelC[], 1753dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[], 1754dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[], 1755dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[], 1756dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[], 1757dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[], 1758dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[], 1759dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[], 1760dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[], 1761dda4fb85SAurabindo Pillai unsigned int ReadBlockWidthY[], 1762dda4fb85SAurabindo Pillai unsigned int ReadBlockWidthC[], 1763dda4fb85SAurabindo Pillai unsigned int ReadBlockHeightY[], 1764dda4fb85SAurabindo Pillai unsigned int ReadBlockHeightC[], 1765dda4fb85SAurabindo Pillai 1766dda4fb85SAurabindo Pillai /* Output */ 1767dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[], 1768dda4fb85SAurabindo Pillai bool *ExceededMALLSize) 1769dda4fb85SAurabindo Pillai { 1770dda4fb85SAurabindo Pillai unsigned int TotalSurfaceSizeInMALL = 0; 1771dda4fb85SAurabindo Pillai unsigned int k; 1772dda4fb85SAurabindo Pillai 1773dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1774dda4fb85SAurabindo Pillai if (ViewportStationary[k]) { 1775dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = dml_min(dml_ceil(SurfaceWidthY[k], ReadBlockWidthY[k]), 1776dda4fb85SAurabindo Pillai dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + ReadBlockWidthY[k] - 1, 1777dda4fb85SAurabindo Pillai ReadBlockWidthY[k]) - dml_floor(ViewportXStartY[k], 1778dda4fb85SAurabindo Pillai ReadBlockWidthY[k])) * dml_min(dml_ceil(SurfaceHeightY[k], 1779dda4fb85SAurabindo Pillai ReadBlockHeightY[k]), dml_floor(ViewportYStartY[k] + 1780dda4fb85SAurabindo Pillai ViewportHeightY[k] + ReadBlockHeightY[k] - 1, ReadBlockHeightY[k]) - 1781dda4fb85SAurabindo Pillai dml_floor(ViewportYStartY[k], ReadBlockHeightY[k])) * BytesPerPixelY[k]; 1782dda4fb85SAurabindo Pillai 1783dda4fb85SAurabindo Pillai if (ReadBlockWidthC[k] > 0) { 1784dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1785dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceWidthC[k], ReadBlockWidthC[k]), 1786dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + 1787dda4fb85SAurabindo Pillai ReadBlockWidthC[k] - 1, ReadBlockWidthC[k]) - 1788dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k], ReadBlockWidthC[k])) * 1789dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceHeightC[k], ReadBlockHeightC[k]), 1790dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + 1791dda4fb85SAurabindo Pillai ReadBlockHeightC[k] - 1, ReadBlockHeightC[k]) - 1792dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k], ReadBlockHeightC[k])) * 1793dda4fb85SAurabindo Pillai BytesPerPixelC[k]; 1794dda4fb85SAurabindo Pillai } 1795dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) { 1796dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1797dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceWidthY[k], 8 * Read256BytesBlockWidthY[k]), 1798dda4fb85SAurabindo Pillai dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + 8 * 1799dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1, 8 * Read256BytesBlockWidthY[k]) 1800dda4fb85SAurabindo Pillai - dml_floor(ViewportXStartY[k], 8 * Read256BytesBlockWidthY[k])) 1801dda4fb85SAurabindo Pillai * dml_min(dml_ceil(SurfaceHeightY[k], 8 * 1802dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]), dml_floor(ViewportYStartY[k] + 1803dda4fb85SAurabindo Pillai ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1, 8 * 1804dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStartY[k], 8 1805dda4fb85SAurabindo Pillai * Read256BytesBlockHeightY[k])) * BytesPerPixelY[k] / 256; 1806dda4fb85SAurabindo Pillai if (Read256BytesBlockWidthC[k] > 0) { 1807dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1808dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceWidthC[k], 8 * 1809dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]), 1810dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + 8 1811dda4fb85SAurabindo Pillai * Read256BytesBlockWidthC[k] - 1, 8 * 1812dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) - 1813dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k], 8 * 1814dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k])) * 1815dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceHeightC[k], 8 * 1816dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]), 1817dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + ViewportHeightC[k] + 1818dda4fb85SAurabindo Pillai 8 * Read256BytesBlockHeightC[k] - 1, 8 * 1819dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) - 1820dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k], 8 * 1821dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k])) * 1822dda4fb85SAurabindo Pillai BytesPerPixelC[k] / 256; 1823dda4fb85SAurabindo Pillai } 1824dda4fb85SAurabindo Pillai } 1825dda4fb85SAurabindo Pillai } else { 1826dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + 1827dda4fb85SAurabindo Pillai ReadBlockWidthY[k] - 1), ReadBlockWidthY[k]) * 1828dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + 1829dda4fb85SAurabindo Pillai ReadBlockHeightY[k] - 1), ReadBlockHeightY[k]) * 1830dda4fb85SAurabindo Pillai BytesPerPixelY[k]; 1831dda4fb85SAurabindo Pillai if (ReadBlockWidthC[k] > 0) { 1832dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1833dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + 1834dda4fb85SAurabindo Pillai ReadBlockWidthC[k] - 1), ReadBlockWidthC[k]) * 1835dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + 1836dda4fb85SAurabindo Pillai ReadBlockHeightC[k] - 1), ReadBlockHeightC[k]) * 1837dda4fb85SAurabindo Pillai BytesPerPixelC[k]; 1838dda4fb85SAurabindo Pillai } 1839dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) { 1840dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1841dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] + 8 * 1842dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1), 8 * 1843dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) * 1844dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + 8 * 1845dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k] - 1), 8 * 1846dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) * BytesPerPixelY[k] / 256; 1847dda4fb85SAurabindo Pillai 1848dda4fb85SAurabindo Pillai if (Read256BytesBlockWidthC[k] > 0) { 1849dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] + 1850dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] + 8 * 1851dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k] - 1), 8 * 1852dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) * 1853dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + 8 * 1854dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k] - 1), 8 * 1855dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) * 1856dda4fb85SAurabindo Pillai BytesPerPixelC[k] / 256; 1857dda4fb85SAurabindo Pillai } 1858dda4fb85SAurabindo Pillai } 1859dda4fb85SAurabindo Pillai } 1860dda4fb85SAurabindo Pillai } 1861dda4fb85SAurabindo Pillai 1862dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1863dda4fb85SAurabindo Pillai if (UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable) 1864dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k]; 1865dda4fb85SAurabindo Pillai } 1866dda4fb85SAurabindo Pillai *ExceededMALLSize = (TotalSurfaceSizeInMALL <= MALLAllocatedForDCN * 1024 * 1024 ? false : true); 1867dda4fb85SAurabindo Pillai } // CalculateSurfaceSizeInMall 1868dda4fb85SAurabindo Pillai 1869dda4fb85SAurabindo Pillai void dml32_CalculateVMRowAndSwath( 1870c3b3f9baSAlex Deucher struct dml32_CalculateVMRowAndSwath *st_vars, 1871dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 1872dda4fb85SAurabindo Pillai DmlPipe myPipe[], 1873dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[], 1874dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequestsLuma, 1875dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequestsChroma, 1876dda4fb85SAurabindo Pillai unsigned int DCCMetaBufferSizeBytes, 1877dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[], 1878dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 1879dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCN, 1880dda4fb85SAurabindo Pillai double SwathWidthY[], 1881dda4fb85SAurabindo Pillai double SwathWidthC[], 1882dda4fb85SAurabindo Pillai bool GPUVMEnable, 1883dda4fb85SAurabindo Pillai bool HostVMEnable, 1884dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels, 1885dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels, 1886dda4fb85SAurabindo Pillai unsigned int GPUVMMinPageSizeKBytes[], 1887dda4fb85SAurabindo Pillai unsigned int HostVMMinPageSize, 1888dda4fb85SAurabindo Pillai 1889dda4fb85SAurabindo Pillai /* Output */ 1890dda4fb85SAurabindo Pillai bool PTEBufferSizeNotExceeded[], 1891dda4fb85SAurabindo Pillai bool DCCMetaBufferSizeNotExceeded[], 1892dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[], 1893dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[], 1894dda4fb85SAurabindo Pillai unsigned int dpte_row_height_luma[], 1895dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma[], 1896dda4fb85SAurabindo Pillai unsigned int dpte_row_height_linear_luma[], // VBA_DELTA 1897dda4fb85SAurabindo Pillai unsigned int dpte_row_height_linear_chroma[], // VBA_DELTA 1898dda4fb85SAurabindo Pillai unsigned int meta_req_width[], 1899dda4fb85SAurabindo Pillai unsigned int meta_req_width_chroma[], 1900dda4fb85SAurabindo Pillai unsigned int meta_req_height[], 1901dda4fb85SAurabindo Pillai unsigned int meta_req_height_chroma[], 1902dda4fb85SAurabindo Pillai unsigned int meta_row_width[], 1903dda4fb85SAurabindo Pillai unsigned int meta_row_width_chroma[], 1904dda4fb85SAurabindo Pillai unsigned int meta_row_height[], 1905dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma[], 1906dda4fb85SAurabindo Pillai unsigned int vm_group_bytes[], 1907dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 1908dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthY[], 1909dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightY[], 1910dda4fb85SAurabindo Pillai unsigned int PTERequestSizeY[], 1911dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthC[], 1912dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightC[], 1913dda4fb85SAurabindo Pillai unsigned int PTERequestSizeC[], 1914dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_l[], 1915dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_l[], 1916dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_c[], 1917dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_c[], 1918dda4fb85SAurabindo Pillai double PrefetchSourceLinesY[], 1919dda4fb85SAurabindo Pillai double PrefetchSourceLinesC[], 1920dda4fb85SAurabindo Pillai double VInitPreFillY[], 1921dda4fb85SAurabindo Pillai double VInitPreFillC[], 1922dda4fb85SAurabindo Pillai unsigned int MaxNumSwathY[], 1923dda4fb85SAurabindo Pillai unsigned int MaxNumSwathC[], 1924dda4fb85SAurabindo Pillai double meta_row_bw[], 1925dda4fb85SAurabindo Pillai double dpte_row_bw[], 1926dda4fb85SAurabindo Pillai double PixelPTEBytesPerRow[], 1927dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesFrame[], 1928dda4fb85SAurabindo Pillai double MetaRowByte[], 1929dda4fb85SAurabindo Pillai bool use_one_row_for_frame[], 1930dda4fb85SAurabindo Pillai bool use_one_row_for_frame_flip[], 1931dda4fb85SAurabindo Pillai bool UsesMALLForStaticScreen[], 1932dda4fb85SAurabindo Pillai bool PTE_BUFFER_MODE[], 1933dda4fb85SAurabindo Pillai unsigned int BIGK_FRAGMENT_SIZE[]) 1934dda4fb85SAurabindo Pillai { 1935dda4fb85SAurabindo Pillai unsigned int k; 1936dda4fb85SAurabindo Pillai 1937dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 1938dda4fb85SAurabindo Pillai if (HostVMEnable == true) { 1939dda4fb85SAurabindo Pillai vm_group_bytes[k] = 512; 1940dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 512; 1941dda4fb85SAurabindo Pillai } else if (GPUVMEnable == true) { 1942dda4fb85SAurabindo Pillai vm_group_bytes[k] = 2048; 1943dda4fb85SAurabindo Pillai if (GPUVMMinPageSizeKBytes[k] >= 64 && IsVertical(myPipe[k].SourceRotation)) 1944dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 512; 1945dda4fb85SAurabindo Pillai else 1946dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 2048; 1947dda4fb85SAurabindo Pillai } else { 1948dda4fb85SAurabindo Pillai vm_group_bytes[k] = 0; 1949dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 0; 1950dda4fb85SAurabindo Pillai } 1951dda4fb85SAurabindo Pillai 1952dda4fb85SAurabindo Pillai if (myPipe[k].SourcePixelFormat == dm_420_8 || myPipe[k].SourcePixelFormat == dm_420_10 || 1953dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat == dm_420_12 || 1954dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat == dm_rgbe_alpha) { 1955dda4fb85SAurabindo Pillai if ((myPipe[k].SourcePixelFormat == dm_420_10 || myPipe[k].SourcePixelFormat == dm_420_12) && 1956dda4fb85SAurabindo Pillai !IsVertical(myPipe[k].SourceRotation)) { 1957c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForLuma[k] = 1958dda4fb85SAurabindo Pillai (PTEBufferSizeInRequestsLuma + PTEBufferSizeInRequestsChroma) / 2; 1959c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForChroma[k] = st_vars->PTEBufferSizeInRequestsForLuma[k]; 1960dda4fb85SAurabindo Pillai } else { 1961c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForLuma[k] = PTEBufferSizeInRequestsLuma; 1962c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForChroma[k] = PTEBufferSizeInRequestsChroma; 1963dda4fb85SAurabindo Pillai } 1964dda4fb85SAurabindo Pillai 1965c3b3f9baSAlex Deucher st_vars->PDEAndMetaPTEBytesFrameC = dml32_CalculateVMAndRowBytes( 1966dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary, 1967dda4fb85SAurabindo Pillai myPipe[k].DCCEnable, 1968dda4fb85SAurabindo Pillai myPipe[k].DPPPerSurface, 1969dda4fb85SAurabindo Pillai myPipe[k].BlockHeight256BytesC, 1970dda4fb85SAurabindo Pillai myPipe[k].BlockWidth256BytesC, 1971dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat, 1972dda4fb85SAurabindo Pillai myPipe[k].SurfaceTiling, 1973dda4fb85SAurabindo Pillai myPipe[k].BytePerPixelC, 1974dda4fb85SAurabindo Pillai myPipe[k].SourceRotation, 1975dda4fb85SAurabindo Pillai SwathWidthC[k], 1976dda4fb85SAurabindo Pillai myPipe[k].ViewportHeightChroma, 1977dda4fb85SAurabindo Pillai myPipe[k].ViewportXStartC, 1978dda4fb85SAurabindo Pillai myPipe[k].ViewportYStartC, 1979dda4fb85SAurabindo Pillai GPUVMEnable, 1980dda4fb85SAurabindo Pillai HostVMEnable, 1981dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels, 1982dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels, 1983dda4fb85SAurabindo Pillai GPUVMMinPageSizeKBytes[k], 1984dda4fb85SAurabindo Pillai HostVMMinPageSize, 1985c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForChroma[k], 1986dda4fb85SAurabindo Pillai myPipe[k].PitchC, 1987dda4fb85SAurabindo Pillai myPipe[k].DCCMetaPitchC, 1988dda4fb85SAurabindo Pillai myPipe[k].BlockWidthC, 1989dda4fb85SAurabindo Pillai myPipe[k].BlockHeightC, 1990dda4fb85SAurabindo Pillai 1991dda4fb85SAurabindo Pillai /* Output */ 1992c3b3f9baSAlex Deucher &st_vars->MetaRowByteC[k], 1993c3b3f9baSAlex Deucher &st_vars->PixelPTEBytesPerRowC[k], 1994dda4fb85SAurabindo Pillai &dpte_row_width_chroma_ub[k], 1995dda4fb85SAurabindo Pillai &dpte_row_height_chroma[k], 1996dda4fb85SAurabindo Pillai &dpte_row_height_linear_chroma[k], 1997c3b3f9baSAlex Deucher &st_vars->PixelPTEBytesPerRowC_one_row_per_frame[k], 1998c3b3f9baSAlex Deucher &st_vars->dpte_row_width_chroma_ub_one_row_per_frame[k], 1999c3b3f9baSAlex Deucher &st_vars->dpte_row_height_chroma_one_row_per_frame[k], 2000dda4fb85SAurabindo Pillai &meta_req_width_chroma[k], 2001dda4fb85SAurabindo Pillai &meta_req_height_chroma[k], 2002dda4fb85SAurabindo Pillai &meta_row_width_chroma[k], 2003dda4fb85SAurabindo Pillai &meta_row_height_chroma[k], 2004dda4fb85SAurabindo Pillai &PixelPTEReqWidthC[k], 2005dda4fb85SAurabindo Pillai &PixelPTEReqHeightC[k], 2006dda4fb85SAurabindo Pillai &PTERequestSizeC[k], 2007dda4fb85SAurabindo Pillai &dpde0_bytes_per_frame_ub_c[k], 2008dda4fb85SAurabindo Pillai &meta_pte_bytes_per_frame_ub_c[k]); 2009dda4fb85SAurabindo Pillai 2010dda4fb85SAurabindo Pillai PrefetchSourceLinesC[k] = dml32_CalculatePrefetchSourceLines( 2011dda4fb85SAurabindo Pillai myPipe[k].VRatioChroma, 2012dda4fb85SAurabindo Pillai myPipe[k].VTapsChroma, 2013dda4fb85SAurabindo Pillai myPipe[k].InterlaceEnable, 2014dda4fb85SAurabindo Pillai myPipe[k].ProgressiveToInterlaceUnitInOPP, 2015dda4fb85SAurabindo Pillai myPipe[k].SwathHeightC, 2016dda4fb85SAurabindo Pillai myPipe[k].SourceRotation, 2017dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary, 2018dda4fb85SAurabindo Pillai SwathWidthC[k], 2019dda4fb85SAurabindo Pillai myPipe[k].ViewportHeightChroma, 2020dda4fb85SAurabindo Pillai myPipe[k].ViewportXStartC, 2021dda4fb85SAurabindo Pillai myPipe[k].ViewportYStartC, 2022dda4fb85SAurabindo Pillai 2023dda4fb85SAurabindo Pillai /* Output */ 2024dda4fb85SAurabindo Pillai &VInitPreFillC[k], 2025dda4fb85SAurabindo Pillai &MaxNumSwathC[k]); 2026dda4fb85SAurabindo Pillai } else { 2027c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForLuma[k] = PTEBufferSizeInRequestsLuma + PTEBufferSizeInRequestsChroma; 2028c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForChroma[k] = 0; 2029c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC[k] = 0; 2030c3b3f9baSAlex Deucher st_vars->PDEAndMetaPTEBytesFrameC = 0; 2031c3b3f9baSAlex Deucher st_vars->MetaRowByteC[k] = 0; 2032dda4fb85SAurabindo Pillai MaxNumSwathC[k] = 0; 2033dda4fb85SAurabindo Pillai PrefetchSourceLinesC[k] = 0; 2034c3b3f9baSAlex Deucher st_vars->dpte_row_height_chroma_one_row_per_frame[k] = 0; 2035c3b3f9baSAlex Deucher st_vars->dpte_row_width_chroma_ub_one_row_per_frame[k] = 0; 2036c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC_one_row_per_frame[k] = 0; 2037dda4fb85SAurabindo Pillai } 2038dda4fb85SAurabindo Pillai 2039c3b3f9baSAlex Deucher st_vars->PDEAndMetaPTEBytesFrameY = dml32_CalculateVMAndRowBytes( 2040dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary, 2041dda4fb85SAurabindo Pillai myPipe[k].DCCEnable, 2042dda4fb85SAurabindo Pillai myPipe[k].DPPPerSurface, 2043dda4fb85SAurabindo Pillai myPipe[k].BlockHeight256BytesY, 2044dda4fb85SAurabindo Pillai myPipe[k].BlockWidth256BytesY, 2045dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat, 2046dda4fb85SAurabindo Pillai myPipe[k].SurfaceTiling, 2047dda4fb85SAurabindo Pillai myPipe[k].BytePerPixelY, 2048dda4fb85SAurabindo Pillai myPipe[k].SourceRotation, 2049dda4fb85SAurabindo Pillai SwathWidthY[k], 2050dda4fb85SAurabindo Pillai myPipe[k].ViewportHeight, 2051dda4fb85SAurabindo Pillai myPipe[k].ViewportXStart, 2052dda4fb85SAurabindo Pillai myPipe[k].ViewportYStart, 2053dda4fb85SAurabindo Pillai GPUVMEnable, 2054dda4fb85SAurabindo Pillai HostVMEnable, 2055dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels, 2056dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels, 2057dda4fb85SAurabindo Pillai GPUVMMinPageSizeKBytes[k], 2058dda4fb85SAurabindo Pillai HostVMMinPageSize, 2059c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForLuma[k], 2060dda4fb85SAurabindo Pillai myPipe[k].PitchY, 2061dda4fb85SAurabindo Pillai myPipe[k].DCCMetaPitchY, 2062dda4fb85SAurabindo Pillai myPipe[k].BlockWidthY, 2063dda4fb85SAurabindo Pillai myPipe[k].BlockHeightY, 2064dda4fb85SAurabindo Pillai 2065dda4fb85SAurabindo Pillai /* Output */ 2066c3b3f9baSAlex Deucher &st_vars->MetaRowByteY[k], 2067c3b3f9baSAlex Deucher &st_vars->PixelPTEBytesPerRowY[k], 2068dda4fb85SAurabindo Pillai &dpte_row_width_luma_ub[k], 2069dda4fb85SAurabindo Pillai &dpte_row_height_luma[k], 2070dda4fb85SAurabindo Pillai &dpte_row_height_linear_luma[k], 2071c3b3f9baSAlex Deucher &st_vars->PixelPTEBytesPerRowY_one_row_per_frame[k], 2072c3b3f9baSAlex Deucher &st_vars->dpte_row_width_luma_ub_one_row_per_frame[k], 2073c3b3f9baSAlex Deucher &st_vars->dpte_row_height_luma_one_row_per_frame[k], 2074dda4fb85SAurabindo Pillai &meta_req_width[k], 2075dda4fb85SAurabindo Pillai &meta_req_height[k], 2076dda4fb85SAurabindo Pillai &meta_row_width[k], 2077dda4fb85SAurabindo Pillai &meta_row_height[k], 2078dda4fb85SAurabindo Pillai &PixelPTEReqWidthY[k], 2079dda4fb85SAurabindo Pillai &PixelPTEReqHeightY[k], 2080dda4fb85SAurabindo Pillai &PTERequestSizeY[k], 2081dda4fb85SAurabindo Pillai &dpde0_bytes_per_frame_ub_l[k], 2082dda4fb85SAurabindo Pillai &meta_pte_bytes_per_frame_ub_l[k]); 2083dda4fb85SAurabindo Pillai 2084dda4fb85SAurabindo Pillai PrefetchSourceLinesY[k] = dml32_CalculatePrefetchSourceLines( 2085dda4fb85SAurabindo Pillai myPipe[k].VRatio, 2086dda4fb85SAurabindo Pillai myPipe[k].VTaps, 2087dda4fb85SAurabindo Pillai myPipe[k].InterlaceEnable, 2088dda4fb85SAurabindo Pillai myPipe[k].ProgressiveToInterlaceUnitInOPP, 2089dda4fb85SAurabindo Pillai myPipe[k].SwathHeightY, 2090dda4fb85SAurabindo Pillai myPipe[k].SourceRotation, 2091dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary, 2092dda4fb85SAurabindo Pillai SwathWidthY[k], 2093dda4fb85SAurabindo Pillai myPipe[k].ViewportHeight, 2094dda4fb85SAurabindo Pillai myPipe[k].ViewportXStart, 2095dda4fb85SAurabindo Pillai myPipe[k].ViewportYStart, 2096dda4fb85SAurabindo Pillai 2097dda4fb85SAurabindo Pillai /* Output */ 2098dda4fb85SAurabindo Pillai &VInitPreFillY[k], 2099dda4fb85SAurabindo Pillai &MaxNumSwathY[k]); 2100dda4fb85SAurabindo Pillai 2101c3b3f9baSAlex Deucher PDEAndMetaPTEBytesFrame[k] = st_vars->PDEAndMetaPTEBytesFrameY + st_vars->PDEAndMetaPTEBytesFrameC; 2102c3b3f9baSAlex Deucher MetaRowByte[k] = st_vars->MetaRowByteY[k] + st_vars->MetaRowByteC[k]; 2103dda4fb85SAurabindo Pillai 2104c3b3f9baSAlex Deucher if (st_vars->PixelPTEBytesPerRowY[k] <= 64 * st_vars->PTEBufferSizeInRequestsForLuma[k] && 2105c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC[k] <= 64 * st_vars->PTEBufferSizeInRequestsForChroma[k]) { 2106dda4fb85SAurabindo Pillai PTEBufferSizeNotExceeded[k] = true; 2107dda4fb85SAurabindo Pillai } else { 2108dda4fb85SAurabindo Pillai PTEBufferSizeNotExceeded[k] = false; 2109dda4fb85SAurabindo Pillai } 2110dda4fb85SAurabindo Pillai 2111c3b3f9baSAlex Deucher st_vars->one_row_per_frame_fits_in_buffer[k] = (st_vars->PixelPTEBytesPerRowY_one_row_per_frame[k] <= 64 * 2 * 2112c3b3f9baSAlex Deucher st_vars->PTEBufferSizeInRequestsForLuma[k] && 2113c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC_one_row_per_frame[k] <= 64 * 2 * st_vars->PTEBufferSizeInRequestsForChroma[k]); 2114dda4fb85SAurabindo Pillai } 2115dda4fb85SAurabindo Pillai 2116dda4fb85SAurabindo Pillai dml32_CalculateMALLUseForStaticScreen( 2117dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, 2118dda4fb85SAurabindo Pillai MALLAllocatedForDCN, 2119dda4fb85SAurabindo Pillai UseMALLForStaticScreen, // mode 2120dda4fb85SAurabindo Pillai SurfaceSizeInMALL, 2121c3b3f9baSAlex Deucher st_vars->one_row_per_frame_fits_in_buffer, 2122dda4fb85SAurabindo Pillai /* Output */ 2123dda4fb85SAurabindo Pillai UsesMALLForStaticScreen); // boolen 2124dda4fb85SAurabindo Pillai 2125dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2126dda4fb85SAurabindo Pillai PTE_BUFFER_MODE[k] = myPipe[k].FORCE_ONE_ROW_FOR_FRAME || UsesMALLForStaticScreen[k] || 2127dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport) || 2128dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) || 2129dda4fb85SAurabindo Pillai (GPUVMMinPageSizeKBytes[k] > 64); 2130dda4fb85SAurabindo Pillai BIGK_FRAGMENT_SIZE[k] = dml_log2(GPUVMMinPageSizeKBytes[k] * 1024) - 12; 2131dda4fb85SAurabindo Pillai } 2132dda4fb85SAurabindo Pillai 2133dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2134dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2135dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SurfaceSizeInMALL = %d\n", __func__, k, SurfaceSizeInMALL[k]); 2136dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UsesMALLForStaticScreen = %d\n", __func__, k, UsesMALLForStaticScreen[k]); 2137dda4fb85SAurabindo Pillai #endif 2138dda4fb85SAurabindo Pillai use_one_row_for_frame[k] = myPipe[k].FORCE_ONE_ROW_FOR_FRAME || UsesMALLForStaticScreen[k] || 2139dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport) || 2140dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) || 2141dda4fb85SAurabindo Pillai (GPUVMMinPageSizeKBytes[k] > 64 && IsVertical(myPipe[k].SourceRotation)); 2142dda4fb85SAurabindo Pillai 2143dda4fb85SAurabindo Pillai use_one_row_for_frame_flip[k] = use_one_row_for_frame[k] && 2144dda4fb85SAurabindo Pillai !(UseMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame); 2145dda4fb85SAurabindo Pillai 2146dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) { 2147c3b3f9baSAlex Deucher dpte_row_height_luma[k] = st_vars->dpte_row_height_luma_one_row_per_frame[k]; 2148c3b3f9baSAlex Deucher dpte_row_width_luma_ub[k] = st_vars->dpte_row_width_luma_ub_one_row_per_frame[k]; 2149c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowY[k] = st_vars->PixelPTEBytesPerRowY_one_row_per_frame[k]; 2150c3b3f9baSAlex Deucher dpte_row_height_chroma[k] = st_vars->dpte_row_height_chroma_one_row_per_frame[k]; 2151c3b3f9baSAlex Deucher dpte_row_width_chroma_ub[k] = st_vars->dpte_row_width_chroma_ub_one_row_per_frame[k]; 2152c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC[k] = st_vars->PixelPTEBytesPerRowC_one_row_per_frame[k]; 2153c3b3f9baSAlex Deucher PTEBufferSizeNotExceeded[k] = st_vars->one_row_per_frame_fits_in_buffer[k]; 2154dda4fb85SAurabindo Pillai } 2155dda4fb85SAurabindo Pillai 2156dda4fb85SAurabindo Pillai if (MetaRowByte[k] <= DCCMetaBufferSizeBytes) 2157dda4fb85SAurabindo Pillai DCCMetaBufferSizeNotExceeded[k] = true; 2158dda4fb85SAurabindo Pillai else 2159dda4fb85SAurabindo Pillai DCCMetaBufferSizeNotExceeded[k] = false; 2160dda4fb85SAurabindo Pillai 2161c3b3f9baSAlex Deucher PixelPTEBytesPerRow[k] = st_vars->PixelPTEBytesPerRowY[k] + st_vars->PixelPTEBytesPerRowC[k]; 2162dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) 2163dda4fb85SAurabindo Pillai PixelPTEBytesPerRow[k] = PixelPTEBytesPerRow[k] / 2; 2164dda4fb85SAurabindo Pillai 2165dda4fb85SAurabindo Pillai dml32_CalculateRowBandwidth( 2166dda4fb85SAurabindo Pillai GPUVMEnable, 2167dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat, 2168dda4fb85SAurabindo Pillai myPipe[k].VRatio, 2169dda4fb85SAurabindo Pillai myPipe[k].VRatioChroma, 2170dda4fb85SAurabindo Pillai myPipe[k].DCCEnable, 2171dda4fb85SAurabindo Pillai myPipe[k].HTotal / myPipe[k].PixelClock, 2172c3b3f9baSAlex Deucher st_vars->MetaRowByteY[k], st_vars->MetaRowByteC[k], 2173dda4fb85SAurabindo Pillai meta_row_height[k], 2174dda4fb85SAurabindo Pillai meta_row_height_chroma[k], 2175c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowY[k], 2176c3b3f9baSAlex Deucher st_vars->PixelPTEBytesPerRowC[k], 2177dda4fb85SAurabindo Pillai dpte_row_height_luma[k], 2178dda4fb85SAurabindo Pillai dpte_row_height_chroma[k], 2179dda4fb85SAurabindo Pillai 2180dda4fb85SAurabindo Pillai /* Output */ 2181dda4fb85SAurabindo Pillai &meta_row_bw[k], 2182dda4fb85SAurabindo Pillai &dpte_row_bw[k]); 2183dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2184dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, use_one_row_for_frame = %d\n", __func__, k, use_one_row_for_frame[k]); 2185dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, use_one_row_for_frame_flip = %d\n", 2186dda4fb85SAurabindo Pillai __func__, k, use_one_row_for_frame_flip[k]); 2187dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UseMALLForPStateChange = %d\n", 2188dda4fb85SAurabindo Pillai __func__, k, UseMALLForPStateChange[k]); 2189dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_height_luma = %d\n", __func__, k, dpte_row_height_luma[k]); 2190dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_width_luma_ub = %d\n", 2191dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_luma_ub[k]); 2192c3b3f9baSAlex Deucher dml_print("DML::%s: k=%d, PixelPTEBytesPerRowY = %d\n", __func__, k, st_vars->PixelPTEBytesPerRowY[k]); 2193dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_height_chroma = %d\n", 2194dda4fb85SAurabindo Pillai __func__, k, dpte_row_height_chroma[k]); 2195dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_width_chroma_ub = %d\n", 2196dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_chroma_ub[k]); 2197c3b3f9baSAlex Deucher dml_print("DML::%s: k=%d, PixelPTEBytesPerRowC = %d\n", __func__, k, st_vars->PixelPTEBytesPerRowC[k]); 2198dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PixelPTEBytesPerRow = %d\n", __func__, k, PixelPTEBytesPerRow[k]); 2199dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PTEBufferSizeNotExceeded = %d\n", 2200dda4fb85SAurabindo Pillai __func__, k, PTEBufferSizeNotExceeded[k]); 2201dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PTE_BUFFER_MODE = %d\n", __func__, k, PTE_BUFFER_MODE[k]); 2202dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, BIGK_FRAGMENT_SIZE = %d\n", __func__, k, BIGK_FRAGMENT_SIZE[k]); 2203dda4fb85SAurabindo Pillai #endif 2204dda4fb85SAurabindo Pillai } 2205dda4fb85SAurabindo Pillai } // CalculateVMRowAndSwath 2206dda4fb85SAurabindo Pillai 2207dda4fb85SAurabindo Pillai unsigned int dml32_CalculateVMAndRowBytes( 2208dda4fb85SAurabindo Pillai bool ViewportStationary, 2209dda4fb85SAurabindo Pillai bool DCCEnable, 2210dda4fb85SAurabindo Pillai unsigned int NumberOfDPPs, 2211dda4fb85SAurabindo Pillai unsigned int BlockHeight256Bytes, 2212dda4fb85SAurabindo Pillai unsigned int BlockWidth256Bytes, 2213dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 2214dda4fb85SAurabindo Pillai unsigned int SurfaceTiling, 2215dda4fb85SAurabindo Pillai unsigned int BytePerPixel, 2216dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation, 2217dda4fb85SAurabindo Pillai double SwathWidth, 2218dda4fb85SAurabindo Pillai unsigned int ViewportHeight, 2219dda4fb85SAurabindo Pillai unsigned int ViewportXStart, 2220dda4fb85SAurabindo Pillai unsigned int ViewportYStart, 2221dda4fb85SAurabindo Pillai bool GPUVMEnable, 2222dda4fb85SAurabindo Pillai bool HostVMEnable, 2223dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels, 2224dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels, 2225dda4fb85SAurabindo Pillai unsigned int GPUVMMinPageSizeKBytes, 2226dda4fb85SAurabindo Pillai unsigned int HostVMMinPageSize, 2227dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequests, 2228dda4fb85SAurabindo Pillai unsigned int Pitch, 2229dda4fb85SAurabindo Pillai unsigned int DCCMetaPitch, 2230dda4fb85SAurabindo Pillai unsigned int MacroTileWidth, 2231dda4fb85SAurabindo Pillai unsigned int MacroTileHeight, 2232dda4fb85SAurabindo Pillai 2233dda4fb85SAurabindo Pillai /* Output */ 2234dda4fb85SAurabindo Pillai unsigned int *MetaRowByte, 2235dda4fb85SAurabindo Pillai unsigned int *PixelPTEBytesPerRow, 2236dda4fb85SAurabindo Pillai unsigned int *dpte_row_width_ub, 2237dda4fb85SAurabindo Pillai unsigned int *dpte_row_height, 2238dda4fb85SAurabindo Pillai unsigned int *dpte_row_height_linear, 2239dda4fb85SAurabindo Pillai unsigned int *PixelPTEBytesPerRow_one_row_per_frame, 2240dda4fb85SAurabindo Pillai unsigned int *dpte_row_width_ub_one_row_per_frame, 2241dda4fb85SAurabindo Pillai unsigned int *dpte_row_height_one_row_per_frame, 2242dda4fb85SAurabindo Pillai unsigned int *MetaRequestWidth, 2243dda4fb85SAurabindo Pillai unsigned int *MetaRequestHeight, 2244dda4fb85SAurabindo Pillai unsigned int *meta_row_width, 2245dda4fb85SAurabindo Pillai unsigned int *meta_row_height, 2246dda4fb85SAurabindo Pillai unsigned int *PixelPTEReqWidth, 2247dda4fb85SAurabindo Pillai unsigned int *PixelPTEReqHeight, 2248dda4fb85SAurabindo Pillai unsigned int *PTERequestSize, 2249dda4fb85SAurabindo Pillai unsigned int *DPDE0BytesFrame, 2250dda4fb85SAurabindo Pillai unsigned int *MetaPTEBytesFrame) 2251dda4fb85SAurabindo Pillai { 2252dda4fb85SAurabindo Pillai unsigned int MPDEBytesFrame; 2253dda4fb85SAurabindo Pillai unsigned int DCCMetaSurfaceBytes; 2254dda4fb85SAurabindo Pillai unsigned int ExtraDPDEBytesFrame; 2255dda4fb85SAurabindo Pillai unsigned int PDEAndMetaPTEBytesFrame; 2256dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevels = 0; 2257dda4fb85SAurabindo Pillai unsigned int MacroTileSizeBytes; 2258dda4fb85SAurabindo Pillai unsigned int vp_height_meta_ub; 2259dda4fb85SAurabindo Pillai unsigned int vp_height_dpte_ub; 2260dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidth_linear = 0; // VBA_DELTA. VBA doesn't calculate this 2261dda4fb85SAurabindo Pillai 2262dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) { 2263dda4fb85SAurabindo Pillai if (HostVMMinPageSize < 2048) 2264dda4fb85SAurabindo Pillai HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels; 2265dda4fb85SAurabindo Pillai else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) 2266dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1); 2267dda4fb85SAurabindo Pillai else 2268dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2); 2269dda4fb85SAurabindo Pillai } 2270dda4fb85SAurabindo Pillai 2271dda4fb85SAurabindo Pillai *MetaRequestHeight = 8 * BlockHeight256Bytes; 2272dda4fb85SAurabindo Pillai *MetaRequestWidth = 8 * BlockWidth256Bytes; 2273dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) { 2274dda4fb85SAurabindo Pillai *meta_row_height = 32; 2275dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth) 2276dda4fb85SAurabindo Pillai - dml_floor(ViewportXStart, *MetaRequestWidth); 2277dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) { 2278dda4fb85SAurabindo Pillai *meta_row_height = *MetaRequestHeight; 2279dda4fb85SAurabindo Pillai if (ViewportStationary && NumberOfDPPs == 1) { 2280dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, 2281dda4fb85SAurabindo Pillai *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth); 2282dda4fb85SAurabindo Pillai } else { 2283dda4fb85SAurabindo Pillai *meta_row_width = dml_ceil(SwathWidth - 1, *MetaRequestWidth) + *MetaRequestWidth; 2284dda4fb85SAurabindo Pillai } 2285dda4fb85SAurabindo Pillai *MetaRowByte = *meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0; 2286dda4fb85SAurabindo Pillai } else { 2287dda4fb85SAurabindo Pillai *meta_row_height = *MetaRequestWidth; 2288dda4fb85SAurabindo Pillai if (ViewportStationary && NumberOfDPPs == 1) { 2289dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportYStart + ViewportHeight + *MetaRequestHeight - 1, 2290dda4fb85SAurabindo Pillai *MetaRequestHeight) - dml_floor(ViewportYStart, *MetaRequestHeight); 2291dda4fb85SAurabindo Pillai } else { 2292dda4fb85SAurabindo Pillai *meta_row_width = dml_ceil(SwathWidth - 1, *MetaRequestHeight) + *MetaRequestHeight; 2293dda4fb85SAurabindo Pillai } 2294dda4fb85SAurabindo Pillai *MetaRowByte = *meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0; 2295dda4fb85SAurabindo Pillai } 2296dda4fb85SAurabindo Pillai 2297dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1 || !IsVertical(SourceRotation))) { 2298dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_floor(ViewportYStart + ViewportHeight + 64 * BlockHeight256Bytes - 1, 2299dda4fb85SAurabindo Pillai 64 * BlockHeight256Bytes) - dml_floor(ViewportYStart, 64 * BlockHeight256Bytes); 2300dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) { 2301dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes; 2302dda4fb85SAurabindo Pillai } else { 2303dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_ceil(SwathWidth - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes; 2304dda4fb85SAurabindo Pillai } 2305dda4fb85SAurabindo Pillai 2306dda4fb85SAurabindo Pillai DCCMetaSurfaceBytes = DCCMetaPitch * vp_height_meta_ub * BytePerPixel / 256.0; 2307dda4fb85SAurabindo Pillai 2308dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 2309dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = (dml_ceil((double) (DCCMetaSurfaceBytes - 4.0 * 1024.0) / 2310dda4fb85SAurabindo Pillai (8 * 4.0 * 1024), 1) + 1) * 64; 2311dda4fb85SAurabindo Pillai MPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 1); 2312dda4fb85SAurabindo Pillai } else { 2313dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = 0; 2314dda4fb85SAurabindo Pillai MPDEBytesFrame = 0; 2315dda4fb85SAurabindo Pillai } 2316dda4fb85SAurabindo Pillai 2317dda4fb85SAurabindo Pillai if (DCCEnable != true) { 2318dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = 0; 2319dda4fb85SAurabindo Pillai MPDEBytesFrame = 0; 2320dda4fb85SAurabindo Pillai *MetaRowByte = 0; 2321dda4fb85SAurabindo Pillai } 2322dda4fb85SAurabindo Pillai 2323dda4fb85SAurabindo Pillai MacroTileSizeBytes = MacroTileWidth * BytePerPixel * MacroTileHeight; 2324dda4fb85SAurabindo Pillai 2325dda4fb85SAurabindo Pillai if (GPUVMEnable == true && GPUVMMaxPageTableLevels > 1) { 2326dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1 || !IsVertical(SourceRotation))) { 2327dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_floor(ViewportYStart + ViewportHeight + 2328dda4fb85SAurabindo Pillai MacroTileHeight - 1, MacroTileHeight) - 2329dda4fb85SAurabindo Pillai dml_floor(ViewportYStart, MacroTileHeight); 2330dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) { 2331dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight; 2332dda4fb85SAurabindo Pillai } else { 2333dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_ceil(SwathWidth - 1, MacroTileHeight) + MacroTileHeight; 2334dda4fb85SAurabindo Pillai } 2335dda4fb85SAurabindo Pillai *DPDE0BytesFrame = 64 * (dml_ceil((Pitch * vp_height_dpte_ub * BytePerPixel - MacroTileSizeBytes) / 2336dda4fb85SAurabindo Pillai (8 * 2097152), 1) + 1); 2337dda4fb85SAurabindo Pillai ExtraDPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 2); 2338dda4fb85SAurabindo Pillai } else { 2339dda4fb85SAurabindo Pillai *DPDE0BytesFrame = 0; 2340dda4fb85SAurabindo Pillai ExtraDPDEBytesFrame = 0; 2341dda4fb85SAurabindo Pillai vp_height_dpte_ub = 0; 2342dda4fb85SAurabindo Pillai } 2343dda4fb85SAurabindo Pillai 2344dda4fb85SAurabindo Pillai PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame + ExtraDPDEBytesFrame; 2345dda4fb85SAurabindo Pillai 2346dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2347dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, DCCEnable); 2348dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable); 2349dda4fb85SAurabindo Pillai dml_print("DML::%s: SwModeLinear = %d\n", __func__, SurfaceTiling == dm_sw_linear); 2350dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixel = %d\n", __func__, BytePerPixel); 2351dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMaxPageTableLevels = %d\n", __func__, GPUVMMaxPageTableLevels); 2352dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256Bytes = %d\n", __func__, BlockHeight256Bytes); 2353dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256Bytes = %d\n", __func__, BlockWidth256Bytes); 2354dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeight = %d\n", __func__, MacroTileHeight); 2355dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidth = %d\n", __func__, MacroTileWidth); 2356dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaPTEBytesFrame = %d\n", __func__, *MetaPTEBytesFrame); 2357dda4fb85SAurabindo Pillai dml_print("DML::%s: MPDEBytesFrame = %d\n", __func__, MPDEBytesFrame); 2358dda4fb85SAurabindo Pillai dml_print("DML::%s: DPDE0BytesFrame = %d\n", __func__, *DPDE0BytesFrame); 2359dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraDPDEBytesFrame= %d\n", __func__, ExtraDPDEBytesFrame); 2360dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame); 2361dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportHeight = %d\n", __func__, ViewportHeight); 2362dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathWidth = %d\n", __func__, SwathWidth); 2363dda4fb85SAurabindo Pillai dml_print("DML::%s: vp_height_dpte_ub = %d\n", __func__, vp_height_dpte_ub); 2364dda4fb85SAurabindo Pillai #endif 2365dda4fb85SAurabindo Pillai 2366dda4fb85SAurabindo Pillai if (HostVMEnable == true) 2367dda4fb85SAurabindo Pillai PDEAndMetaPTEBytesFrame = PDEAndMetaPTEBytesFrame * (1 + 8 * HostVMDynamicLevels); 2368dda4fb85SAurabindo Pillai 2369dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) { 2370dda4fb85SAurabindo Pillai *PixelPTEReqHeight = 1; 2371dda4fb85SAurabindo Pillai *PixelPTEReqWidth = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel; 2372dda4fb85SAurabindo Pillai PixelPTEReqWidth_linear = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel; 2373dda4fb85SAurabindo Pillai *PTERequestSize = 64; 2374dda4fb85SAurabindo Pillai } else if (GPUVMMinPageSizeKBytes == 4) { 2375dda4fb85SAurabindo Pillai *PixelPTEReqHeight = 16 * BlockHeight256Bytes; 2376dda4fb85SAurabindo Pillai *PixelPTEReqWidth = 16 * BlockWidth256Bytes; 2377dda4fb85SAurabindo Pillai *PTERequestSize = 128; 2378dda4fb85SAurabindo Pillai } else { 2379dda4fb85SAurabindo Pillai *PixelPTEReqHeight = MacroTileHeight; 2380dda4fb85SAurabindo Pillai *PixelPTEReqWidth = 8 * 1024 * GPUVMMinPageSizeKBytes / (MacroTileHeight * BytePerPixel); 2381dda4fb85SAurabindo Pillai *PTERequestSize = 64; 2382dda4fb85SAurabindo Pillai } 2383dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2384dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMinPageSizeKBytes = %d\n", __func__, GPUVMMinPageSizeKBytes); 2385dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d (after HostVM factor)\n", __func__, PDEAndMetaPTEBytesFrame); 2386dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqHeight = %d\n", __func__, *PixelPTEReqHeight); 2387dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqWidth = %d\n", __func__, *PixelPTEReqWidth); 2388dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqWidth_linear = %d\n", __func__, PixelPTEReqWidth_linear); 2389dda4fb85SAurabindo Pillai dml_print("DML::%s: PTERequestSize = %d\n", __func__, *PTERequestSize); 2390dda4fb85SAurabindo Pillai dml_print("DML::%s: Pitch = %d\n", __func__, Pitch); 2391dda4fb85SAurabindo Pillai #endif 2392dda4fb85SAurabindo Pillai 2393dda4fb85SAurabindo Pillai *dpte_row_height_one_row_per_frame = vp_height_dpte_ub; 2394dda4fb85SAurabindo Pillai *dpte_row_width_ub_one_row_per_frame = (dml_ceil(((double)Pitch * (double)*dpte_row_height_one_row_per_frame / 2395dda4fb85SAurabindo Pillai (double) *PixelPTEReqHeight - 1) / (double) *PixelPTEReqWidth, 1) + 1) * 2396dda4fb85SAurabindo Pillai (double) *PixelPTEReqWidth; 2397dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow_one_row_per_frame = *dpte_row_width_ub_one_row_per_frame / *PixelPTEReqWidth * 2398dda4fb85SAurabindo Pillai *PTERequestSize; 2399dda4fb85SAurabindo Pillai 2400dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) { 2401dda4fb85SAurabindo Pillai *dpte_row_height = dml_min(128, 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests * 2402dda4fb85SAurabindo Pillai *PixelPTEReqWidth / Pitch), 1)); 2403dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2404dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d (1)\n", __func__, 2405dda4fb85SAurabindo Pillai PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch); 2406dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %f (2)\n", __func__, 2407dda4fb85SAurabindo Pillai dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch)); 2408dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %f (3)\n", __func__, 2409dda4fb85SAurabindo Pillai dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1)); 2410dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d (4)\n", __func__, 2411dda4fb85SAurabindo Pillai 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests * 2412dda4fb85SAurabindo Pillai *PixelPTEReqWidth / Pitch), 1)); 2413dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d\n", __func__, *dpte_row_height); 2414dda4fb85SAurabindo Pillai #endif 2415dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_ceil(((double) Pitch * (double) *dpte_row_height - 1), 2416dda4fb85SAurabindo Pillai (double) *PixelPTEReqWidth) + *PixelPTEReqWidth; 2417dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / (double)*PixelPTEReqWidth * (double)*PTERequestSize; 2418dda4fb85SAurabindo Pillai 2419dda4fb85SAurabindo Pillai // VBA_DELTA, VBA doesn't have programming value for pte row height linear. 2420dda4fb85SAurabindo Pillai *dpte_row_height_linear = 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests * 2421dda4fb85SAurabindo Pillai PixelPTEReqWidth_linear / Pitch), 1); 2422dda4fb85SAurabindo Pillai if (*dpte_row_height_linear > 128) 2423dda4fb85SAurabindo Pillai *dpte_row_height_linear = 128; 2424dda4fb85SAurabindo Pillai 2425dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) { 2426dda4fb85SAurabindo Pillai *dpte_row_height = *PixelPTEReqHeight; 2427dda4fb85SAurabindo Pillai 2428dda4fb85SAurabindo Pillai if (GPUVMMinPageSizeKBytes > 64) { 2429dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((Pitch * *dpte_row_height / *PixelPTEReqHeight - 1) / 2430dda4fb85SAurabindo Pillai *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth; 2431dda4fb85SAurabindo Pillai } else if (ViewportStationary && (NumberOfDPPs == 1)) { 2432dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_floor(ViewportXStart + SwathWidth + 2433dda4fb85SAurabindo Pillai *PixelPTEReqWidth - 1, *PixelPTEReqWidth) - 2434dda4fb85SAurabindo Pillai dml_floor(ViewportXStart, *PixelPTEReqWidth); 2435dda4fb85SAurabindo Pillai } else { 2436dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) * 2437dda4fb85SAurabindo Pillai *PixelPTEReqWidth; 2438dda4fb85SAurabindo Pillai } 2439dda4fb85SAurabindo Pillai 2440dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize; 2441dda4fb85SAurabindo Pillai } else { 2442dda4fb85SAurabindo Pillai *dpte_row_height = dml_min(*PixelPTEReqWidth, MacroTileWidth); 2443dda4fb85SAurabindo Pillai 2444dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1)) { 2445dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_floor(ViewportYStart + ViewportHeight + *PixelPTEReqHeight - 1, 2446dda4fb85SAurabindo Pillai *PixelPTEReqHeight) - dml_floor(ViewportYStart, *PixelPTEReqHeight); 2447dda4fb85SAurabindo Pillai } else { 2448dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((SwathWidth - 1) / *PixelPTEReqHeight, 1) + 1) 2449dda4fb85SAurabindo Pillai * *PixelPTEReqHeight; 2450dda4fb85SAurabindo Pillai } 2451dda4fb85SAurabindo Pillai 2452dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqHeight * *PTERequestSize; 2453dda4fb85SAurabindo Pillai } 2454dda4fb85SAurabindo Pillai 2455dda4fb85SAurabindo Pillai if (GPUVMEnable != true) 2456dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = 0; 2457dda4fb85SAurabindo Pillai if (HostVMEnable == true) 2458dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *PixelPTEBytesPerRow * (1 + 8 * HostVMDynamicLevels); 2459dda4fb85SAurabindo Pillai 2460dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2461dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMinPageSizeKBytes = %d\n", __func__, GPUVMMinPageSizeKBytes); 2462dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d\n", __func__, *dpte_row_height); 2463dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height_linear = %d\n", __func__, *dpte_row_height_linear); 2464dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_width_ub = %d\n", __func__, *dpte_row_width_ub); 2465dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, *PixelPTEBytesPerRow); 2466dda4fb85SAurabindo Pillai dml_print("DML::%s: PTEBufferSizeInRequests = %d\n", __func__, PTEBufferSizeInRequests); 2467dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height_one_row_per_frame = %d\n", __func__, *dpte_row_height_one_row_per_frame); 2468dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_width_ub_one_row_per_frame = %d\n", 2469dda4fb85SAurabindo Pillai __func__, *dpte_row_width_ub_one_row_per_frame); 2470dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow_one_row_per_frame = %d\n", 2471dda4fb85SAurabindo Pillai __func__, *PixelPTEBytesPerRow_one_row_per_frame); 2472dda4fb85SAurabindo Pillai dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n", 2473dda4fb85SAurabindo Pillai *MetaPTEBytesFrame); 2474dda4fb85SAurabindo Pillai #endif 2475dda4fb85SAurabindo Pillai 2476dda4fb85SAurabindo Pillai return PDEAndMetaPTEBytesFrame; 2477dda4fb85SAurabindo Pillai } // CalculateVMAndRowBytes 2478dda4fb85SAurabindo Pillai 2479dda4fb85SAurabindo Pillai double dml32_CalculatePrefetchSourceLines( 2480dda4fb85SAurabindo Pillai double VRatio, 2481dda4fb85SAurabindo Pillai unsigned int VTaps, 2482dda4fb85SAurabindo Pillai bool Interlace, 2483dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP, 2484dda4fb85SAurabindo Pillai unsigned int SwathHeight, 2485dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation, 2486dda4fb85SAurabindo Pillai bool ViewportStationary, 2487dda4fb85SAurabindo Pillai double SwathWidth, 2488dda4fb85SAurabindo Pillai unsigned int ViewportHeight, 2489dda4fb85SAurabindo Pillai unsigned int ViewportXStart, 2490dda4fb85SAurabindo Pillai unsigned int ViewportYStart, 2491dda4fb85SAurabindo Pillai 2492dda4fb85SAurabindo Pillai /* Output */ 2493dda4fb85SAurabindo Pillai double *VInitPreFill, 2494dda4fb85SAurabindo Pillai unsigned int *MaxNumSwath) 2495dda4fb85SAurabindo Pillai { 2496dda4fb85SAurabindo Pillai 2497dda4fb85SAurabindo Pillai unsigned int vp_start_rot; 2498dda4fb85SAurabindo Pillai unsigned int sw0_tmp; 2499dda4fb85SAurabindo Pillai unsigned int MaxPartialSwath; 2500dda4fb85SAurabindo Pillai double numLines; 2501dda4fb85SAurabindo Pillai 2502dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2503dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatio = %f\n", __func__, VRatio); 2504dda4fb85SAurabindo Pillai dml_print("DML::%s: VTaps = %d\n", __func__, VTaps); 2505dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportXStart = %d\n", __func__, ViewportXStart); 2506dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportYStart = %d\n", __func__, ViewportYStart); 2507dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportStationary = %d\n", __func__, ViewportStationary); 2508dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeight = %d\n", __func__, SwathHeight); 2509dda4fb85SAurabindo Pillai #endif 2510dda4fb85SAurabindo Pillai if (ProgressiveToInterlaceUnitInOPP) 2511dda4fb85SAurabindo Pillai *VInitPreFill = dml_floor((VRatio + (double) VTaps + 1) / 2.0, 1); 2512dda4fb85SAurabindo Pillai else 2513dda4fb85SAurabindo Pillai *VInitPreFill = dml_floor((VRatio + (double) VTaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1); 2514dda4fb85SAurabindo Pillai 2515dda4fb85SAurabindo Pillai if (ViewportStationary) { 2516dda4fb85SAurabindo Pillai if (SourceRotation == dm_rotation_180 || SourceRotation == dm_rotation_180m) { 2517dda4fb85SAurabindo Pillai vp_start_rot = SwathHeight - 2518dda4fb85SAurabindo Pillai (((unsigned int) (ViewportYStart + ViewportHeight - 1) % SwathHeight) + 1); 2519dda4fb85SAurabindo Pillai } else if (SourceRotation == dm_rotation_270 || SourceRotation == dm_rotation_90m) { 2520dda4fb85SAurabindo Pillai vp_start_rot = ViewportXStart; 2521dda4fb85SAurabindo Pillai } else if (SourceRotation == dm_rotation_90 || SourceRotation == dm_rotation_270m) { 2522dda4fb85SAurabindo Pillai vp_start_rot = SwathHeight - 2523dda4fb85SAurabindo Pillai (((unsigned int)(ViewportYStart + SwathWidth - 1) % SwathHeight) + 1); 2524dda4fb85SAurabindo Pillai } else { 2525dda4fb85SAurabindo Pillai vp_start_rot = ViewportYStart; 2526dda4fb85SAurabindo Pillai } 2527dda4fb85SAurabindo Pillai sw0_tmp = SwathHeight - (vp_start_rot % SwathHeight); 2528dda4fb85SAurabindo Pillai if (sw0_tmp < *VInitPreFill) 2529dda4fb85SAurabindo Pillai *MaxNumSwath = dml_ceil((*VInitPreFill - sw0_tmp) / SwathHeight, 1) + 1; 2530dda4fb85SAurabindo Pillai else 2531dda4fb85SAurabindo Pillai *MaxNumSwath = 1; 2532dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (vp_start_rot + *VInitPreFill - 1) % SwathHeight); 2533dda4fb85SAurabindo Pillai } else { 2534dda4fb85SAurabindo Pillai *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1; 2535dda4fb85SAurabindo Pillai if (*VInitPreFill > 1) 2536dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (*VInitPreFill - 2) % SwathHeight); 2537dda4fb85SAurabindo Pillai else 2538dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (*VInitPreFill + SwathHeight - 2) % SwathHeight); 2539dda4fb85SAurabindo Pillai } 2540dda4fb85SAurabindo Pillai numLines = *MaxNumSwath * SwathHeight + MaxPartialSwath; 2541dda4fb85SAurabindo Pillai 2542dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2543dda4fb85SAurabindo Pillai dml_print("DML::%s: vp_start_rot = %d\n", __func__, vp_start_rot); 2544dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFill = %d\n", __func__, *VInitPreFill); 2545dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxPartialSwath = %d\n", __func__, MaxPartialSwath); 2546dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwath = %d\n", __func__, *MaxNumSwath); 2547dda4fb85SAurabindo Pillai dml_print("DML::%s: Prefetch source lines = %3.2f\n", __func__, numLines); 2548dda4fb85SAurabindo Pillai #endif 2549dda4fb85SAurabindo Pillai return numLines; 2550dda4fb85SAurabindo Pillai 2551dda4fb85SAurabindo Pillai } // CalculatePrefetchSourceLines 2552dda4fb85SAurabindo Pillai 2553dda4fb85SAurabindo Pillai void dml32_CalculateMALLUseForStaticScreen( 2554dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 2555dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCNFinal, 2556dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode *UseMALLForStaticScreen, 2557dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[], 2558dda4fb85SAurabindo Pillai bool one_row_per_frame_fits_in_buffer[], 2559dda4fb85SAurabindo Pillai 2560dda4fb85SAurabindo Pillai /* output */ 2561dda4fb85SAurabindo Pillai bool UsesMALLForStaticScreen[]) 2562dda4fb85SAurabindo Pillai { 2563dda4fb85SAurabindo Pillai unsigned int k; 2564dda4fb85SAurabindo Pillai unsigned int SurfaceToAddToMALL; 2565dda4fb85SAurabindo Pillai bool CanAddAnotherSurfaceToMALL; 2566dda4fb85SAurabindo Pillai unsigned int TotalSurfaceSizeInMALL; 2567dda4fb85SAurabindo Pillai 2568dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = 0; 2569dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2570dda4fb85SAurabindo Pillai UsesMALLForStaticScreen[k] = (UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable); 2571dda4fb85SAurabindo Pillai if (UsesMALLForStaticScreen[k]) 2572dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k]; 2573dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2574dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UsesMALLForStaticScreen = %d\n", __func__, k, UsesMALLForStaticScreen[k]); 2575dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, TotalSurfaceSizeInMALL = %d\n", __func__, k, TotalSurfaceSizeInMALL); 2576dda4fb85SAurabindo Pillai #endif 2577dda4fb85SAurabindo Pillai } 2578dda4fb85SAurabindo Pillai 2579dda4fb85SAurabindo Pillai SurfaceToAddToMALL = 0; 2580dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = true; 2581dda4fb85SAurabindo Pillai while (CanAddAnotherSurfaceToMALL) { 2582dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = false; 2583dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2584dda4fb85SAurabindo Pillai if (TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k] <= MALLAllocatedForDCNFinal * 1024 * 1024 && 2585dda4fb85SAurabindo Pillai !UsesMALLForStaticScreen[k] && 2586dda4fb85SAurabindo Pillai UseMALLForStaticScreen[k] != dm_use_mall_static_screen_disable && 2587dda4fb85SAurabindo Pillai one_row_per_frame_fits_in_buffer[k] && 2588dda4fb85SAurabindo Pillai (!CanAddAnotherSurfaceToMALL || 2589dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] < SurfaceSizeInMALL[SurfaceToAddToMALL])) { 2590dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = true; 2591dda4fb85SAurabindo Pillai SurfaceToAddToMALL = k; 2592dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2593dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UseMALLForStaticScreen = %d (dis, en, optimize)\n", 2594dda4fb85SAurabindo Pillai __func__, k, UseMALLForStaticScreen[k]); 2595dda4fb85SAurabindo Pillai #endif 2596dda4fb85SAurabindo Pillai } 2597dda4fb85SAurabindo Pillai } 2598dda4fb85SAurabindo Pillai if (CanAddAnotherSurfaceToMALL) { 2599dda4fb85SAurabindo Pillai UsesMALLForStaticScreen[SurfaceToAddToMALL] = true; 2600dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[SurfaceToAddToMALL]; 2601dda4fb85SAurabindo Pillai 2602dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2603dda4fb85SAurabindo Pillai dml_print("DML::%s: SurfaceToAddToMALL = %d\n", __func__, SurfaceToAddToMALL); 2604dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalSurfaceSizeInMALL = %d\n", __func__, TotalSurfaceSizeInMALL); 2605dda4fb85SAurabindo Pillai #endif 2606dda4fb85SAurabindo Pillai 2607dda4fb85SAurabindo Pillai } 2608dda4fb85SAurabindo Pillai } 2609dda4fb85SAurabindo Pillai } 2610dda4fb85SAurabindo Pillai 2611dda4fb85SAurabindo Pillai void dml32_CalculateRowBandwidth( 2612dda4fb85SAurabindo Pillai bool GPUVMEnable, 2613dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 2614dda4fb85SAurabindo Pillai double VRatio, 2615dda4fb85SAurabindo Pillai double VRatioChroma, 2616dda4fb85SAurabindo Pillai bool DCCEnable, 2617dda4fb85SAurabindo Pillai double LineTime, 2618dda4fb85SAurabindo Pillai unsigned int MetaRowByteLuma, 2619dda4fb85SAurabindo Pillai unsigned int MetaRowByteChroma, 2620dda4fb85SAurabindo Pillai unsigned int meta_row_height_luma, 2621dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma, 2622dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRowLuma, 2623dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRowChroma, 2624dda4fb85SAurabindo Pillai unsigned int dpte_row_height_luma, 2625dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma, 2626dda4fb85SAurabindo Pillai /* Output */ 2627dda4fb85SAurabindo Pillai double *meta_row_bw, 2628dda4fb85SAurabindo Pillai double *dpte_row_bw) 2629dda4fb85SAurabindo Pillai { 2630dda4fb85SAurabindo Pillai if (DCCEnable != true) { 2631dda4fb85SAurabindo Pillai *meta_row_bw = 0; 2632dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || 2633dda4fb85SAurabindo Pillai SourcePixelFormat == dm_rgbe_alpha) { 2634dda4fb85SAurabindo Pillai *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime) + VRatioChroma * 2635dda4fb85SAurabindo Pillai MetaRowByteChroma / (meta_row_height_chroma * LineTime); 2636dda4fb85SAurabindo Pillai } else { 2637dda4fb85SAurabindo Pillai *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime); 2638dda4fb85SAurabindo Pillai } 2639dda4fb85SAurabindo Pillai 2640dda4fb85SAurabindo Pillai if (GPUVMEnable != true) { 2641dda4fb85SAurabindo Pillai *dpte_row_bw = 0; 2642dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 || 2643dda4fb85SAurabindo Pillai SourcePixelFormat == dm_rgbe_alpha) { 2644dda4fb85SAurabindo Pillai *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime) + 2645dda4fb85SAurabindo Pillai VRatioChroma * PixelPTEBytesPerRowChroma / (dpte_row_height_chroma * LineTime); 2646dda4fb85SAurabindo Pillai } else { 2647dda4fb85SAurabindo Pillai *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime); 2648dda4fb85SAurabindo Pillai } 2649dda4fb85SAurabindo Pillai } 2650dda4fb85SAurabindo Pillai 2651dda4fb85SAurabindo Pillai double dml32_CalculateUrgentLatency( 2652dda4fb85SAurabindo Pillai double UrgentLatencyPixelDataOnly, 2653dda4fb85SAurabindo Pillai double UrgentLatencyPixelMixedWithVMData, 2654dda4fb85SAurabindo Pillai double UrgentLatencyVMDataOnly, 2655dda4fb85SAurabindo Pillai bool DoUrgentLatencyAdjustment, 2656dda4fb85SAurabindo Pillai double UrgentLatencyAdjustmentFabricClockComponent, 2657dda4fb85SAurabindo Pillai double UrgentLatencyAdjustmentFabricClockReference, 2658dda4fb85SAurabindo Pillai double FabricClock) 2659dda4fb85SAurabindo Pillai { 2660dda4fb85SAurabindo Pillai double ret; 2661dda4fb85SAurabindo Pillai 2662dda4fb85SAurabindo Pillai ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly); 2663dda4fb85SAurabindo Pillai if (DoUrgentLatencyAdjustment == true) { 2664dda4fb85SAurabindo Pillai ret = ret + UrgentLatencyAdjustmentFabricClockComponent * 2665dda4fb85SAurabindo Pillai (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1); 2666dda4fb85SAurabindo Pillai } 2667dda4fb85SAurabindo Pillai return ret; 2668dda4fb85SAurabindo Pillai } 2669dda4fb85SAurabindo Pillai 2670dda4fb85SAurabindo Pillai void dml32_CalculateUrgentBurstFactor( 2671dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange, 2672dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub, 2673dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub, 2674dda4fb85SAurabindo Pillai unsigned int SwathHeightY, 2675dda4fb85SAurabindo Pillai unsigned int SwathHeightC, 2676dda4fb85SAurabindo Pillai double LineTime, 2677dda4fb85SAurabindo Pillai double UrgentLatency, 2678dda4fb85SAurabindo Pillai double CursorBufferSize, 2679dda4fb85SAurabindo Pillai unsigned int CursorWidth, 2680dda4fb85SAurabindo Pillai unsigned int CursorBPP, 2681dda4fb85SAurabindo Pillai double VRatio, 2682dda4fb85SAurabindo Pillai double VRatioC, 2683dda4fb85SAurabindo Pillai double BytePerPixelInDETY, 2684dda4fb85SAurabindo Pillai double BytePerPixelInDETC, 2685dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY, 2686dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC, 2687dda4fb85SAurabindo Pillai /* Output */ 2688dda4fb85SAurabindo Pillai double *UrgentBurstFactorCursor, 2689dda4fb85SAurabindo Pillai double *UrgentBurstFactorLuma, 2690dda4fb85SAurabindo Pillai double *UrgentBurstFactorChroma, 2691dda4fb85SAurabindo Pillai bool *NotEnoughUrgentLatencyHiding) 2692dda4fb85SAurabindo Pillai { 2693dda4fb85SAurabindo Pillai double LinesInDETLuma; 2694dda4fb85SAurabindo Pillai double LinesInDETChroma; 2695dda4fb85SAurabindo Pillai unsigned int LinesInCursorBuffer; 2696dda4fb85SAurabindo Pillai double CursorBufferSizeInTime; 2697dda4fb85SAurabindo Pillai double DETBufferSizeInTimeLuma; 2698dda4fb85SAurabindo Pillai double DETBufferSizeInTimeChroma; 2699dda4fb85SAurabindo Pillai 2700dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 0; 2701dda4fb85SAurabindo Pillai 2702dda4fb85SAurabindo Pillai if (CursorWidth > 0) { 2703dda4fb85SAurabindo Pillai LinesInCursorBuffer = 1 << (unsigned int) dml_floor(dml_log2(CursorBufferSize * 1024.0 / 2704dda4fb85SAurabindo Pillai (CursorWidth * CursorBPP / 8.0)), 1.0); 2705dda4fb85SAurabindo Pillai if (VRatio > 0) { 2706dda4fb85SAurabindo Pillai CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio; 2707dda4fb85SAurabindo Pillai if (CursorBufferSizeInTime - UrgentLatency <= 0) { 2708dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1; 2709dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = 0; 2710dda4fb85SAurabindo Pillai } else { 2711dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = CursorBufferSizeInTime / 2712dda4fb85SAurabindo Pillai (CursorBufferSizeInTime - UrgentLatency); 2713dda4fb85SAurabindo Pillai } 2714dda4fb85SAurabindo Pillai } else { 2715dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = 1; 2716dda4fb85SAurabindo Pillai } 2717dda4fb85SAurabindo Pillai } 2718dda4fb85SAurabindo Pillai 2719dda4fb85SAurabindo Pillai LinesInDETLuma = (UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe ? 1024*1024 : 2720dda4fb85SAurabindo Pillai DETBufferSizeY) / BytePerPixelInDETY / swath_width_luma_ub; 2721dda4fb85SAurabindo Pillai 2722dda4fb85SAurabindo Pillai if (VRatio > 0) { 2723dda4fb85SAurabindo Pillai DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio; 2724dda4fb85SAurabindo Pillai if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) { 2725dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1; 2726dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = 0; 2727dda4fb85SAurabindo Pillai } else { 2728dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency); 2729dda4fb85SAurabindo Pillai } 2730dda4fb85SAurabindo Pillai } else { 2731dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = 1; 2732dda4fb85SAurabindo Pillai } 2733dda4fb85SAurabindo Pillai 2734dda4fb85SAurabindo Pillai if (BytePerPixelInDETC > 0) { 2735dda4fb85SAurabindo Pillai LinesInDETChroma = (UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe ? 2736dda4fb85SAurabindo Pillai 1024 * 1024 : DETBufferSizeC) / BytePerPixelInDETC 2737dda4fb85SAurabindo Pillai / swath_width_chroma_ub; 2738dda4fb85SAurabindo Pillai 2739dda4fb85SAurabindo Pillai if (VRatio > 0) { 2740dda4fb85SAurabindo Pillai DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatio; 2741dda4fb85SAurabindo Pillai if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) { 2742dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1; 2743dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = 0; 2744dda4fb85SAurabindo Pillai } else { 2745dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = DETBufferSizeInTimeChroma 2746dda4fb85SAurabindo Pillai / (DETBufferSizeInTimeChroma - UrgentLatency); 2747dda4fb85SAurabindo Pillai } 2748dda4fb85SAurabindo Pillai } else { 2749dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = 1; 2750dda4fb85SAurabindo Pillai } 2751dda4fb85SAurabindo Pillai } 2752dda4fb85SAurabindo Pillai } // CalculateUrgentBurstFactor 2753dda4fb85SAurabindo Pillai 2754dda4fb85SAurabindo Pillai void dml32_CalculateDCFCLKDeepSleep( 2755dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 2756dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[], 2757dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[], 2758dda4fb85SAurabindo Pillai double VRatio[], 2759dda4fb85SAurabindo Pillai double VRatioChroma[], 2760dda4fb85SAurabindo Pillai double SwathWidthY[], 2761dda4fb85SAurabindo Pillai double SwathWidthC[], 2762dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 2763dda4fb85SAurabindo Pillai double HRatio[], 2764dda4fb85SAurabindo Pillai double HRatioChroma[], 2765dda4fb85SAurabindo Pillai double PixelClock[], 2766dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT[], 2767dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT_CHROMA[], 2768dda4fb85SAurabindo Pillai double Dppclk[], 2769dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 2770dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 2771dda4fb85SAurabindo Pillai unsigned int ReturnBusWidth, 2772dda4fb85SAurabindo Pillai 2773dda4fb85SAurabindo Pillai /* Output */ 2774dda4fb85SAurabindo Pillai double *DCFClkDeepSleep) 2775dda4fb85SAurabindo Pillai { 2776dda4fb85SAurabindo Pillai unsigned int k; 2777dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLuma; 2778dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChroma; 2779dda4fb85SAurabindo Pillai double DCFClkDeepSleepPerSurface[DC__NUM_DPP__MAX]; 2780dda4fb85SAurabindo Pillai double ReadBandwidth = 0.0; 2781dda4fb85SAurabindo Pillai 2782dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2783dda4fb85SAurabindo Pillai 2784dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) { 2785dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerSurface[k] / HRatio[k] 2786dda4fb85SAurabindo Pillai / PixelClock[k]; 2787dda4fb85SAurabindo Pillai } else { 2788dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / Dppclk[k]; 2789dda4fb85SAurabindo Pillai } 2790dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 2791dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = 0; 2792dda4fb85SAurabindo Pillai } else { 2793dda4fb85SAurabindo Pillai if (VRatioChroma[k] <= 1) { 2794dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] * 2795dda4fb85SAurabindo Pillai DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k]; 2796dda4fb85SAurabindo Pillai } else { 2797dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k] 2798dda4fb85SAurabindo Pillai / Dppclk[k]; 2799dda4fb85SAurabindo Pillai } 2800dda4fb85SAurabindo Pillai } 2801dda4fb85SAurabindo Pillai 2802dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 2803dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = dml_max(__DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * 2804dda4fb85SAurabindo Pillai BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma, 2805dda4fb85SAurabindo Pillai __DML_MIN_DCFCLK_FACTOR__ * SwathWidthC[k] * BytePerPixelC[k] / 2806dda4fb85SAurabindo Pillai 32.0 / DisplayPipeLineDeliveryTimeChroma); 2807dda4fb85SAurabindo Pillai } else { 2808dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = __DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] / 2809dda4fb85SAurabindo Pillai 64.0 / DisplayPipeLineDeliveryTimeLuma; 2810dda4fb85SAurabindo Pillai } 2811dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = dml_max(DCFClkDeepSleepPerSurface[k], PixelClock[k] / 16); 2812dda4fb85SAurabindo Pillai 2813dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2814dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PixelClock = %f\n", __func__, k, PixelClock[k]); 2815dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, DCFClkDeepSleepPerSurface = %f\n", __func__, k, DCFClkDeepSleepPerSurface[k]); 2816dda4fb85SAurabindo Pillai #endif 2817dda4fb85SAurabindo Pillai } 2818dda4fb85SAurabindo Pillai 2819dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) 2820dda4fb85SAurabindo Pillai ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k]; 2821dda4fb85SAurabindo Pillai 2822dda4fb85SAurabindo Pillai *DCFClkDeepSleep = dml_max(8.0, __DML_MIN_DCFCLK_FACTOR__ * ReadBandwidth / (double) ReturnBusWidth); 2823dda4fb85SAurabindo Pillai 2824dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2825dda4fb85SAurabindo Pillai dml_print("DML::%s: __DML_MIN_DCFCLK_FACTOR__ = %f\n", __func__, __DML_MIN_DCFCLK_FACTOR__); 2826dda4fb85SAurabindo Pillai dml_print("DML::%s: ReadBandwidth = %f\n", __func__, ReadBandwidth); 2827dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBusWidth = %d\n", __func__, ReturnBusWidth); 2828dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, *DCFClkDeepSleep); 2829dda4fb85SAurabindo Pillai #endif 2830dda4fb85SAurabindo Pillai 2831dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) 2832dda4fb85SAurabindo Pillai *DCFClkDeepSleep = dml_max(*DCFClkDeepSleep, DCFClkDeepSleepPerSurface[k]); 2833dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 2834dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFClkDeepSleep = %f (final)\n", __func__, *DCFClkDeepSleep); 2835dda4fb85SAurabindo Pillai #endif 2836dda4fb85SAurabindo Pillai } // CalculateDCFCLKDeepSleep 2837dda4fb85SAurabindo Pillai 2838dda4fb85SAurabindo Pillai double dml32_CalculateWriteBackDelay( 2839dda4fb85SAurabindo Pillai enum source_format_class WritebackPixelFormat, 2840dda4fb85SAurabindo Pillai double WritebackHRatio, 2841dda4fb85SAurabindo Pillai double WritebackVRatio, 2842dda4fb85SAurabindo Pillai unsigned int WritebackVTaps, 2843dda4fb85SAurabindo Pillai unsigned int WritebackDestinationWidth, 2844dda4fb85SAurabindo Pillai unsigned int WritebackDestinationHeight, 2845dda4fb85SAurabindo Pillai unsigned int WritebackSourceHeight, 2846dda4fb85SAurabindo Pillai unsigned int HTotal) 2847dda4fb85SAurabindo Pillai { 2848dda4fb85SAurabindo Pillai double CalculateWriteBackDelay; 2849dda4fb85SAurabindo Pillai double Line_length; 2850dda4fb85SAurabindo Pillai double Output_lines_last_notclamped; 2851dda4fb85SAurabindo Pillai double WritebackVInit; 2852dda4fb85SAurabindo Pillai 2853dda4fb85SAurabindo Pillai WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2; 2854dda4fb85SAurabindo Pillai Line_length = dml_max((double) WritebackDestinationWidth, 2855dda4fb85SAurabindo Pillai dml_ceil((double)WritebackDestinationWidth / 6.0, 1.0) * WritebackVTaps); 2856dda4fb85SAurabindo Pillai Output_lines_last_notclamped = WritebackDestinationHeight - 1 - 2857dda4fb85SAurabindo Pillai dml_ceil(((double)WritebackSourceHeight - 2858dda4fb85SAurabindo Pillai (double) WritebackVInit) / (double)WritebackVRatio, 1.0); 2859dda4fb85SAurabindo Pillai if (Output_lines_last_notclamped < 0) { 2860dda4fb85SAurabindo Pillai CalculateWriteBackDelay = 0; 2861dda4fb85SAurabindo Pillai } else { 2862dda4fb85SAurabindo Pillai CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length + 2863dda4fb85SAurabindo Pillai (HTotal - WritebackDestinationWidth) + 80; 2864dda4fb85SAurabindo Pillai } 2865dda4fb85SAurabindo Pillai return CalculateWriteBackDelay; 2866dda4fb85SAurabindo Pillai } 2867dda4fb85SAurabindo Pillai 2868dda4fb85SAurabindo Pillai void dml32_UseMinimumDCFCLK( 2869dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 2870dda4fb85SAurabindo Pillai bool DRRDisplay[], 2871dda4fb85SAurabindo Pillai bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal, 2872dda4fb85SAurabindo Pillai unsigned int MaxInterDCNTileRepeaters, 2873dda4fb85SAurabindo Pillai unsigned int MaxPrefetchMode, 2874dda4fb85SAurabindo Pillai double DRAMClockChangeLatencyFinal, 2875dda4fb85SAurabindo Pillai double FCLKChangeLatency, 2876dda4fb85SAurabindo Pillai double SREnterPlusExitTime, 2877dda4fb85SAurabindo Pillai unsigned int ReturnBusWidth, 2878dda4fb85SAurabindo Pillai unsigned int RoundTripPingLatencyCycles, 2879dda4fb85SAurabindo Pillai unsigned int ReorderingBytes, 2880dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte, 2881dda4fb85SAurabindo Pillai unsigned int MetaChunkSize, 2882dda4fb85SAurabindo Pillai bool GPUVMEnable, 2883dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels, 2884dda4fb85SAurabindo Pillai bool HostVMEnable, 2885dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 2886dda4fb85SAurabindo Pillai double HostVMMinPageSize, 2887dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels, 2888dda4fb85SAurabindo Pillai bool DynamicMetadataVMEnabled, 2889dda4fb85SAurabindo Pillai bool ImmediateFlipRequirement, 2890dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP, 2891dda4fb85SAurabindo Pillai double MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation, 2892dda4fb85SAurabindo Pillai double PercentOfIdealSDPPortBWReceivedAfterUrgLatency, 2893dda4fb85SAurabindo Pillai unsigned int VTotal[], 2894dda4fb85SAurabindo Pillai unsigned int VActive[], 2895dda4fb85SAurabindo Pillai unsigned int DynamicMetadataTransmittedBytes[], 2896dda4fb85SAurabindo Pillai unsigned int DynamicMetadataLinesBeforeActiveRequired[], 2897dda4fb85SAurabindo Pillai bool Interlace[], 2898dda4fb85SAurabindo Pillai double RequiredDPPCLKPerSurface[][2][DC__NUM_DPP__MAX], 2899dda4fb85SAurabindo Pillai double RequiredDISPCLK[][2], 2900dda4fb85SAurabindo Pillai double UrgLatency[], 2901dda4fb85SAurabindo Pillai unsigned int NoOfDPP[][2][DC__NUM_DPP__MAX], 2902dda4fb85SAurabindo Pillai double ProjectedDCFClkDeepSleep[][2], 2903dda4fb85SAurabindo Pillai double MaximumVStartup[][2][DC__NUM_DPP__MAX], 2904dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP[][2], 2905dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP[][2], 2906dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 2907dda4fb85SAurabindo Pillai double PrefetchLinesY[][2][DC__NUM_DPP__MAX], 2908dda4fb85SAurabindo Pillai double PrefetchLinesC[][2][DC__NUM_DPP__MAX], 2909dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub_all_states[][2][DC__NUM_DPP__MAX], 2910dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub_all_states[][2][DC__NUM_DPP__MAX], 2911dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[], 2912dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[], 2913dda4fb85SAurabindo Pillai unsigned int HTotal[], 2914dda4fb85SAurabindo Pillai double PixelClock[], 2915dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesPerFrame[][2][DC__NUM_DPP__MAX], 2916dda4fb85SAurabindo Pillai double DPTEBytesPerRow[][2][DC__NUM_DPP__MAX], 2917dda4fb85SAurabindo Pillai double MetaRowBytes[][2][DC__NUM_DPP__MAX], 2918dda4fb85SAurabindo Pillai bool DynamicMetadataEnable[], 2919dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 2920dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 2921dda4fb85SAurabindo Pillai double DCFCLKPerState[], 2922dda4fb85SAurabindo Pillai /* Output */ 2923dda4fb85SAurabindo Pillai double DCFCLKState[][2]) 2924dda4fb85SAurabindo Pillai { 2925dda4fb85SAurabindo Pillai unsigned int i, j, k; 2926dda4fb85SAurabindo Pillai unsigned int dummy1; 2927dda4fb85SAurabindo Pillai double dummy2, dummy3; 2928dda4fb85SAurabindo Pillai double NormalEfficiency; 2929dda4fb85SAurabindo Pillai double TotalMaxPrefetchFlipDPTERowBandwidth[DC__VOLTAGE_STATES][2]; 2930dda4fb85SAurabindo Pillai 2931dda4fb85SAurabindo Pillai NormalEfficiency = PercentOfIdealSDPPortBWReceivedAfterUrgLatency / 100.0; 2932dda4fb85SAurabindo Pillai for (i = 0; i < DC__VOLTAGE_STATES; ++i) { 2933dda4fb85SAurabindo Pillai for (j = 0; j <= 1; ++j) { 2934dda4fb85SAurabindo Pillai double PixelDCFCLKCyclesRequiredInPrefetch[DC__NUM_DPP__MAX]; 2935dda4fb85SAurabindo Pillai double PrefetchPixelLinesTime[DC__NUM_DPP__MAX]; 2936dda4fb85SAurabindo Pillai double DCFCLKRequiredForPeakBandwidthPerSurface[DC__NUM_DPP__MAX]; 2937dda4fb85SAurabindo Pillai double DynamicMetadataVMExtraLatency[DC__NUM_DPP__MAX]; 2938dda4fb85SAurabindo Pillai double MinimumTWait = 0.0; 2939dda4fb85SAurabindo Pillai double DPTEBandwidth; 2940dda4fb85SAurabindo Pillai double DCFCLKRequiredForAverageBandwidth; 2941dda4fb85SAurabindo Pillai unsigned int ExtraLatencyBytes; 2942dda4fb85SAurabindo Pillai double ExtraLatencyCycles; 2943dda4fb85SAurabindo Pillai double DCFCLKRequiredForPeakBandwidth; 2944dda4fb85SAurabindo Pillai unsigned int NoOfDPPState[DC__NUM_DPP__MAX]; 2945dda4fb85SAurabindo Pillai double MinimumTvmPlus2Tr0; 2946dda4fb85SAurabindo Pillai 2947dda4fb85SAurabindo Pillai TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = 0; 2948dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2949dda4fb85SAurabindo Pillai TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = TotalMaxPrefetchFlipDPTERowBandwidth[i][j] 2950dda4fb85SAurabindo Pillai + NoOfDPP[i][j][k] * DPTEBytesPerRow[i][j][k] 2951dda4fb85SAurabindo Pillai / (15.75 * HTotal[k] / PixelClock[k]); 2952dda4fb85SAurabindo Pillai } 2953dda4fb85SAurabindo Pillai 2954dda4fb85SAurabindo Pillai for (k = 0; k <= NumberOfActiveSurfaces - 1; ++k) 2955dda4fb85SAurabindo Pillai NoOfDPPState[k] = NoOfDPP[i][j][k]; 2956dda4fb85SAurabindo Pillai 2957dda4fb85SAurabindo Pillai DPTEBandwidth = TotalMaxPrefetchFlipDPTERowBandwidth[i][j]; 2958dda4fb85SAurabindo Pillai DCFCLKRequiredForAverageBandwidth = dml_max(ProjectedDCFClkDeepSleep[i][j], DPTEBandwidth / NormalEfficiency / ReturnBusWidth); 2959dda4fb85SAurabindo Pillai 2960dda4fb85SAurabindo Pillai ExtraLatencyBytes = dml32_CalculateExtraLatencyBytes(ReorderingBytes, 2961dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP[i][j], PixelChunkSizeInKByte, 2962dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP[i][j], MetaChunkSize, GPUVMEnable, HostVMEnable, 2963dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, NoOfDPPState, dpte_group_bytes, 1, HostVMMinPageSize, 2964dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels); 2965dda4fb85SAurabindo Pillai ExtraLatencyCycles = RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__ 2966dda4fb85SAurabindo Pillai + ExtraLatencyBytes / NormalEfficiency / ReturnBusWidth; 2967dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 2968dda4fb85SAurabindo Pillai double DCFCLKCyclesRequiredInPrefetch; 2969dda4fb85SAurabindo Pillai double PrefetchTime; 2970dda4fb85SAurabindo Pillai 2971dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] = (PrefetchLinesY[i][j][k] 2972dda4fb85SAurabindo Pillai * swath_width_luma_ub_all_states[i][j][k] * BytePerPixelY[k] 2973dda4fb85SAurabindo Pillai + PrefetchLinesC[i][j][k] * swath_width_chroma_ub_all_states[i][j][k] 2974dda4fb85SAurabindo Pillai * BytePerPixelC[k]) / NormalEfficiency 2975dda4fb85SAurabindo Pillai / ReturnBusWidth; 2976dda4fb85SAurabindo Pillai DCFCLKCyclesRequiredInPrefetch = 2 * ExtraLatencyCycles / NoOfDPPState[k] 2977dda4fb85SAurabindo Pillai + PDEAndMetaPTEBytesPerFrame[i][j][k] / NormalEfficiency 2978dda4fb85SAurabindo Pillai / NormalEfficiency / ReturnBusWidth 2979dda4fb85SAurabindo Pillai * (GPUVMMaxPageTableLevels > 2 ? 1 : 0) 2980dda4fb85SAurabindo Pillai + 2 * DPTEBytesPerRow[i][j][k] / NormalEfficiency / NormalEfficiency 2981dda4fb85SAurabindo Pillai / ReturnBusWidth 2982dda4fb85SAurabindo Pillai + 2 * MetaRowBytes[i][j][k] / NormalEfficiency / ReturnBusWidth 2983dda4fb85SAurabindo Pillai + PixelDCFCLKCyclesRequiredInPrefetch[k]; 2984dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] = dml_max(PrefetchLinesY[i][j][k], PrefetchLinesC[i][j][k]) 2985dda4fb85SAurabindo Pillai * HTotal[k] / PixelClock[k]; 2986dda4fb85SAurabindo Pillai DynamicMetadataVMExtraLatency[k] = (GPUVMEnable == true && 2987dda4fb85SAurabindo Pillai DynamicMetadataEnable[k] == true && DynamicMetadataVMEnabled == true) ? 2988dda4fb85SAurabindo Pillai UrgLatency[i] * GPUVMMaxPageTableLevels * 2989dda4fb85SAurabindo Pillai (HostVMEnable == true ? HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0; 2990dda4fb85SAurabindo Pillai 2991dda4fb85SAurabindo Pillai MinimumTWait = dml32_CalculateTWait(MaxPrefetchMode, 2992dda4fb85SAurabindo Pillai UseMALLForPStateChange[k], 2993dda4fb85SAurabindo Pillai SynchronizeDRRDisplaysForUCLKPStateChangeFinal, 2994dda4fb85SAurabindo Pillai DRRDisplay[k], 2995dda4fb85SAurabindo Pillai DRAMClockChangeLatencyFinal, 2996dda4fb85SAurabindo Pillai FCLKChangeLatency, 2997dda4fb85SAurabindo Pillai UrgLatency[i], 2998dda4fb85SAurabindo Pillai SREnterPlusExitTime); 2999dda4fb85SAurabindo Pillai 3000dda4fb85SAurabindo Pillai PrefetchTime = (MaximumVStartup[i][j][k] - 1) * HTotal[k] / PixelClock[k] - 3001dda4fb85SAurabindo Pillai MinimumTWait - UrgLatency[i] * 3002dda4fb85SAurabindo Pillai ((GPUVMMaxPageTableLevels <= 2 ? GPUVMMaxPageTableLevels : 3003dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels - 2) * (HostVMEnable == true ? 3004dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) - 3005dda4fb85SAurabindo Pillai DynamicMetadataVMExtraLatency[k]; 3006dda4fb85SAurabindo Pillai 3007dda4fb85SAurabindo Pillai if (PrefetchTime > 0) { 3008dda4fb85SAurabindo Pillai double ExpectedVRatioPrefetch; 3009dda4fb85SAurabindo Pillai 3010dda4fb85SAurabindo Pillai ExpectedVRatioPrefetch = PrefetchPixelLinesTime[k] / (PrefetchTime * 3011dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] / 3012dda4fb85SAurabindo Pillai DCFCLKCyclesRequiredInPrefetch); 3013dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = NoOfDPPState[k] * 3014dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] / 3015dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] * 3016dda4fb85SAurabindo Pillai dml_max(1.0, ExpectedVRatioPrefetch) * 3017dda4fb85SAurabindo Pillai dml_max(1.0, ExpectedVRatioPrefetch / 4); 3018dda4fb85SAurabindo Pillai if (HostVMEnable == true || ImmediateFlipRequirement == true) { 3019dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = 3020dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] + 3021dda4fb85SAurabindo Pillai NoOfDPPState[k] * DPTEBandwidth / NormalEfficiency / 3022dda4fb85SAurabindo Pillai NormalEfficiency / ReturnBusWidth; 3023dda4fb85SAurabindo Pillai } 3024dda4fb85SAurabindo Pillai } else { 3025dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = DCFCLKPerState[i]; 3026dda4fb85SAurabindo Pillai } 3027dda4fb85SAurabindo Pillai if (DynamicMetadataEnable[k] == true) { 3028dda4fb85SAurabindo Pillai double TSetupPipe; 3029dda4fb85SAurabindo Pillai double TdmbfPipe; 3030dda4fb85SAurabindo Pillai double TdmsksPipe; 3031dda4fb85SAurabindo Pillai double TdmecPipe; 3032dda4fb85SAurabindo Pillai double AllowedTimeForUrgentExtraLatency; 3033dda4fb85SAurabindo Pillai 3034dda4fb85SAurabindo Pillai dml32_CalculateVUpdateAndDynamicMetadataParameters( 3035dda4fb85SAurabindo Pillai MaxInterDCNTileRepeaters, 3036dda4fb85SAurabindo Pillai RequiredDPPCLKPerSurface[i][j][k], 3037dda4fb85SAurabindo Pillai RequiredDISPCLK[i][j], 3038dda4fb85SAurabindo Pillai ProjectedDCFClkDeepSleep[i][j], 3039dda4fb85SAurabindo Pillai PixelClock[k], 3040dda4fb85SAurabindo Pillai HTotal[k], 3041dda4fb85SAurabindo Pillai VTotal[k] - VActive[k], 3042dda4fb85SAurabindo Pillai DynamicMetadataTransmittedBytes[k], 3043dda4fb85SAurabindo Pillai DynamicMetadataLinesBeforeActiveRequired[k], 3044dda4fb85SAurabindo Pillai Interlace[k], 3045dda4fb85SAurabindo Pillai ProgressiveToInterlaceUnitInOPP, 3046dda4fb85SAurabindo Pillai 3047dda4fb85SAurabindo Pillai /* output */ 3048dda4fb85SAurabindo Pillai &TSetupPipe, 3049dda4fb85SAurabindo Pillai &TdmbfPipe, 3050dda4fb85SAurabindo Pillai &TdmecPipe, 3051dda4fb85SAurabindo Pillai &TdmsksPipe, 3052dda4fb85SAurabindo Pillai &dummy1, 3053dda4fb85SAurabindo Pillai &dummy2, 3054dda4fb85SAurabindo Pillai &dummy3); 3055dda4fb85SAurabindo Pillai AllowedTimeForUrgentExtraLatency = MaximumVStartup[i][j][k] * HTotal[k] / 3056dda4fb85SAurabindo Pillai PixelClock[k] - MinimumTWait - TSetupPipe - TdmbfPipe - 3057dda4fb85SAurabindo Pillai TdmecPipe - TdmsksPipe - DynamicMetadataVMExtraLatency[k]; 3058dda4fb85SAurabindo Pillai if (AllowedTimeForUrgentExtraLatency > 0) 3059dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = 3060dda4fb85SAurabindo Pillai dml_max(DCFCLKRequiredForPeakBandwidthPerSurface[k], 3061dda4fb85SAurabindo Pillai ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency); 3062dda4fb85SAurabindo Pillai else 3063dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = DCFCLKPerState[i]; 3064dda4fb85SAurabindo Pillai } 3065dda4fb85SAurabindo Pillai } 3066dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = 0; 3067dda4fb85SAurabindo Pillai for (k = 0; k <= NumberOfActiveSurfaces - 1; ++k) { 3068dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = DCFCLKRequiredForPeakBandwidth + 3069dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k]; 3070dda4fb85SAurabindo Pillai } 3071dda4fb85SAurabindo Pillai MinimumTvmPlus2Tr0 = UrgLatency[i] * (GPUVMEnable == true ? 3072dda4fb85SAurabindo Pillai (HostVMEnable == true ? (GPUVMMaxPageTableLevels + 2) * 3073dda4fb85SAurabindo Pillai (HostVMMaxNonCachedPageTableLevels + 1) - 1 : GPUVMMaxPageTableLevels + 1) : 0); 3074dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 3075dda4fb85SAurabindo Pillai double MaximumTvmPlus2Tr0PlusTsw; 3076dda4fb85SAurabindo Pillai 3077dda4fb85SAurabindo Pillai MaximumTvmPlus2Tr0PlusTsw = (MaximumVStartup[i][j][k] - 2) * HTotal[k] / 3078dda4fb85SAurabindo Pillai PixelClock[k] - MinimumTWait - DynamicMetadataVMExtraLatency[k]; 3079dda4fb85SAurabindo Pillai if (MaximumTvmPlus2Tr0PlusTsw <= MinimumTvmPlus2Tr0 + PrefetchPixelLinesTime[k] / 4) { 3080dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = DCFCLKPerState[i]; 3081dda4fb85SAurabindo Pillai } else { 3082dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = dml_max3(DCFCLKRequiredForPeakBandwidth, 3083dda4fb85SAurabindo Pillai 2 * ExtraLatencyCycles / (MaximumTvmPlus2Tr0PlusTsw - 3084dda4fb85SAurabindo Pillai MinimumTvmPlus2Tr0 - 3085dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] / 4), 3086dda4fb85SAurabindo Pillai (2 * ExtraLatencyCycles + 3087dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k]) / 3088dda4fb85SAurabindo Pillai (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0)); 3089dda4fb85SAurabindo Pillai } 3090dda4fb85SAurabindo Pillai } 3091dda4fb85SAurabindo Pillai DCFCLKState[i][j] = dml_min(DCFCLKPerState[i], 1.05 * 3092dda4fb85SAurabindo Pillai dml_max(DCFCLKRequiredForAverageBandwidth, DCFCLKRequiredForPeakBandwidth)); 3093dda4fb85SAurabindo Pillai } 3094dda4fb85SAurabindo Pillai } 3095dda4fb85SAurabindo Pillai } 3096dda4fb85SAurabindo Pillai 3097dda4fb85SAurabindo Pillai unsigned int dml32_CalculateExtraLatencyBytes(unsigned int ReorderingBytes, 3098dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP, 3099dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte, 3100dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP, 3101dda4fb85SAurabindo Pillai unsigned int MetaChunkSize, 3102dda4fb85SAurabindo Pillai bool GPUVMEnable, 3103dda4fb85SAurabindo Pillai bool HostVMEnable, 3104dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 3105dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 3106dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 3107dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor, 3108dda4fb85SAurabindo Pillai double HostVMMinPageSize, 3109dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels) 3110dda4fb85SAurabindo Pillai { 3111dda4fb85SAurabindo Pillai unsigned int k; 3112dda4fb85SAurabindo Pillai double ret; 3113dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevels; 3114dda4fb85SAurabindo Pillai 3115dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) { 3116dda4fb85SAurabindo Pillai if (HostVMMinPageSize < 2048) 3117dda4fb85SAurabindo Pillai HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels; 3118dda4fb85SAurabindo Pillai else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576) 3119dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1); 3120dda4fb85SAurabindo Pillai else 3121dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2); 3122dda4fb85SAurabindo Pillai } else { 3123dda4fb85SAurabindo Pillai HostVMDynamicLevels = 0; 3124dda4fb85SAurabindo Pillai } 3125dda4fb85SAurabindo Pillai 3126dda4fb85SAurabindo Pillai ret = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte + 3127dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0; 3128dda4fb85SAurabindo Pillai 3129dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 3130dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 3131dda4fb85SAurabindo Pillai ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] * 3132dda4fb85SAurabindo Pillai (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor; 3133dda4fb85SAurabindo Pillai } 3134dda4fb85SAurabindo Pillai } 3135dda4fb85SAurabindo Pillai return ret; 3136dda4fb85SAurabindo Pillai } 3137dda4fb85SAurabindo Pillai 3138dda4fb85SAurabindo Pillai void dml32_CalculateVUpdateAndDynamicMetadataParameters( 3139dda4fb85SAurabindo Pillai unsigned int MaxInterDCNTileRepeaters, 3140dda4fb85SAurabindo Pillai double Dppclk, 3141dda4fb85SAurabindo Pillai double Dispclk, 3142dda4fb85SAurabindo Pillai double DCFClkDeepSleep, 3143dda4fb85SAurabindo Pillai double PixelClock, 3144dda4fb85SAurabindo Pillai unsigned int HTotal, 3145dda4fb85SAurabindo Pillai unsigned int VBlank, 3146dda4fb85SAurabindo Pillai unsigned int DynamicMetadataTransmittedBytes, 3147dda4fb85SAurabindo Pillai unsigned int DynamicMetadataLinesBeforeActiveRequired, 3148dda4fb85SAurabindo Pillai unsigned int InterlaceEnable, 3149dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP, 3150dda4fb85SAurabindo Pillai 3151dda4fb85SAurabindo Pillai /* output */ 3152dda4fb85SAurabindo Pillai double *TSetup, 3153dda4fb85SAurabindo Pillai double *Tdmbf, 3154dda4fb85SAurabindo Pillai double *Tdmec, 3155dda4fb85SAurabindo Pillai double *Tdmsks, 3156dda4fb85SAurabindo Pillai unsigned int *VUpdateOffsetPix, 3157dda4fb85SAurabindo Pillai double *VUpdateWidthPix, 3158dda4fb85SAurabindo Pillai double *VReadyOffsetPix) 3159dda4fb85SAurabindo Pillai { 3160dda4fb85SAurabindo Pillai double TotalRepeaterDelayTime; 3161dda4fb85SAurabindo Pillai 3162dda4fb85SAurabindo Pillai TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / Dppclk + 3 / Dispclk); 3163dda4fb85SAurabindo Pillai *VUpdateWidthPix = 3164dda4fb85SAurabindo Pillai dml_ceil((14.0 / DCFClkDeepSleep + 12.0 / Dppclk + TotalRepeaterDelayTime) * PixelClock, 1.0); 3165dda4fb85SAurabindo Pillai *VReadyOffsetPix = dml_ceil(dml_max(150.0 / Dppclk, 3166dda4fb85SAurabindo Pillai TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / Dppclk) * PixelClock, 1.0); 3167dda4fb85SAurabindo Pillai *VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1.0); 3168dda4fb85SAurabindo Pillai *TSetup = (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock; 3169dda4fb85SAurabindo Pillai *Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / Dispclk; 3170dda4fb85SAurabindo Pillai *Tdmec = HTotal / PixelClock; 3171dda4fb85SAurabindo Pillai 3172dda4fb85SAurabindo Pillai if (DynamicMetadataLinesBeforeActiveRequired == 0) 3173dda4fb85SAurabindo Pillai *Tdmsks = VBlank * HTotal / PixelClock / 2.0; 3174dda4fb85SAurabindo Pillai else 3175dda4fb85SAurabindo Pillai *Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock; 3176dda4fb85SAurabindo Pillai 3177dda4fb85SAurabindo Pillai if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false) 3178dda4fb85SAurabindo Pillai *Tdmsks = *Tdmsks / 2; 3179dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3180dda4fb85SAurabindo Pillai dml_print("DML::%s: VUpdateWidthPix = %d\n", __func__, *VUpdateWidthPix); 3181dda4fb85SAurabindo Pillai dml_print("DML::%s: VReadyOffsetPix = %d\n", __func__, *VReadyOffsetPix); 3182dda4fb85SAurabindo Pillai dml_print("DML::%s: VUpdateOffsetPix = %d\n", __func__, *VUpdateOffsetPix); 3183dda4fb85SAurabindo Pillai 3184dda4fb85SAurabindo Pillai dml_print("DML::%s: DynamicMetadataLinesBeforeActiveRequired = %d\n", 3185dda4fb85SAurabindo Pillai __func__, DynamicMetadataLinesBeforeActiveRequired); 3186dda4fb85SAurabindo Pillai dml_print("DML::%s: VBlank = %d\n", __func__, VBlank); 3187dda4fb85SAurabindo Pillai dml_print("DML::%s: HTotal = %d\n", __func__, HTotal); 3188dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock); 3189dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmsks = %f\n", __func__, *Tdmsks); 3190dda4fb85SAurabindo Pillai #endif 3191dda4fb85SAurabindo Pillai } 3192dda4fb85SAurabindo Pillai 3193dda4fb85SAurabindo Pillai double dml32_CalculateTWait( 3194dda4fb85SAurabindo Pillai unsigned int PrefetchMode, 3195dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange, 3196dda4fb85SAurabindo Pillai bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal, 3197dda4fb85SAurabindo Pillai bool DRRDisplay, 3198dda4fb85SAurabindo Pillai double DRAMClockChangeLatency, 3199dda4fb85SAurabindo Pillai double FCLKChangeLatency, 3200dda4fb85SAurabindo Pillai double UrgentLatency, 3201dda4fb85SAurabindo Pillai double SREnterPlusExitTime) 3202dda4fb85SAurabindo Pillai { 3203dda4fb85SAurabindo Pillai double TWait = 0.0; 3204dda4fb85SAurabindo Pillai 3205dda4fb85SAurabindo Pillai if (PrefetchMode == 0 && 3206dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_full_frame) && 3207dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_sub_viewport) && 3208dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe) && 3209dda4fb85SAurabindo Pillai !(SynchronizeDRRDisplaysForUCLKPStateChangeFinal && DRRDisplay)) { 3210dda4fb85SAurabindo Pillai TWait = dml_max3(DRAMClockChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency); 3211dda4fb85SAurabindo Pillai } else if (PrefetchMode <= 1 && !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe)) { 3212dda4fb85SAurabindo Pillai TWait = dml_max3(FCLKChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency); 3213dda4fb85SAurabindo Pillai } else if (PrefetchMode <= 2 && !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe)) { 3214dda4fb85SAurabindo Pillai TWait = dml_max(SREnterPlusExitTime, UrgentLatency); 3215dda4fb85SAurabindo Pillai } else { 3216dda4fb85SAurabindo Pillai TWait = UrgentLatency; 3217dda4fb85SAurabindo Pillai } 3218dda4fb85SAurabindo Pillai 3219dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3220dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchMode = %d\n", __func__, PrefetchMode); 3221dda4fb85SAurabindo Pillai dml_print("DML::%s: TWait = %f\n", __func__, TWait); 3222dda4fb85SAurabindo Pillai #endif 3223dda4fb85SAurabindo Pillai return TWait; 3224dda4fb85SAurabindo Pillai } // CalculateTWait 3225dda4fb85SAurabindo Pillai 3226dda4fb85SAurabindo Pillai // Function: get_return_bw_mbps 3227dda4fb85SAurabindo Pillai // Megabyte per second 3228dda4fb85SAurabindo Pillai double dml32_get_return_bw_mbps(const soc_bounding_box_st *soc, 3229dda4fb85SAurabindo Pillai const int VoltageLevel, 3230dda4fb85SAurabindo Pillai const bool HostVMEnable, 3231dda4fb85SAurabindo Pillai const double DCFCLK, 3232dda4fb85SAurabindo Pillai const double FabricClock, 3233dda4fb85SAurabindo Pillai const double DRAMSpeed) 3234dda4fb85SAurabindo Pillai { 3235dda4fb85SAurabindo Pillai double ReturnBW = 0.; 3236dda4fb85SAurabindo Pillai double IdealSDPPortBandwidth = soc->return_bus_width_bytes /*mode_lib->vba.ReturnBusWidth*/ * DCFCLK; 3237dda4fb85SAurabindo Pillai double IdealFabricBandwidth = FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes; 3238dda4fb85SAurabindo Pillai double IdealDRAMBandwidth = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes; 3239dda4fb85SAurabindo Pillai double PixelDataOnlyReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100, 3240dda4fb85SAurabindo Pillai IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100, 3241dda4fb85SAurabindo Pillai IdealDRAMBandwidth * (VoltageLevel < 2 ? soc->pct_ideal_dram_bw_after_urgent_strobe : 3242dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_pixel_only) / 100); 3243dda4fb85SAurabindo Pillai double PixelMixedWithVMDataReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100, 3244dda4fb85SAurabindo Pillai IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100, 3245dda4fb85SAurabindo Pillai IdealDRAMBandwidth * (VoltageLevel < 2 ? soc->pct_ideal_dram_bw_after_urgent_strobe : 3246dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_pixel_only) / 100); 3247dda4fb85SAurabindo Pillai 3248dda4fb85SAurabindo Pillai if (HostVMEnable != true) 3249dda4fb85SAurabindo Pillai ReturnBW = PixelDataOnlyReturnBW; 3250dda4fb85SAurabindo Pillai else 3251dda4fb85SAurabindo Pillai ReturnBW = PixelMixedWithVMDataReturnBW; 3252dda4fb85SAurabindo Pillai 3253dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3254dda4fb85SAurabindo Pillai dml_print("DML::%s: VoltageLevel = %d\n", __func__, VoltageLevel); 3255dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMEnable = %d\n", __func__, HostVMEnable); 3256dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK); 3257dda4fb85SAurabindo Pillai dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock); 3258dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed); 3259dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealSDPPortBandwidth = %f\n", __func__, IdealSDPPortBandwidth); 3260dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealFabricBandwidth = %f\n", __func__, IdealFabricBandwidth); 3261dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth); 3262dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW); 3263dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW); 3264dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f MBps\n", __func__, ReturnBW); 3265dda4fb85SAurabindo Pillai #endif 3266dda4fb85SAurabindo Pillai return ReturnBW; 3267dda4fb85SAurabindo Pillai } 3268dda4fb85SAurabindo Pillai 3269dda4fb85SAurabindo Pillai // Function: get_return_bw_mbps_vm_only 3270dda4fb85SAurabindo Pillai // Megabyte per second 3271dda4fb85SAurabindo Pillai double dml32_get_return_bw_mbps_vm_only(const soc_bounding_box_st *soc, 3272dda4fb85SAurabindo Pillai const int VoltageLevel, 3273dda4fb85SAurabindo Pillai const double DCFCLK, 3274dda4fb85SAurabindo Pillai const double FabricClock, 3275dda4fb85SAurabindo Pillai const double DRAMSpeed) 3276dda4fb85SAurabindo Pillai { 3277dda4fb85SAurabindo Pillai double VMDataOnlyReturnBW = dml_min3( 3278dda4fb85SAurabindo Pillai soc->return_bus_width_bytes * DCFCLK * soc->pct_ideal_sdp_bw_after_urgent / 100.0, 3279dda4fb85SAurabindo Pillai FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes 3280dda4fb85SAurabindo Pillai * soc->pct_ideal_sdp_bw_after_urgent / 100.0, 3281dda4fb85SAurabindo Pillai DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes 3282dda4fb85SAurabindo Pillai * (VoltageLevel < 2 ? 3283dda4fb85SAurabindo Pillai soc->pct_ideal_dram_bw_after_urgent_strobe : 3284dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_vm_only) / 100.0); 3285dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3286dda4fb85SAurabindo Pillai dml_print("DML::%s: VoltageLevel = %d\n", __func__, VoltageLevel); 3287dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK); 3288dda4fb85SAurabindo Pillai dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock); 3289dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed); 3290dda4fb85SAurabindo Pillai dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW); 3291dda4fb85SAurabindo Pillai #endif 3292dda4fb85SAurabindo Pillai return VMDataOnlyReturnBW; 3293dda4fb85SAurabindo Pillai } 3294dda4fb85SAurabindo Pillai 3295dda4fb85SAurabindo Pillai double dml32_CalculateExtraLatency( 3296dda4fb85SAurabindo Pillai unsigned int RoundTripPingLatencyCycles, 3297dda4fb85SAurabindo Pillai unsigned int ReorderingBytes, 3298dda4fb85SAurabindo Pillai double DCFCLK, 3299dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP, 3300dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte, 3301dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP, 3302dda4fb85SAurabindo Pillai unsigned int MetaChunkSize, 3303dda4fb85SAurabindo Pillai double ReturnBW, 3304dda4fb85SAurabindo Pillai bool GPUVMEnable, 3305dda4fb85SAurabindo Pillai bool HostVMEnable, 3306dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 3307dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 3308dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 3309dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor, 3310dda4fb85SAurabindo Pillai double HostVMMinPageSize, 3311dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels) 3312dda4fb85SAurabindo Pillai { 3313dda4fb85SAurabindo Pillai double ExtraLatencyBytes; 3314dda4fb85SAurabindo Pillai double ExtraLatency; 3315dda4fb85SAurabindo Pillai 3316dda4fb85SAurabindo Pillai ExtraLatencyBytes = dml32_CalculateExtraLatencyBytes( 3317dda4fb85SAurabindo Pillai ReorderingBytes, 3318dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP, 3319dda4fb85SAurabindo Pillai PixelChunkSizeInKByte, 3320dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP, 3321dda4fb85SAurabindo Pillai MetaChunkSize, 3322dda4fb85SAurabindo Pillai GPUVMEnable, 3323dda4fb85SAurabindo Pillai HostVMEnable, 3324dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, 3325dda4fb85SAurabindo Pillai NumberOfDPP, 3326dda4fb85SAurabindo Pillai dpte_group_bytes, 3327dda4fb85SAurabindo Pillai HostVMInefficiencyFactor, 3328dda4fb85SAurabindo Pillai HostVMMinPageSize, 3329dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels); 3330dda4fb85SAurabindo Pillai 3331dda4fb85SAurabindo Pillai ExtraLatency = (RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__) / DCFCLK + ExtraLatencyBytes / ReturnBW; 3332dda4fb85SAurabindo Pillai 3333dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3334dda4fb85SAurabindo Pillai dml_print("DML::%s: RoundTripPingLatencyCycles=%d\n", __func__, RoundTripPingLatencyCycles); 3335dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK=%f\n", __func__, DCFCLK); 3336dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatencyBytes=%f\n", __func__, ExtraLatencyBytes); 3337dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW=%f\n", __func__, ReturnBW); 3338dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatency=%f\n", __func__, ExtraLatency); 3339dda4fb85SAurabindo Pillai #endif 3340dda4fb85SAurabindo Pillai 3341dda4fb85SAurabindo Pillai return ExtraLatency; 3342dda4fb85SAurabindo Pillai } // CalculateExtraLatency 3343dda4fb85SAurabindo Pillai 3344dda4fb85SAurabindo Pillai bool dml32_CalculatePrefetchSchedule( 3345dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor, 3346dda4fb85SAurabindo Pillai DmlPipe *myPipe, 3347dda4fb85SAurabindo Pillai unsigned int DSCDelay, 3348dda4fb85SAurabindo Pillai double DPPCLKDelaySubtotalPlusCNVCFormater, 3349dda4fb85SAurabindo Pillai double DPPCLKDelaySCL, 3350dda4fb85SAurabindo Pillai double DPPCLKDelaySCLLBOnly, 3351dda4fb85SAurabindo Pillai double DPPCLKDelayCNVCCursor, 3352dda4fb85SAurabindo Pillai double DISPCLKDelaySubtotal, 3353dda4fb85SAurabindo Pillai unsigned int DPP_RECOUT_WIDTH, 3354dda4fb85SAurabindo Pillai enum output_format_class OutputFormat, 3355dda4fb85SAurabindo Pillai unsigned int MaxInterDCNTileRepeaters, 3356dda4fb85SAurabindo Pillai unsigned int VStartup, 3357dda4fb85SAurabindo Pillai unsigned int MaxVStartup, 3358dda4fb85SAurabindo Pillai unsigned int GPUVMPageTableLevels, 3359dda4fb85SAurabindo Pillai bool GPUVMEnable, 3360dda4fb85SAurabindo Pillai bool HostVMEnable, 3361dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels, 3362dda4fb85SAurabindo Pillai double HostVMMinPageSize, 3363dda4fb85SAurabindo Pillai bool DynamicMetadataEnable, 3364dda4fb85SAurabindo Pillai bool DynamicMetadataVMEnabled, 3365dda4fb85SAurabindo Pillai int DynamicMetadataLinesBeforeActiveRequired, 3366dda4fb85SAurabindo Pillai unsigned int DynamicMetadataTransmittedBytes, 3367dda4fb85SAurabindo Pillai double UrgentLatency, 3368dda4fb85SAurabindo Pillai double UrgentExtraLatency, 3369dda4fb85SAurabindo Pillai double TCalc, 3370dda4fb85SAurabindo Pillai unsigned int PDEAndMetaPTEBytesFrame, 3371dda4fb85SAurabindo Pillai unsigned int MetaRowByte, 3372dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRow, 3373dda4fb85SAurabindo Pillai double PrefetchSourceLinesY, 3374dda4fb85SAurabindo Pillai unsigned int SwathWidthY, 3375dda4fb85SAurabindo Pillai unsigned int VInitPreFillY, 3376dda4fb85SAurabindo Pillai unsigned int MaxNumSwathY, 3377dda4fb85SAurabindo Pillai double PrefetchSourceLinesC, 3378dda4fb85SAurabindo Pillai unsigned int SwathWidthC, 3379dda4fb85SAurabindo Pillai unsigned int VInitPreFillC, 3380dda4fb85SAurabindo Pillai unsigned int MaxNumSwathC, 3381dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub, 3382dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub, 3383dda4fb85SAurabindo Pillai unsigned int SwathHeightY, 3384dda4fb85SAurabindo Pillai unsigned int SwathHeightC, 3385dda4fb85SAurabindo Pillai double TWait, 3386dda4fb85SAurabindo Pillai /* Output */ 3387dda4fb85SAurabindo Pillai double *DSTXAfterScaler, 3388dda4fb85SAurabindo Pillai double *DSTYAfterScaler, 3389dda4fb85SAurabindo Pillai double *DestinationLinesForPrefetch, 3390dda4fb85SAurabindo Pillai double *PrefetchBandwidth, 3391dda4fb85SAurabindo Pillai double *DestinationLinesToRequestVMInVBlank, 3392dda4fb85SAurabindo Pillai double *DestinationLinesToRequestRowInVBlank, 3393dda4fb85SAurabindo Pillai double *VRatioPrefetchY, 3394dda4fb85SAurabindo Pillai double *VRatioPrefetchC, 3395dda4fb85SAurabindo Pillai double *RequiredPrefetchPixDataBWLuma, 3396dda4fb85SAurabindo Pillai double *RequiredPrefetchPixDataBWChroma, 3397dda4fb85SAurabindo Pillai bool *NotEnoughTimeForDynamicMetadata, 3398dda4fb85SAurabindo Pillai double *Tno_bw, 3399dda4fb85SAurabindo Pillai double *prefetch_vmrow_bw, 3400dda4fb85SAurabindo Pillai double *Tdmdl_vm, 3401dda4fb85SAurabindo Pillai double *Tdmdl, 3402dda4fb85SAurabindo Pillai double *TSetup, 3403dda4fb85SAurabindo Pillai unsigned int *VUpdateOffsetPix, 3404dda4fb85SAurabindo Pillai double *VUpdateWidthPix, 3405dda4fb85SAurabindo Pillai double *VReadyOffsetPix) 3406dda4fb85SAurabindo Pillai { 3407dda4fb85SAurabindo Pillai bool MyError = false; 3408*efcc9706SRodrigo Siqueira unsigned int DPPCycles, DISPCLKCycles; 3409*efcc9706SRodrigo Siqueira double DSTTotalPixelsAfterScaler; 3410*efcc9706SRodrigo Siqueira double LineTime; 3411*efcc9706SRodrigo Siqueira double dst_y_prefetch_equ; 3412*efcc9706SRodrigo Siqueira double prefetch_bw_oto; 3413*efcc9706SRodrigo Siqueira double Tvm_oto; 3414*efcc9706SRodrigo Siqueira double Tr0_oto; 3415*efcc9706SRodrigo Siqueira double Tvm_oto_lines; 3416*efcc9706SRodrigo Siqueira double Tr0_oto_lines; 3417*efcc9706SRodrigo Siqueira double dst_y_prefetch_oto; 3418*efcc9706SRodrigo Siqueira double TimeForFetchingMetaPTE = 0; 3419*efcc9706SRodrigo Siqueira double TimeForFetchingRowInVBlank = 0; 3420*efcc9706SRodrigo Siqueira double LinesToRequestPrefetchPixelData = 0; 3421*efcc9706SRodrigo Siqueira unsigned int HostVMDynamicLevelsTrips; 3422*efcc9706SRodrigo Siqueira double trip_to_mem; 3423*efcc9706SRodrigo Siqueira double Tvm_trips; 3424*efcc9706SRodrigo Siqueira double Tr0_trips; 3425*efcc9706SRodrigo Siqueira double Tvm_trips_rounded; 3426*efcc9706SRodrigo Siqueira double Tr0_trips_rounded; 3427*efcc9706SRodrigo Siqueira double Lsw_oto; 3428*efcc9706SRodrigo Siqueira double Tpre_rounded; 3429*efcc9706SRodrigo Siqueira double prefetch_bw_equ; 3430*efcc9706SRodrigo Siqueira double Tvm_equ; 3431*efcc9706SRodrigo Siqueira double Tr0_equ; 3432*efcc9706SRodrigo Siqueira double Tdmbf; 3433*efcc9706SRodrigo Siqueira double Tdmec; 3434*efcc9706SRodrigo Siqueira double Tdmsks; 3435*efcc9706SRodrigo Siqueira double prefetch_sw_bytes; 3436*efcc9706SRodrigo Siqueira double bytes_pp; 3437*efcc9706SRodrigo Siqueira double dep_bytes; 3438*efcc9706SRodrigo Siqueira unsigned int max_vratio_pre = __DML_MAX_VRATIO_PRE__; 3439*efcc9706SRodrigo Siqueira double min_Lsw; 3440*efcc9706SRodrigo Siqueira double Tsw_est1 = 0; 3441*efcc9706SRodrigo Siqueira double Tsw_est3 = 0; 3442dda4fb85SAurabindo Pillai 3443dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) 3444*efcc9706SRodrigo Siqueira HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels; 3445dda4fb85SAurabindo Pillai else 3446*efcc9706SRodrigo Siqueira HostVMDynamicLevelsTrips = 0; 3447dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3448dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable); 3449dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMPageTableLevels = %d\n", __func__, GPUVMPageTableLevels); 3450dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, myPipe->DCCEnable); 3451dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMEnable=%d HostVMInefficiencyFactor=%f\n", 3452dda4fb85SAurabindo Pillai __func__, HostVMEnable, HostVMInefficiencyFactor); 3453dda4fb85SAurabindo Pillai #endif 3454dda4fb85SAurabindo Pillai dml32_CalculateVUpdateAndDynamicMetadataParameters( 3455dda4fb85SAurabindo Pillai MaxInterDCNTileRepeaters, 3456dda4fb85SAurabindo Pillai myPipe->Dppclk, 3457dda4fb85SAurabindo Pillai myPipe->Dispclk, 3458dda4fb85SAurabindo Pillai myPipe->DCFClkDeepSleep, 3459dda4fb85SAurabindo Pillai myPipe->PixelClock, 3460dda4fb85SAurabindo Pillai myPipe->HTotal, 3461dda4fb85SAurabindo Pillai myPipe->VBlank, 3462dda4fb85SAurabindo Pillai DynamicMetadataTransmittedBytes, 3463dda4fb85SAurabindo Pillai DynamicMetadataLinesBeforeActiveRequired, 3464dda4fb85SAurabindo Pillai myPipe->InterlaceEnable, 3465dda4fb85SAurabindo Pillai myPipe->ProgressiveToInterlaceUnitInOPP, 3466dda4fb85SAurabindo Pillai TSetup, 3467dda4fb85SAurabindo Pillai 3468dda4fb85SAurabindo Pillai /* output */ 3469*efcc9706SRodrigo Siqueira &Tdmbf, 3470*efcc9706SRodrigo Siqueira &Tdmec, 3471*efcc9706SRodrigo Siqueira &Tdmsks, 3472dda4fb85SAurabindo Pillai VUpdateOffsetPix, 3473dda4fb85SAurabindo Pillai VUpdateWidthPix, 3474dda4fb85SAurabindo Pillai VReadyOffsetPix); 3475dda4fb85SAurabindo Pillai 3476*efcc9706SRodrigo Siqueira LineTime = myPipe->HTotal / myPipe->PixelClock; 3477*efcc9706SRodrigo Siqueira trip_to_mem = UrgentLatency; 3478*efcc9706SRodrigo Siqueira Tvm_trips = UrgentExtraLatency + trip_to_mem * (GPUVMPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1); 3479dda4fb85SAurabindo Pillai 3480dda4fb85SAurabindo Pillai if (DynamicMetadataVMEnabled == true) 3481*efcc9706SRodrigo Siqueira *Tdmdl = TWait + Tvm_trips + trip_to_mem; 3482dda4fb85SAurabindo Pillai else 3483dda4fb85SAurabindo Pillai *Tdmdl = TWait + UrgentExtraLatency; 3484dda4fb85SAurabindo Pillai 3485dda4fb85SAurabindo Pillai #ifdef __DML_VBA_ALLOW_DELTA__ 3486dda4fb85SAurabindo Pillai if (DynamicMetadataEnable == false) 3487dda4fb85SAurabindo Pillai *Tdmdl = 0.0; 3488dda4fb85SAurabindo Pillai #endif 3489dda4fb85SAurabindo Pillai 3490dda4fb85SAurabindo Pillai if (DynamicMetadataEnable == true) { 3491*efcc9706SRodrigo Siqueira if (VStartup * LineTime < *TSetup + *Tdmdl + Tdmbf + Tdmec + Tdmsks) { 3492dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = true; 3493dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3494dda4fb85SAurabindo Pillai dml_print("DML::%s: Not Enough Time for Dynamic Meta!\n", __func__); 3495dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", 3496*efcc9706SRodrigo Siqueira __func__, Tdmbf); 3497*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, Tdmec); 3498dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n", 3499*efcc9706SRodrigo Siqueira __func__, Tdmsks); 3500dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd\n", 3501dda4fb85SAurabindo Pillai __func__, *Tdmdl); 3502dda4fb85SAurabindo Pillai #endif 3503dda4fb85SAurabindo Pillai } else { 3504dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = false; 3505dda4fb85SAurabindo Pillai } 3506dda4fb85SAurabindo Pillai } else { 3507dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = false; 3508dda4fb85SAurabindo Pillai } 3509dda4fb85SAurabindo Pillai 3510dda4fb85SAurabindo Pillai *Tdmdl_vm = (DynamicMetadataEnable == true && DynamicMetadataVMEnabled == true && 3511*efcc9706SRodrigo Siqueira GPUVMEnable == true ? TWait + Tvm_trips : 0); 3512dda4fb85SAurabindo Pillai 3513dda4fb85SAurabindo Pillai if (myPipe->ScalerEnabled) 3514*efcc9706SRodrigo Siqueira DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCL; 3515dda4fb85SAurabindo Pillai else 3516*efcc9706SRodrigo Siqueira DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + DPPCLKDelaySCLLBOnly; 3517dda4fb85SAurabindo Pillai 3518*efcc9706SRodrigo Siqueira DPPCycles = DPPCycles + myPipe->NumberOfCursors * DPPCLKDelayCNVCCursor; 3519dda4fb85SAurabindo Pillai 3520*efcc9706SRodrigo Siqueira DISPCLKCycles = DISPCLKDelaySubtotal; 3521dda4fb85SAurabindo Pillai 3522dda4fb85SAurabindo Pillai if (myPipe->Dppclk == 0.0 || myPipe->Dispclk == 0.0) 3523dda4fb85SAurabindo Pillai return true; 3524dda4fb85SAurabindo Pillai 3525*efcc9706SRodrigo Siqueira *DSTXAfterScaler = DPPCycles * myPipe->PixelClock / myPipe->Dppclk + DISPCLKCycles * 3526dda4fb85SAurabindo Pillai myPipe->PixelClock / myPipe->Dispclk + DSCDelay; 3527dda4fb85SAurabindo Pillai 3528dda4fb85SAurabindo Pillai *DSTXAfterScaler = *DSTXAfterScaler + (myPipe->ODMMode != dm_odm_combine_mode_disabled ? 18 : 0) 3529dda4fb85SAurabindo Pillai + (myPipe->DPPPerSurface - 1) * DPP_RECOUT_WIDTH 3530dda4fb85SAurabindo Pillai + ((myPipe->ODMMode == dm_odm_split_mode_1to2 || myPipe->ODMMode == dm_odm_mode_mso_1to2) ? 3531dda4fb85SAurabindo Pillai myPipe->HActive / 2 : 0) 3532dda4fb85SAurabindo Pillai + ((myPipe->ODMMode == dm_odm_mode_mso_1to4) ? myPipe->HActive * 3 / 4 : 0); 3533dda4fb85SAurabindo Pillai 3534dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3535*efcc9706SRodrigo Siqueira dml_print("DML::%s: DPPCycles: %d\n", __func__, DPPCycles); 3536dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelClock: %f\n", __func__, myPipe->PixelClock); 3537dda4fb85SAurabindo Pillai dml_print("DML::%s: Dppclk: %f\n", __func__, myPipe->Dppclk); 3538*efcc9706SRodrigo Siqueira dml_print("DML::%s: DISPCLKCycles: %d\n", __func__, DISPCLKCycles); 3539dda4fb85SAurabindo Pillai dml_print("DML::%s: DISPCLK: %f\n", __func__, myPipe->Dispclk); 3540dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCDelay: %d\n", __func__, DSCDelay); 3541dda4fb85SAurabindo Pillai dml_print("DML::%s: ODMMode: %d\n", __func__, myPipe->ODMMode); 3542dda4fb85SAurabindo Pillai dml_print("DML::%s: DPP_RECOUT_WIDTH: %d\n", __func__, DPP_RECOUT_WIDTH); 3543dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTXAfterScaler: %d\n", __func__, *DSTXAfterScaler); 3544dda4fb85SAurabindo Pillai #endif 3545dda4fb85SAurabindo Pillai 3546dda4fb85SAurabindo Pillai if (OutputFormat == dm_420 || (myPipe->InterlaceEnable && myPipe->ProgressiveToInterlaceUnitInOPP)) 3547dda4fb85SAurabindo Pillai *DSTYAfterScaler = 1; 3548dda4fb85SAurabindo Pillai else 3549dda4fb85SAurabindo Pillai *DSTYAfterScaler = 0; 3550dda4fb85SAurabindo Pillai 3551*efcc9706SRodrigo Siqueira DSTTotalPixelsAfterScaler = *DSTYAfterScaler * myPipe->HTotal + *DSTXAfterScaler; 3552*efcc9706SRodrigo Siqueira *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / myPipe->HTotal, 1); 3553*efcc9706SRodrigo Siqueira *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * myPipe->HTotal)); 3554dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3555dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTXAfterScaler: %d (final)\n", __func__, *DSTXAfterScaler); 3556dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTYAfterScaler: %d (final)\n", __func__, *DSTYAfterScaler); 3557dda4fb85SAurabindo Pillai #endif 3558dda4fb85SAurabindo Pillai 3559dda4fb85SAurabindo Pillai MyError = false; 3560dda4fb85SAurabindo Pillai 3561*efcc9706SRodrigo Siqueira Tr0_trips = trip_to_mem * (HostVMDynamicLevelsTrips + 1); 3562dda4fb85SAurabindo Pillai 3563dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 3564*efcc9706SRodrigo Siqueira Tvm_trips_rounded = dml_ceil(4.0 * Tvm_trips / LineTime, 1.0) / 4.0 * LineTime; 3565*efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1.0) / 4.0 * LineTime; 3566dda4fb85SAurabindo Pillai if (GPUVMPageTableLevels >= 3) { 3567*efcc9706SRodrigo Siqueira *Tno_bw = UrgentExtraLatency + trip_to_mem * 3568*efcc9706SRodrigo Siqueira (double) ((GPUVMPageTableLevels - 2) * (HostVMDynamicLevelsTrips + 1) - 1); 3569dda4fb85SAurabindo Pillai } else if (GPUVMPageTableLevels == 1 && myPipe->DCCEnable != true) { 3570*efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * UrgentExtraLatency / LineTime, 1.0) / 3571*efcc9706SRodrigo Siqueira 4.0 * LineTime; // VBA_ERROR 3572dda4fb85SAurabindo Pillai *Tno_bw = UrgentExtraLatency; 3573dda4fb85SAurabindo Pillai } else { 3574dda4fb85SAurabindo Pillai *Tno_bw = 0; 3575dda4fb85SAurabindo Pillai } 3576dda4fb85SAurabindo Pillai } else if (myPipe->DCCEnable == true) { 3577*efcc9706SRodrigo Siqueira Tvm_trips_rounded = LineTime / 4.0; 3578*efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1.0) / 4.0 * LineTime; 3579dda4fb85SAurabindo Pillai *Tno_bw = 0; 3580dda4fb85SAurabindo Pillai } else { 3581*efcc9706SRodrigo Siqueira Tvm_trips_rounded = LineTime / 4.0; 3582*efcc9706SRodrigo Siqueira Tr0_trips_rounded = LineTime / 2.0; 3583dda4fb85SAurabindo Pillai *Tno_bw = 0; 3584dda4fb85SAurabindo Pillai } 3585*efcc9706SRodrigo Siqueira Tvm_trips_rounded = dml_max(Tvm_trips_rounded, LineTime / 4.0); 3586*efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_max(Tr0_trips_rounded, LineTime / 4.0); 3587dda4fb85SAurabindo Pillai 3588dda4fb85SAurabindo Pillai if (myPipe->SourcePixelFormat == dm_420_8 || myPipe->SourcePixelFormat == dm_420_10 3589dda4fb85SAurabindo Pillai || myPipe->SourcePixelFormat == dm_420_12) { 3590*efcc9706SRodrigo Siqueira bytes_pp = myPipe->BytePerPixelY + myPipe->BytePerPixelC / 4; 3591dda4fb85SAurabindo Pillai } else { 3592*efcc9706SRodrigo Siqueira bytes_pp = myPipe->BytePerPixelY + myPipe->BytePerPixelC; 3593dda4fb85SAurabindo Pillai } 3594dda4fb85SAurabindo Pillai 3595*efcc9706SRodrigo Siqueira prefetch_sw_bytes = PrefetchSourceLinesY * swath_width_luma_ub * myPipe->BytePerPixelY 3596dda4fb85SAurabindo Pillai + PrefetchSourceLinesC * swath_width_chroma_ub * myPipe->BytePerPixelC; 3597*efcc9706SRodrigo Siqueira prefetch_bw_oto = dml_max(bytes_pp * myPipe->PixelClock / myPipe->DPPPerSurface, 3598*efcc9706SRodrigo Siqueira prefetch_sw_bytes / (dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime)); 3599dda4fb85SAurabindo Pillai 3600*efcc9706SRodrigo Siqueira min_Lsw = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) / max_vratio_pre; 3601*efcc9706SRodrigo Siqueira min_Lsw = dml_max(min_Lsw, 1.0); 3602*efcc9706SRodrigo Siqueira Lsw_oto = dml_ceil(4.0 * dml_max(prefetch_sw_bytes / prefetch_bw_oto / LineTime, min_Lsw), 1.0) / 4.0; 3603dda4fb85SAurabindo Pillai 3604dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 3605*efcc9706SRodrigo Siqueira Tvm_oto = dml_max3( 3606*efcc9706SRodrigo Siqueira Tvm_trips, 3607*efcc9706SRodrigo Siqueira *Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_oto, 3608*efcc9706SRodrigo Siqueira LineTime / 4.0); 3609dda4fb85SAurabindo Pillai } else 3610*efcc9706SRodrigo Siqueira Tvm_oto = LineTime / 4.0; 3611dda4fb85SAurabindo Pillai 3612dda4fb85SAurabindo Pillai if ((GPUVMEnable == true || myPipe->DCCEnable == true)) { 3613*efcc9706SRodrigo Siqueira Tr0_oto = dml_max4( 3614*efcc9706SRodrigo Siqueira Tr0_trips, 3615*efcc9706SRodrigo Siqueira (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto, 3616*efcc9706SRodrigo Siqueira (LineTime - Tvm_oto)/2.0, 3617*efcc9706SRodrigo Siqueira LineTime / 4.0); 3618dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3619dda4fb85SAurabindo Pillai dml_print("DML::%s: Tr0_oto max0 = %f\n", __func__, 3620*efcc9706SRodrigo Siqueira (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto); 3621*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max1 = %f\n", __func__, Tr0_trips); 3622*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max2 = %f\n", __func__, LineTime - Tvm_oto); 3623*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max3 = %f\n", __func__, LineTime / 4); 3624dda4fb85SAurabindo Pillai #endif 3625dda4fb85SAurabindo Pillai } else 3626*efcc9706SRodrigo Siqueira Tr0_oto = (LineTime - Tvm_oto) / 2.0; 3627dda4fb85SAurabindo Pillai 3628*efcc9706SRodrigo Siqueira Tvm_oto_lines = dml_ceil(4.0 * Tvm_oto / LineTime, 1) / 4.0; 3629*efcc9706SRodrigo Siqueira Tr0_oto_lines = dml_ceil(4.0 * Tr0_oto / LineTime, 1) / 4.0; 3630*efcc9706SRodrigo Siqueira dst_y_prefetch_oto = Tvm_oto_lines + 2 * Tr0_oto_lines + Lsw_oto; 3631dda4fb85SAurabindo Pillai 3632*efcc9706SRodrigo Siqueira dst_y_prefetch_equ = VStartup - (*TSetup + dml_max(TWait + TCalc, *Tdmdl)) / LineTime - 3633dda4fb85SAurabindo Pillai (*DSTYAfterScaler + (double) *DSTXAfterScaler / (double) myPipe->HTotal); 3634dda4fb85SAurabindo Pillai 3635dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3636dda4fb85SAurabindo Pillai dml_print("DML::%s: HTotal = %d\n", __func__, myPipe->HTotal); 3637*efcc9706SRodrigo Siqueira dml_print("DML::%s: min_Lsw = %f\n", __func__, min_Lsw); 3638dda4fb85SAurabindo Pillai dml_print("DML::%s: *Tno_bw = %f\n", __func__, *Tno_bw); 3639dda4fb85SAurabindo Pillai dml_print("DML::%s: UrgentExtraLatency = %f\n", __func__, UrgentExtraLatency); 3640*efcc9706SRodrigo Siqueira dml_print("DML::%s: trip_to_mem = %f\n", __func__, trip_to_mem); 3641dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, myPipe->BytePerPixelY); 3642dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY); 3643dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_luma_ub = %d\n", __func__, swath_width_luma_ub); 3644dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelC = %d\n", __func__, myPipe->BytePerPixelC); 3645dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, PrefetchSourceLinesC); 3646dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_chroma_ub = %d\n", __func__, swath_width_chroma_ub); 3647*efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_sw_bytes = %f\n", __func__, prefetch_sw_bytes); 3648*efcc9706SRodrigo Siqueira dml_print("DML::%s: bytes_pp = %f\n", __func__, bytes_pp); 3649dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame); 3650dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaRowByte = %d\n", __func__, MetaRowByte); 3651dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, PixelPTEBytesPerRow); 3652dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor); 3653*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_trips = %f\n", __func__, Tvm_trips); 3654*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_trips = %f\n", __func__, Tr0_trips); 3655*efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_bw_oto = %f\n", __func__, prefetch_bw_oto); 3656*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto = %f\n", __func__, Tr0_oto); 3657*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_oto = %f\n", __func__, Tvm_oto); 3658*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_oto_lines = %f\n", __func__, Tvm_oto_lines); 3659*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto_lines = %f\n", __func__, Tr0_oto_lines); 3660*efcc9706SRodrigo Siqueira dml_print("DML::%s: Lsw_oto = %f\n", __func__, Lsw_oto); 3661*efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_oto = %f\n", __func__, dst_y_prefetch_oto); 3662*efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_equ = %f\n", __func__, dst_y_prefetch_equ); 3663dda4fb85SAurabindo Pillai #endif 3664dda4fb85SAurabindo Pillai 3665*efcc9706SRodrigo Siqueira dst_y_prefetch_equ = dml_floor(4.0 * (dst_y_prefetch_equ + 0.125), 1) / 4.0; 3666*efcc9706SRodrigo Siqueira Tpre_rounded = dst_y_prefetch_equ * LineTime; 3667dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3668*efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_equ: %f (after round)\n", __func__, dst_y_prefetch_equ); 3669*efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime: %f\n", __func__, LineTime); 3670dda4fb85SAurabindo Pillai dml_print("DML::%s: VStartup: %d\n", __func__, VStartup); 3671dda4fb85SAurabindo Pillai dml_print("DML::%s: Tvstartup: %fus - time between vstartup and first pixel of active\n", 3672*efcc9706SRodrigo Siqueira __func__, VStartup * LineTime); 3673dda4fb85SAurabindo Pillai dml_print("DML::%s: TSetup: %fus - time from vstartup to vready\n", __func__, *TSetup); 3674dda4fb85SAurabindo Pillai dml_print("DML::%s: TCalc: %fus - time for calculations in dchub starting at vready\n", __func__, TCalc); 3675*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, Tdmbf); 3676*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, Tdmec); 3677dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl_vm: %fus - time for vm stages of dmd\n", __func__, *Tdmdl_vm); 3678dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd\n", __func__, *Tdmdl); 3679dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTYAfterScaler: %d lines - number of lines of pipeline and buffer delay after scaler\n", 3680dda4fb85SAurabindo Pillai __func__, *DSTYAfterScaler); 3681dda4fb85SAurabindo Pillai #endif 3682*efcc9706SRodrigo Siqueira dep_bytes = dml_max(PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor, 3683dda4fb85SAurabindo Pillai MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor); 3684dda4fb85SAurabindo Pillai 3685*efcc9706SRodrigo Siqueira if (prefetch_sw_bytes < dep_bytes) 3686*efcc9706SRodrigo Siqueira prefetch_sw_bytes = 2 * dep_bytes; 3687dda4fb85SAurabindo Pillai 3688dda4fb85SAurabindo Pillai *PrefetchBandwidth = 0; 3689dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank = 0; 3690dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank = 0; 3691dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0; 3692dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0; 3693dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0; 3694*efcc9706SRodrigo Siqueira if (dst_y_prefetch_equ > 1) { 3695dda4fb85SAurabindo Pillai double PrefetchBandwidth1; 3696dda4fb85SAurabindo Pillai double PrefetchBandwidth2; 3697dda4fb85SAurabindo Pillai double PrefetchBandwidth3; 3698dda4fb85SAurabindo Pillai double PrefetchBandwidth4; 3699dda4fb85SAurabindo Pillai 3700*efcc9706SRodrigo Siqueira if (Tpre_rounded - *Tno_bw > 0) { 3701dda4fb85SAurabindo Pillai PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte 3702dda4fb85SAurabindo Pillai + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor 3703*efcc9706SRodrigo Siqueira + prefetch_sw_bytes) / (Tpre_rounded - *Tno_bw); 3704*efcc9706SRodrigo Siqueira Tsw_est1 = prefetch_sw_bytes / PrefetchBandwidth1; 3705dda4fb85SAurabindo Pillai } else 3706dda4fb85SAurabindo Pillai PrefetchBandwidth1 = 0; 3707dda4fb85SAurabindo Pillai 3708*efcc9706SRodrigo Siqueira if (VStartup == MaxVStartup && (Tsw_est1 / LineTime < min_Lsw) 3709*efcc9706SRodrigo Siqueira && Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - *Tno_bw > 0) { 3710dda4fb85SAurabindo Pillai PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte 3711dda4fb85SAurabindo Pillai + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) 3712*efcc9706SRodrigo Siqueira / (Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - *Tno_bw); 3713dda4fb85SAurabindo Pillai } 3714dda4fb85SAurabindo Pillai 3715*efcc9706SRodrigo Siqueira if (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded > 0) 3716*efcc9706SRodrigo Siqueira PrefetchBandwidth2 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + prefetch_sw_bytes) / 3717*efcc9706SRodrigo Siqueira (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded); 3718dda4fb85SAurabindo Pillai else 3719dda4fb85SAurabindo Pillai PrefetchBandwidth2 = 0; 3720dda4fb85SAurabindo Pillai 3721*efcc9706SRodrigo Siqueira if (Tpre_rounded - Tvm_trips_rounded > 0) { 3722dda4fb85SAurabindo Pillai PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor 3723*efcc9706SRodrigo Siqueira + prefetch_sw_bytes) / (Tpre_rounded - Tvm_trips_rounded); 3724*efcc9706SRodrigo Siqueira Tsw_est3 = prefetch_sw_bytes / PrefetchBandwidth3; 3725dda4fb85SAurabindo Pillai } else 3726dda4fb85SAurabindo Pillai PrefetchBandwidth3 = 0; 3727dda4fb85SAurabindo Pillai 3728dda4fb85SAurabindo Pillai 3729dda4fb85SAurabindo Pillai if (VStartup == MaxVStartup && 3730*efcc9706SRodrigo Siqueira (Tsw_est3 / LineTime < min_Lsw) && Tpre_rounded - min_Lsw * LineTime - 0.75 * 3731*efcc9706SRodrigo Siqueira LineTime - Tvm_trips_rounded > 0) { 3732dda4fb85SAurabindo Pillai PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor) 3733*efcc9706SRodrigo Siqueira / (Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - Tvm_trips_rounded); 3734dda4fb85SAurabindo Pillai } 3735dda4fb85SAurabindo Pillai 3736*efcc9706SRodrigo Siqueira if (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded > 0) { 3737*efcc9706SRodrigo Siqueira PrefetchBandwidth4 = prefetch_sw_bytes / 3738*efcc9706SRodrigo Siqueira (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded); 3739dda4fb85SAurabindo Pillai } else { 3740dda4fb85SAurabindo Pillai PrefetchBandwidth4 = 0; 3741dda4fb85SAurabindo Pillai } 3742dda4fb85SAurabindo Pillai 3743dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3744*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tpre_rounded: %f\n", __func__, Tpre_rounded); 3745dda4fb85SAurabindo Pillai dml_print("DML::%s: Tno_bw: %f\n", __func__, *Tno_bw); 3746*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_trips_rounded: %f\n", __func__, Tvm_trips_rounded); 3747*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tsw_est1: %f\n", __func__, Tsw_est1); 3748*efcc9706SRodrigo Siqueira dml_print("DML::%s: Tsw_est3: %f\n", __func__, Tsw_est3); 3749dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth1: %f\n", __func__, PrefetchBandwidth1); 3750dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth2: %f\n", __func__, PrefetchBandwidth2); 3751dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth3: %f\n", __func__, PrefetchBandwidth3); 3752dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth4: %f\n", __func__, PrefetchBandwidth4); 3753dda4fb85SAurabindo Pillai #endif 3754dda4fb85SAurabindo Pillai { 3755dda4fb85SAurabindo Pillai bool Case1OK; 3756dda4fb85SAurabindo Pillai bool Case2OK; 3757dda4fb85SAurabindo Pillai bool Case3OK; 3758dda4fb85SAurabindo Pillai 3759dda4fb85SAurabindo Pillai if (PrefetchBandwidth1 > 0) { 3760dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth1 3761*efcc9706SRodrigo Siqueira >= Tvm_trips_rounded 3762dda4fb85SAurabindo Pillai && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) 3763*efcc9706SRodrigo Siqueira / PrefetchBandwidth1 >= Tr0_trips_rounded) { 3764dda4fb85SAurabindo Pillai Case1OK = true; 3765dda4fb85SAurabindo Pillai } else { 3766dda4fb85SAurabindo Pillai Case1OK = false; 3767dda4fb85SAurabindo Pillai } 3768dda4fb85SAurabindo Pillai } else { 3769dda4fb85SAurabindo Pillai Case1OK = false; 3770dda4fb85SAurabindo Pillai } 3771dda4fb85SAurabindo Pillai 3772dda4fb85SAurabindo Pillai if (PrefetchBandwidth2 > 0) { 3773dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth2 3774*efcc9706SRodrigo Siqueira >= Tvm_trips_rounded 3775dda4fb85SAurabindo Pillai && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) 3776*efcc9706SRodrigo Siqueira / PrefetchBandwidth2 < Tr0_trips_rounded) { 3777dda4fb85SAurabindo Pillai Case2OK = true; 3778dda4fb85SAurabindo Pillai } else { 3779dda4fb85SAurabindo Pillai Case2OK = false; 3780dda4fb85SAurabindo Pillai } 3781dda4fb85SAurabindo Pillai } else { 3782dda4fb85SAurabindo Pillai Case2OK = false; 3783dda4fb85SAurabindo Pillai } 3784dda4fb85SAurabindo Pillai 3785dda4fb85SAurabindo Pillai if (PrefetchBandwidth3 > 0) { 3786dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth3 < 3787*efcc9706SRodrigo Siqueira Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow * 3788dda4fb85SAurabindo Pillai HostVMInefficiencyFactor) / PrefetchBandwidth3 >= 3789*efcc9706SRodrigo Siqueira Tr0_trips_rounded) { 3790dda4fb85SAurabindo Pillai Case3OK = true; 3791dda4fb85SAurabindo Pillai } else { 3792dda4fb85SAurabindo Pillai Case3OK = false; 3793dda4fb85SAurabindo Pillai } 3794dda4fb85SAurabindo Pillai } else { 3795dda4fb85SAurabindo Pillai Case3OK = false; 3796dda4fb85SAurabindo Pillai } 3797dda4fb85SAurabindo Pillai 3798dda4fb85SAurabindo Pillai if (Case1OK) 3799*efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth1; 3800dda4fb85SAurabindo Pillai else if (Case2OK) 3801*efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth2; 3802dda4fb85SAurabindo Pillai else if (Case3OK) 3803*efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth3; 3804dda4fb85SAurabindo Pillai else 3805*efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth4; 3806dda4fb85SAurabindo Pillai 3807dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3808dda4fb85SAurabindo Pillai dml_print("DML::%s: Case1OK: %d\n", __func__, Case1OK); 3809dda4fb85SAurabindo Pillai dml_print("DML::%s: Case2OK: %d\n", __func__, Case2OK); 3810dda4fb85SAurabindo Pillai dml_print("DML::%s: Case3OK: %d\n", __func__, Case3OK); 3811*efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_bw_equ: %f\n", __func__, prefetch_bw_equ); 3812dda4fb85SAurabindo Pillai #endif 3813dda4fb85SAurabindo Pillai 3814*efcc9706SRodrigo Siqueira if (prefetch_bw_equ > 0) { 3815dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 3816*efcc9706SRodrigo Siqueira Tvm_equ = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame * 3817*efcc9706SRodrigo Siqueira HostVMInefficiencyFactor / prefetch_bw_equ, 3818*efcc9706SRodrigo Siqueira Tvm_trips, LineTime / 4); 3819dda4fb85SAurabindo Pillai } else { 3820*efcc9706SRodrigo Siqueira Tvm_equ = LineTime / 4; 3821dda4fb85SAurabindo Pillai } 3822dda4fb85SAurabindo Pillai 3823dda4fb85SAurabindo Pillai if ((GPUVMEnable == true || myPipe->DCCEnable == true)) { 3824*efcc9706SRodrigo Siqueira Tr0_equ = dml_max4((MetaRowByte + PixelPTEBytesPerRow * 3825*efcc9706SRodrigo Siqueira HostVMInefficiencyFactor) / prefetch_bw_equ, Tr0_trips, 3826*efcc9706SRodrigo Siqueira (LineTime - Tvm_equ) / 2, LineTime / 4); 3827dda4fb85SAurabindo Pillai } else { 3828*efcc9706SRodrigo Siqueira Tr0_equ = (LineTime - Tvm_equ) / 2; 3829dda4fb85SAurabindo Pillai } 3830dda4fb85SAurabindo Pillai } else { 3831*efcc9706SRodrigo Siqueira Tvm_equ = 0; 3832*efcc9706SRodrigo Siqueira Tr0_equ = 0; 3833dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3834dda4fb85SAurabindo Pillai dml_print("DML: prefetch_bw_equ equals 0! %s:%d\n", __FILE__, __LINE__); 3835dda4fb85SAurabindo Pillai #endif 3836dda4fb85SAurabindo Pillai } 3837dda4fb85SAurabindo Pillai } 3838dda4fb85SAurabindo Pillai 3839*efcc9706SRodrigo Siqueira if (dst_y_prefetch_oto < dst_y_prefetch_equ) { 3840*efcc9706SRodrigo Siqueira *DestinationLinesForPrefetch = dst_y_prefetch_oto; 3841*efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = Tvm_oto; 3842*efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = Tr0_oto; 3843*efcc9706SRodrigo Siqueira *PrefetchBandwidth = prefetch_bw_oto; 3844dda4fb85SAurabindo Pillai } else { 3845*efcc9706SRodrigo Siqueira *DestinationLinesForPrefetch = dst_y_prefetch_equ; 3846*efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = Tvm_equ; 3847*efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = Tr0_equ; 3848*efcc9706SRodrigo Siqueira *PrefetchBandwidth = prefetch_bw_equ; 3849dda4fb85SAurabindo Pillai } 3850dda4fb85SAurabindo Pillai 3851*efcc9706SRodrigo Siqueira *DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * TimeForFetchingMetaPTE / LineTime, 1.0) / 4.0; 3852dda4fb85SAurabindo Pillai 3853dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank = 3854*efcc9706SRodrigo Siqueira dml_ceil(4.0 * TimeForFetchingRowInVBlank / LineTime, 1.0) / 4.0; 3855dda4fb85SAurabindo Pillai 3856*efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData = *DestinationLinesForPrefetch - 3857dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank - 2 * *DestinationLinesToRequestRowInVBlank; 3858dda4fb85SAurabindo Pillai 3859dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3860dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesForPrefetch = %f\n", __func__, *DestinationLinesForPrefetch); 3861dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", 3862dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank); 3863*efcc9706SRodrigo Siqueira dml_print("DML::%s: TimeForFetchingRowInVBlank = %f\n", __func__, TimeForFetchingRowInVBlank); 3864*efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime); 3865dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", 3866dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank); 3867dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY); 3868*efcc9706SRodrigo Siqueira dml_print("DML::%s: LinesToRequestPrefetchPixelData = %f\n", __func__, LinesToRequestPrefetchPixelData); 3869dda4fb85SAurabindo Pillai #endif 3870dda4fb85SAurabindo Pillai 3871*efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData >= 1 && prefetch_bw_equ > 0) { 3872*efcc9706SRodrigo Siqueira *VRatioPrefetchY = (double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData; 3873dda4fb85SAurabindo Pillai *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); 3874dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3875dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *VRatioPrefetchY); 3876dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeightY = %d\n", __func__, SwathHeightY); 3877dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFillY = %d\n", __func__, VInitPreFillY); 3878dda4fb85SAurabindo Pillai #endif 3879dda4fb85SAurabindo Pillai if ((SwathHeightY > 4) && (VInitPreFillY > 3)) { 3880*efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) { 3881dda4fb85SAurabindo Pillai *VRatioPrefetchY = 3882dda4fb85SAurabindo Pillai dml_max((double) PrefetchSourceLinesY / 3883*efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData, 3884dda4fb85SAurabindo Pillai (double) MaxNumSwathY * SwathHeightY / 3885*efcc9706SRodrigo Siqueira (LinesToRequestPrefetchPixelData - 3886dda4fb85SAurabindo Pillai (VInitPreFillY - 3.0) / 2.0)); 3887dda4fb85SAurabindo Pillai *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); 3888dda4fb85SAurabindo Pillai } else { 3889dda4fb85SAurabindo Pillai MyError = true; 3890dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0; 3891dda4fb85SAurabindo Pillai } 3892dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3893dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *VRatioPrefetchY); 3894dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY); 3895dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwathY = %d\n", __func__, MaxNumSwathY); 3896dda4fb85SAurabindo Pillai #endif 3897dda4fb85SAurabindo Pillai } 3898dda4fb85SAurabindo Pillai 3899*efcc9706SRodrigo Siqueira *VRatioPrefetchC = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData; 3900dda4fb85SAurabindo Pillai *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); 3901dda4fb85SAurabindo Pillai 3902dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3903dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *VRatioPrefetchC); 3904dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeightC = %d\n", __func__, SwathHeightC); 3905dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFillC = %d\n", __func__, VInitPreFillC); 3906dda4fb85SAurabindo Pillai #endif 3907dda4fb85SAurabindo Pillai if ((SwathHeightC > 4)) { 3908*efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) { 3909dda4fb85SAurabindo Pillai *VRatioPrefetchC = 3910dda4fb85SAurabindo Pillai dml_max(*VRatioPrefetchC, 3911dda4fb85SAurabindo Pillai (double) MaxNumSwathC * SwathHeightC / 3912*efcc9706SRodrigo Siqueira (LinesToRequestPrefetchPixelData - 3913dda4fb85SAurabindo Pillai (VInitPreFillC - 3.0) / 2.0)); 3914dda4fb85SAurabindo Pillai *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); 3915dda4fb85SAurabindo Pillai } else { 3916dda4fb85SAurabindo Pillai MyError = true; 3917dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0; 3918dda4fb85SAurabindo Pillai } 3919dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3920dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *VRatioPrefetchC); 3921dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, PrefetchSourceLinesC); 3922dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwathC = %d\n", __func__, MaxNumSwathC); 3923dda4fb85SAurabindo Pillai #endif 3924dda4fb85SAurabindo Pillai } 3925dda4fb85SAurabindo Pillai 3926dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = (double) PrefetchSourceLinesY 3927*efcc9706SRodrigo Siqueira / LinesToRequestPrefetchPixelData * myPipe->BytePerPixelY * swath_width_luma_ub 3928*efcc9706SRodrigo Siqueira / LineTime; 3929dda4fb85SAurabindo Pillai 3930dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3931dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, myPipe->BytePerPixelY); 3932dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_luma_ub = %d\n", __func__, swath_width_luma_ub); 3933*efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime); 3934dda4fb85SAurabindo Pillai dml_print("DML::%s: RequiredPrefetchPixDataBWLuma = %f\n", 3935dda4fb85SAurabindo Pillai __func__, *RequiredPrefetchPixDataBWLuma); 3936dda4fb85SAurabindo Pillai #endif 3937dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = (double) PrefetchSourceLinesC / 3938*efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData 3939dda4fb85SAurabindo Pillai * myPipe->BytePerPixelC 3940*efcc9706SRodrigo Siqueira * swath_width_chroma_ub / LineTime; 3941dda4fb85SAurabindo Pillai } else { 3942dda4fb85SAurabindo Pillai MyError = true; 3943dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3944dda4fb85SAurabindo Pillai dml_print("DML:%s: MyErr set. LinesToRequestPrefetchPixelData: %f, should be > 0\n", 3945*efcc9706SRodrigo Siqueira __func__, LinesToRequestPrefetchPixelData); 3946dda4fb85SAurabindo Pillai #endif 3947dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0; 3948dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0; 3949dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0; 3950dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = 0; 3951dda4fb85SAurabindo Pillai } 3952dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3953dda4fb85SAurabindo Pillai dml_print("DML: Tpre: %fus - sum of time to request meta pte, 2 x data pte + meta data, swaths\n", 3954*efcc9706SRodrigo Siqueira (double)LinesToRequestPrefetchPixelData * LineTime + 3955*efcc9706SRodrigo Siqueira 2.0*TimeForFetchingRowInVBlank + TimeForFetchingMetaPTE); 3956*efcc9706SRodrigo Siqueira dml_print("DML: Tvm: %fus - time to fetch page tables for meta surface\n", TimeForFetchingMetaPTE); 3957dda4fb85SAurabindo Pillai dml_print("DML: To: %fus - time for propagation from scaler to optc\n", 3958*efcc9706SRodrigo Siqueira (*DSTYAfterScaler + ((double) (*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime); 3959dda4fb85SAurabindo Pillai dml_print("DML: Tvstartup - TSetup - Tcalc - Twait - Tpre - To > 0\n"); 3960*efcc9706SRodrigo Siqueira dml_print("DML: Tslack(pre): %fus - time left over in schedule\n", VStartup * LineTime - 3961*efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE - 2*TimeForFetchingRowInVBlank - (*DSTYAfterScaler + 3962*efcc9706SRodrigo Siqueira ((double) (*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime - TWait - TCalc - *TSetup); 3963dda4fb85SAurabindo Pillai dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %d\n", 3964dda4fb85SAurabindo Pillai PixelPTEBytesPerRow); 3965dda4fb85SAurabindo Pillai #endif 3966dda4fb85SAurabindo Pillai } else { 3967dda4fb85SAurabindo Pillai MyError = true; 3968dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3969dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set, dst_y_prefetch_equ = %f (should be > 1)\n", 3970*efcc9706SRodrigo Siqueira __func__, dst_y_prefetch_equ); 3971dda4fb85SAurabindo Pillai #endif 3972dda4fb85SAurabindo Pillai } 3973dda4fb85SAurabindo Pillai 3974dda4fb85SAurabindo Pillai { 3975dda4fb85SAurabindo Pillai double prefetch_vm_bw; 3976dda4fb85SAurabindo Pillai double prefetch_row_bw; 3977dda4fb85SAurabindo Pillai 3978dda4fb85SAurabindo Pillai if (PDEAndMetaPTEBytesFrame == 0) { 3979dda4fb85SAurabindo Pillai prefetch_vm_bw = 0; 3980dda4fb85SAurabindo Pillai } else if (*DestinationLinesToRequestVMInVBlank > 0) { 3981dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3982dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame); 3983dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor); 3984dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n", 3985dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank); 3986*efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime); 3987dda4fb85SAurabindo Pillai #endif 3988dda4fb85SAurabindo Pillai prefetch_vm_bw = PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / 3989*efcc9706SRodrigo Siqueira (*DestinationLinesToRequestVMInVBlank * LineTime); 3990dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3991dda4fb85SAurabindo Pillai dml_print("DML::%s: prefetch_vm_bw = %f\n", __func__, prefetch_vm_bw); 3992dda4fb85SAurabindo Pillai #endif 3993dda4fb85SAurabindo Pillai } else { 3994dda4fb85SAurabindo Pillai prefetch_vm_bw = 0; 3995dda4fb85SAurabindo Pillai MyError = true; 3996dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 3997dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set. DestinationLinesToRequestVMInVBlank=%f (should be > 0)\n", 3998dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank); 3999dda4fb85SAurabindo Pillai #endif 4000dda4fb85SAurabindo Pillai } 4001dda4fb85SAurabindo Pillai 4002dda4fb85SAurabindo Pillai if (MetaRowByte + PixelPTEBytesPerRow == 0) { 4003dda4fb85SAurabindo Pillai prefetch_row_bw = 0; 4004dda4fb85SAurabindo Pillai } else if (*DestinationLinesToRequestRowInVBlank > 0) { 4005dda4fb85SAurabindo Pillai prefetch_row_bw = (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / 4006*efcc9706SRodrigo Siqueira (*DestinationLinesToRequestRowInVBlank * LineTime); 4007dda4fb85SAurabindo Pillai 4008dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4009dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaRowByte = %d\n", __func__, MetaRowByte); 4010dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, PixelPTEBytesPerRow); 4011dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n", 4012dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank); 4013dda4fb85SAurabindo Pillai dml_print("DML::%s: prefetch_row_bw = %f\n", __func__, prefetch_row_bw); 4014dda4fb85SAurabindo Pillai #endif 4015dda4fb85SAurabindo Pillai } else { 4016dda4fb85SAurabindo Pillai prefetch_row_bw = 0; 4017dda4fb85SAurabindo Pillai MyError = true; 4018dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4019dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set. DestinationLinesToRequestRowInVBlank=%f (should be > 0)\n", 4020dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank); 4021dda4fb85SAurabindo Pillai #endif 4022dda4fb85SAurabindo Pillai } 4023dda4fb85SAurabindo Pillai 4024dda4fb85SAurabindo Pillai *prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw); 4025dda4fb85SAurabindo Pillai } 4026dda4fb85SAurabindo Pillai 4027dda4fb85SAurabindo Pillai if (MyError) { 4028dda4fb85SAurabindo Pillai *PrefetchBandwidth = 0; 4029*efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = 0; 4030*efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = 0; 4031dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank = 0; 4032dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank = 0; 4033dda4fb85SAurabindo Pillai *DestinationLinesForPrefetch = 0; 4034*efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData = 0; 4035dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0; 4036dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0; 4037dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0; 4038dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = 0; 4039dda4fb85SAurabindo Pillai } 4040dda4fb85SAurabindo Pillai 4041dda4fb85SAurabindo Pillai return MyError; 4042dda4fb85SAurabindo Pillai } // CalculatePrefetchSchedule 4043dda4fb85SAurabindo Pillai 4044dda4fb85SAurabindo Pillai void dml32_CalculateFlipSchedule( 4045dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor, 4046dda4fb85SAurabindo Pillai double UrgentExtraLatency, 4047dda4fb85SAurabindo Pillai double UrgentLatency, 4048dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels, 4049dda4fb85SAurabindo Pillai bool HostVMEnable, 4050dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels, 4051dda4fb85SAurabindo Pillai bool GPUVMEnable, 4052dda4fb85SAurabindo Pillai double HostVMMinPageSize, 4053dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesPerFrame, 4054dda4fb85SAurabindo Pillai double MetaRowBytes, 4055dda4fb85SAurabindo Pillai double DPTEBytesPerRow, 4056dda4fb85SAurabindo Pillai double BandwidthAvailableForImmediateFlip, 4057dda4fb85SAurabindo Pillai unsigned int TotImmediateFlipBytes, 4058dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 4059dda4fb85SAurabindo Pillai double LineTime, 4060dda4fb85SAurabindo Pillai double VRatio, 4061dda4fb85SAurabindo Pillai double VRatioChroma, 4062dda4fb85SAurabindo Pillai double Tno_bw, 4063dda4fb85SAurabindo Pillai bool DCCEnable, 4064dda4fb85SAurabindo Pillai unsigned int dpte_row_height, 4065dda4fb85SAurabindo Pillai unsigned int meta_row_height, 4066dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma, 4067dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma, 4068dda4fb85SAurabindo Pillai bool use_one_row_for_frame_flip, 4069dda4fb85SAurabindo Pillai 4070dda4fb85SAurabindo Pillai /* Output */ 4071dda4fb85SAurabindo Pillai double *DestinationLinesToRequestVMInImmediateFlip, 4072dda4fb85SAurabindo Pillai double *DestinationLinesToRequestRowInImmediateFlip, 4073dda4fb85SAurabindo Pillai double *final_flip_bw, 4074dda4fb85SAurabindo Pillai bool *ImmediateFlipSupportedForPipe) 4075dda4fb85SAurabindo Pillai { 4076dda4fb85SAurabindo Pillai double min_row_time = 0.0; 4077dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevelsTrips; 4078dda4fb85SAurabindo Pillai double TimeForFetchingMetaPTEImmediateFlip; 4079dda4fb85SAurabindo Pillai double TimeForFetchingRowInVBlankImmediateFlip; 4080dda4fb85SAurabindo Pillai double ImmediateFlipBW; 4081dda4fb85SAurabindo Pillai 4082dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) 4083dda4fb85SAurabindo Pillai HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels; 4084dda4fb85SAurabindo Pillai else 4085dda4fb85SAurabindo Pillai HostVMDynamicLevelsTrips = 0; 4086dda4fb85SAurabindo Pillai 4087dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4088dda4fb85SAurabindo Pillai dml_print("DML::%s: TotImmediateFlipBytes = %d\n", __func__, TotImmediateFlipBytes); 4089dda4fb85SAurabindo Pillai dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip); 4090dda4fb85SAurabindo Pillai #endif 4091dda4fb85SAurabindo Pillai 4092dda4fb85SAurabindo Pillai if (TotImmediateFlipBytes > 0) { 4093dda4fb85SAurabindo Pillai if (use_one_row_for_frame_flip) { 4094dda4fb85SAurabindo Pillai ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + 2 * DPTEBytesPerRow) * 4095dda4fb85SAurabindo Pillai BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes; 4096dda4fb85SAurabindo Pillai } else { 4097dda4fb85SAurabindo Pillai ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) * 4098dda4fb85SAurabindo Pillai BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes; 4099dda4fb85SAurabindo Pillai } 4100dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 4101dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame * 4102dda4fb85SAurabindo Pillai HostVMInefficiencyFactor / ImmediateFlipBW, 4103dda4fb85SAurabindo Pillai UrgentExtraLatency + UrgentLatency * 4104dda4fb85SAurabindo Pillai (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1), 4105dda4fb85SAurabindo Pillai LineTime / 4.0); 4106dda4fb85SAurabindo Pillai } else { 4107dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = 0; 4108dda4fb85SAurabindo Pillai } 4109dda4fb85SAurabindo Pillai if ((GPUVMEnable == true || DCCEnable == true)) { 4110dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = dml_max3( 4111dda4fb85SAurabindo Pillai (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW, 4112dda4fb85SAurabindo Pillai UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4.0); 4113dda4fb85SAurabindo Pillai } else { 4114dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = 0; 4115dda4fb85SAurabindo Pillai } 4116dda4fb85SAurabindo Pillai 4117dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInImmediateFlip = 4118dda4fb85SAurabindo Pillai dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1.0) / 4.0; 4119dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInImmediateFlip = 4120dda4fb85SAurabindo Pillai dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1.0) / 4.0; 4121dda4fb85SAurabindo Pillai 4122dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 4123dda4fb85SAurabindo Pillai *final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor / 4124dda4fb85SAurabindo Pillai (*DestinationLinesToRequestVMInImmediateFlip * LineTime), 4125dda4fb85SAurabindo Pillai (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / 4126dda4fb85SAurabindo Pillai (*DestinationLinesToRequestRowInImmediateFlip * LineTime)); 4127dda4fb85SAurabindo Pillai } else if ((GPUVMEnable == true || DCCEnable == true)) { 4128dda4fb85SAurabindo Pillai *final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / 4129dda4fb85SAurabindo Pillai (*DestinationLinesToRequestRowInImmediateFlip * LineTime); 4130dda4fb85SAurabindo Pillai } else { 4131dda4fb85SAurabindo Pillai *final_flip_bw = 0; 4132dda4fb85SAurabindo Pillai } 4133dda4fb85SAurabindo Pillai } else { 4134dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = 0; 4135dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = 0; 4136dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInImmediateFlip = 0; 4137dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInImmediateFlip = 0; 4138dda4fb85SAurabindo Pillai *final_flip_bw = 0; 4139dda4fb85SAurabindo Pillai } 4140dda4fb85SAurabindo Pillai 4141dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_rgbe_alpha) { 4142dda4fb85SAurabindo Pillai if (GPUVMEnable == true && DCCEnable != true) { 4143dda4fb85SAurabindo Pillai min_row_time = dml_min(dpte_row_height * 4144dda4fb85SAurabindo Pillai LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma); 4145dda4fb85SAurabindo Pillai } else if (GPUVMEnable != true && DCCEnable == true) { 4146dda4fb85SAurabindo Pillai min_row_time = dml_min(meta_row_height * 4147dda4fb85SAurabindo Pillai LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma); 4148dda4fb85SAurabindo Pillai } else { 4149dda4fb85SAurabindo Pillai min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height * 4150dda4fb85SAurabindo Pillai LineTime / VRatio, dpte_row_height_chroma * LineTime / 4151dda4fb85SAurabindo Pillai VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma); 4152dda4fb85SAurabindo Pillai } 4153dda4fb85SAurabindo Pillai } else { 4154dda4fb85SAurabindo Pillai if (GPUVMEnable == true && DCCEnable != true) { 4155dda4fb85SAurabindo Pillai min_row_time = dpte_row_height * LineTime / VRatio; 4156dda4fb85SAurabindo Pillai } else if (GPUVMEnable != true && DCCEnable == true) { 4157dda4fb85SAurabindo Pillai min_row_time = meta_row_height * LineTime / VRatio; 4158dda4fb85SAurabindo Pillai } else { 4159dda4fb85SAurabindo Pillai min_row_time = 4160dda4fb85SAurabindo Pillai dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio); 4161dda4fb85SAurabindo Pillai } 4162dda4fb85SAurabindo Pillai } 4163dda4fb85SAurabindo Pillai 4164dda4fb85SAurabindo Pillai if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16 4165dda4fb85SAurabindo Pillai || TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip 4166dda4fb85SAurabindo Pillai > min_row_time) { 4167dda4fb85SAurabindo Pillai *ImmediateFlipSupportedForPipe = false; 4168dda4fb85SAurabindo Pillai } else { 4169dda4fb85SAurabindo Pillai *ImmediateFlipSupportedForPipe = true; 4170dda4fb85SAurabindo Pillai } 4171dda4fb85SAurabindo Pillai 4172dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4173dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable); 4174dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, DCCEnable); 4175dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInImmediateFlip = %f\n", 4176dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInImmediateFlip); 4177dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInImmediateFlip = %f\n", 4178dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInImmediateFlip); 4179dda4fb85SAurabindo Pillai dml_print("DML::%s: TimeForFetchingMetaPTEImmediateFlip = %f\n", __func__, TimeForFetchingMetaPTEImmediateFlip); 4180dda4fb85SAurabindo Pillai dml_print("DML::%s: TimeForFetchingRowInVBlankImmediateFlip = %f\n", 4181dda4fb85SAurabindo Pillai __func__, TimeForFetchingRowInVBlankImmediateFlip); 4182dda4fb85SAurabindo Pillai dml_print("DML::%s: min_row_time = %f\n", __func__, min_row_time); 4183dda4fb85SAurabindo Pillai dml_print("DML::%s: ImmediateFlipSupportedForPipe = %d\n", __func__, *ImmediateFlipSupportedForPipe); 4184dda4fb85SAurabindo Pillai #endif 4185dda4fb85SAurabindo Pillai } // CalculateFlipSchedule 4186dda4fb85SAurabindo Pillai 4187dda4fb85SAurabindo Pillai void dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport( 41883c3abac6SAlex Deucher struct dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport *st_vars, 4189dda4fb85SAurabindo Pillai bool USRRetrainingRequiredFinal, 4190dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 4191dda4fb85SAurabindo Pillai unsigned int PrefetchMode, 4192dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 4193dda4fb85SAurabindo Pillai unsigned int MaxLineBufferLines, 4194dda4fb85SAurabindo Pillai unsigned int LineBufferSize, 4195dda4fb85SAurabindo Pillai unsigned int WritebackInterfaceBufferSize, 4196dda4fb85SAurabindo Pillai double DCFCLK, 4197dda4fb85SAurabindo Pillai double ReturnBW, 4198dda4fb85SAurabindo Pillai bool SynchronizeTimingsFinal, 4199dda4fb85SAurabindo Pillai bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal, 4200dda4fb85SAurabindo Pillai bool DRRDisplay[], 4201dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 4202dda4fb85SAurabindo Pillai unsigned int meta_row_height[], 4203dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma[], 4204dda4fb85SAurabindo Pillai SOCParametersList mmSOCParameters, 4205dda4fb85SAurabindo Pillai unsigned int WritebackChunkSize, 4206dda4fb85SAurabindo Pillai double SOCCLK, 4207dda4fb85SAurabindo Pillai double DCFClkDeepSleep, 4208dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[], 4209dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC[], 4210dda4fb85SAurabindo Pillai unsigned int SwathHeightY[], 4211dda4fb85SAurabindo Pillai unsigned int SwathHeightC[], 4212dda4fb85SAurabindo Pillai unsigned int LBBitPerPixel[], 4213dda4fb85SAurabindo Pillai double SwathWidthY[], 4214dda4fb85SAurabindo Pillai double SwathWidthC[], 4215dda4fb85SAurabindo Pillai double HRatio[], 4216dda4fb85SAurabindo Pillai double HRatioChroma[], 4217dda4fb85SAurabindo Pillai unsigned int VTaps[], 4218dda4fb85SAurabindo Pillai unsigned int VTapsChroma[], 4219dda4fb85SAurabindo Pillai double VRatio[], 4220dda4fb85SAurabindo Pillai double VRatioChroma[], 4221dda4fb85SAurabindo Pillai unsigned int HTotal[], 4222dda4fb85SAurabindo Pillai unsigned int VTotal[], 4223dda4fb85SAurabindo Pillai unsigned int VActive[], 4224dda4fb85SAurabindo Pillai double PixelClock[], 4225dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[], 4226dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 4227dda4fb85SAurabindo Pillai double BytePerPixelDETY[], 4228dda4fb85SAurabindo Pillai double BytePerPixelDETC[], 4229dda4fb85SAurabindo Pillai double DSTXAfterScaler[], 4230dda4fb85SAurabindo Pillai double DSTYAfterScaler[], 4231dda4fb85SAurabindo Pillai bool WritebackEnable[], 4232dda4fb85SAurabindo Pillai enum source_format_class WritebackPixelFormat[], 4233dda4fb85SAurabindo Pillai double WritebackDestinationWidth[], 4234dda4fb85SAurabindo Pillai double WritebackDestinationHeight[], 4235dda4fb85SAurabindo Pillai double WritebackSourceHeight[], 4236dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled, 4237dda4fb85SAurabindo Pillai unsigned int CompressedBufferSizeInkByte, 4238dda4fb85SAurabindo Pillai 4239dda4fb85SAurabindo Pillai /* Output */ 4240dda4fb85SAurabindo Pillai Watermarks *Watermark, 4241dda4fb85SAurabindo Pillai enum clock_change_support *DRAMClockChangeSupport, 4242dda4fb85SAurabindo Pillai double MaxActiveDRAMClockChangeLatencySupported[], 4243dda4fb85SAurabindo Pillai unsigned int SubViewportLinesNeededInMALL[], 4244dda4fb85SAurabindo Pillai enum dm_fclock_change_support *FCLKChangeSupport, 4245dda4fb85SAurabindo Pillai double *MinActiveFCLKChangeLatencySupported, 4246dda4fb85SAurabindo Pillai bool *USRRetrainingSupport, 4247dda4fb85SAurabindo Pillai double ActiveDRAMClockChangeLatencyMargin[]) 4248dda4fb85SAurabindo Pillai { 4249dda4fb85SAurabindo Pillai unsigned int i, j, k; 4250dda4fb85SAurabindo Pillai 42513c3abac6SAlex Deucher st_vars->SurfaceWithMinActiveFCLKChangeMargin = 0; 42523c3abac6SAlex Deucher st_vars->DRAMClockChangeSupportNumber = 0; 42533c3abac6SAlex Deucher st_vars->DRAMClockChangeMethod = 0; 42543c3abac6SAlex Deucher st_vars->FoundFirstSurfaceWithMinActiveFCLKChangeMargin = false; 42553c3abac6SAlex Deucher st_vars->MinActiveFCLKChangeMargin = 0.; 42563c3abac6SAlex Deucher st_vars->SecondMinActiveFCLKChangeMarginOneDisplayInVBLank = 0.; 42573c3abac6SAlex Deucher st_vars->TotalPixelBW = 0.0; 42583c3abac6SAlex Deucher st_vars->TotalActiveWriteback = 0; 4259dda4fb85SAurabindo Pillai 4260dda4fb85SAurabindo Pillai Watermark->UrgentWatermark = mmSOCParameters.UrgentLatency + mmSOCParameters.ExtraLatency; 4261dda4fb85SAurabindo Pillai Watermark->USRRetrainingWatermark = mmSOCParameters.UrgentLatency + mmSOCParameters.ExtraLatency 4262dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency + mmSOCParameters.SMNLatency; 4263dda4fb85SAurabindo Pillai Watermark->DRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency + Watermark->UrgentWatermark; 4264dda4fb85SAurabindo Pillai Watermark->FCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency + Watermark->UrgentWatermark; 4265dda4fb85SAurabindo Pillai Watermark->StutterExitWatermark = mmSOCParameters.SRExitTime + mmSOCParameters.ExtraLatency 4266dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep; 4267dda4fb85SAurabindo Pillai Watermark->StutterEnterPlusExitWatermark = mmSOCParameters.SREnterPlusExitTime + mmSOCParameters.ExtraLatency 4268dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep; 4269dda4fb85SAurabindo Pillai Watermark->Z8StutterExitWatermark = mmSOCParameters.SRExitZ8Time + mmSOCParameters.ExtraLatency 4270dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep; 4271dda4fb85SAurabindo Pillai Watermark->Z8StutterEnterPlusExitWatermark = mmSOCParameters.SREnterPlusExitZ8Time 4272dda4fb85SAurabindo Pillai + mmSOCParameters.ExtraLatency + 10 / DCFClkDeepSleep; 4273dda4fb85SAurabindo Pillai 4274dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4275dda4fb85SAurabindo Pillai dml_print("DML::%s: UrgentLatency = %f\n", __func__, mmSOCParameters.UrgentLatency); 4276dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatency = %f\n", __func__, mmSOCParameters.ExtraLatency); 4277dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMClockChangeLatency = %f\n", __func__, mmSOCParameters.DRAMClockChangeLatency); 4278dda4fb85SAurabindo Pillai dml_print("DML::%s: UrgentWatermark = %f\n", __func__, Watermark->UrgentWatermark); 4279dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingWatermark = %f\n", __func__, Watermark->USRRetrainingWatermark); 4280dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMClockChangeWatermark = %f\n", __func__, Watermark->DRAMClockChangeWatermark); 4281dda4fb85SAurabindo Pillai dml_print("DML::%s: FCLKChangeWatermark = %f\n", __func__, Watermark->FCLKChangeWatermark); 4282dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterExitWatermark = %f\n", __func__, Watermark->StutterExitWatermark); 4283dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEnterPlusExitWatermark = %f\n", __func__, Watermark->StutterEnterPlusExitWatermark); 4284dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterExitWatermark = %f\n", __func__, Watermark->Z8StutterExitWatermark); 4285dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", 4286dda4fb85SAurabindo Pillai __func__, Watermark->Z8StutterEnterPlusExitWatermark); 4287dda4fb85SAurabindo Pillai #endif 4288dda4fb85SAurabindo Pillai 4289dda4fb85SAurabindo Pillai 42903c3abac6SAlex Deucher st_vars->TotalActiveWriteback = 0; 4291dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4292dda4fb85SAurabindo Pillai if (WritebackEnable[k] == true) 42933c3abac6SAlex Deucher st_vars->TotalActiveWriteback = st_vars->TotalActiveWriteback + 1; 4294dda4fb85SAurabindo Pillai } 4295dda4fb85SAurabindo Pillai 42963c3abac6SAlex Deucher if (st_vars->TotalActiveWriteback <= 1) { 4297dda4fb85SAurabindo Pillai Watermark->WritebackUrgentWatermark = mmSOCParameters.WritebackLatency; 4298dda4fb85SAurabindo Pillai } else { 4299dda4fb85SAurabindo Pillai Watermark->WritebackUrgentWatermark = mmSOCParameters.WritebackLatency 4300dda4fb85SAurabindo Pillai + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK; 4301dda4fb85SAurabindo Pillai } 4302dda4fb85SAurabindo Pillai if (USRRetrainingRequiredFinal) 4303dda4fb85SAurabindo Pillai Watermark->WritebackUrgentWatermark = Watermark->WritebackUrgentWatermark 4304dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency; 4305dda4fb85SAurabindo Pillai 43063c3abac6SAlex Deucher if (st_vars->TotalActiveWriteback <= 1) { 4307dda4fb85SAurabindo Pillai Watermark->WritebackDRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency 4308dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency; 4309dda4fb85SAurabindo Pillai Watermark->WritebackFCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency 4310dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency; 4311dda4fb85SAurabindo Pillai } else { 4312dda4fb85SAurabindo Pillai Watermark->WritebackDRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency 4313dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency + WritebackChunkSize * 1024.0 / 32.0 / SOCCLK; 4314dda4fb85SAurabindo Pillai Watermark->WritebackFCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency 4315dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency + WritebackChunkSize * 1024 / 32 / SOCCLK; 4316dda4fb85SAurabindo Pillai } 4317dda4fb85SAurabindo Pillai 4318dda4fb85SAurabindo Pillai if (USRRetrainingRequiredFinal) 4319dda4fb85SAurabindo Pillai Watermark->WritebackDRAMClockChangeWatermark = Watermark->WritebackDRAMClockChangeWatermark 4320dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency; 4321dda4fb85SAurabindo Pillai 4322dda4fb85SAurabindo Pillai if (USRRetrainingRequiredFinal) 4323dda4fb85SAurabindo Pillai Watermark->WritebackFCLKChangeWatermark = Watermark->WritebackFCLKChangeWatermark 4324dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency; 4325dda4fb85SAurabindo Pillai 4326dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4327dda4fb85SAurabindo Pillai dml_print("DML::%s: WritebackDRAMClockChangeWatermark = %f\n", 4328dda4fb85SAurabindo Pillai __func__, Watermark->WritebackDRAMClockChangeWatermark); 4329dda4fb85SAurabindo Pillai dml_print("DML::%s: WritebackFCLKChangeWatermark = %f\n", __func__, Watermark->WritebackFCLKChangeWatermark); 4330dda4fb85SAurabindo Pillai dml_print("DML::%s: WritebackUrgentWatermark = %f\n", __func__, Watermark->WritebackUrgentWatermark); 4331dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingRequiredFinal = %d\n", __func__, USRRetrainingRequiredFinal); 4332dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingLatency = %f\n", __func__, mmSOCParameters.USRRetrainingLatency); 4333dda4fb85SAurabindo Pillai #endif 4334dda4fb85SAurabindo Pillai 4335dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 43363c3abac6SAlex Deucher st_vars->TotalPixelBW = st_vars->TotalPixelBW + DPPPerSurface[k] * (SwathWidthY[k] * BytePerPixelDETY[k] * VRatio[k] + 4337dda4fb85SAurabindo Pillai SwathWidthC[k] * BytePerPixelDETC[k] * VRatioChroma[k]) / (HTotal[k] / PixelClock[k]); 4338dda4fb85SAurabindo Pillai } 4339dda4fb85SAurabindo Pillai 4340dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4341dda4fb85SAurabindo Pillai 43423c3abac6SAlex Deucher st_vars->LBLatencyHidingSourceLinesY[k] = dml_min((double) MaxLineBufferLines, dml_floor(LineBufferSize / LBBitPerPixel[k] / (SwathWidthY[k] / dml_max(HRatio[k], 1.0)), 1)) - (VTaps[k] - 1); 43433c3abac6SAlex Deucher st_vars->LBLatencyHidingSourceLinesC[k] = dml_min((double) MaxLineBufferLines, dml_floor(LineBufferSize / LBBitPerPixel[k] / (SwathWidthC[k] / dml_max(HRatioChroma[k], 1.0)), 1)) - (VTapsChroma[k] - 1); 4344dda4fb85SAurabindo Pillai 4345dda4fb85SAurabindo Pillai 4346dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4347dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, MaxLineBufferLines = %d\n", __func__, k, MaxLineBufferLines); 4348dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, LineBufferSize = %d\n", __func__, k, LineBufferSize); 4349dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, LBBitPerPixel = %d\n", __func__, k, LBBitPerPixel[k]); 4350dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, HRatio = %f\n", __func__, k, HRatio[k]); 4351dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, VTaps = %d\n", __func__, k, VTaps[k]); 4352dda4fb85SAurabindo Pillai #endif 4353dda4fb85SAurabindo Pillai 43543c3abac6SAlex Deucher st_vars->EffectiveLBLatencyHidingY = st_vars->LBLatencyHidingSourceLinesY[k] / VRatio[k] * (HTotal[k] / PixelClock[k]); 43553c3abac6SAlex Deucher st_vars->EffectiveLBLatencyHidingC = st_vars->LBLatencyHidingSourceLinesC[k] / VRatioChroma[k] * (HTotal[k] / PixelClock[k]); 43563c3abac6SAlex Deucher st_vars->EffectiveDETBufferSizeY = DETBufferSizeY[k]; 4357dda4fb85SAurabindo Pillai 4358dda4fb85SAurabindo Pillai if (UnboundedRequestEnabled) { 43593c3abac6SAlex Deucher st_vars->EffectiveDETBufferSizeY = st_vars->EffectiveDETBufferSizeY 4360dda4fb85SAurabindo Pillai + CompressedBufferSizeInkByte * 1024 4361dda4fb85SAurabindo Pillai * (SwathWidthY[k] * BytePerPixelDETY[k] * VRatio[k]) 43623c3abac6SAlex Deucher / (HTotal[k] / PixelClock[k]) / st_vars->TotalPixelBW; 4363dda4fb85SAurabindo Pillai } 4364dda4fb85SAurabindo Pillai 43653c3abac6SAlex Deucher st_vars->LinesInDETY[k] = (double) st_vars->EffectiveDETBufferSizeY / BytePerPixelDETY[k] / SwathWidthY[k]; 43663c3abac6SAlex Deucher st_vars->LinesInDETYRoundedDownToSwath[k] = dml_floor(st_vars->LinesInDETY[k], SwathHeightY[k]); 43673c3abac6SAlex Deucher st_vars->FullDETBufferingTimeY = st_vars->LinesInDETYRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) / VRatio[k]; 4368dda4fb85SAurabindo Pillai 43693c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHidingY = st_vars->EffectiveLBLatencyHidingY + st_vars->FullDETBufferingTimeY 4370dda4fb85SAurabindo Pillai - (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) * HTotal[k] / PixelClock[k]; 4371dda4fb85SAurabindo Pillai 4372dda4fb85SAurabindo Pillai if (NumberOfActiveSurfaces > 1) { 43733c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHidingY = st_vars->ActiveClockChangeLatencyHidingY 4374dda4fb85SAurabindo Pillai - (1 - 1 / NumberOfActiveSurfaces) * SwathHeightY[k] * HTotal[k] 4375dda4fb85SAurabindo Pillai / PixelClock[k] / VRatio[k]; 4376dda4fb85SAurabindo Pillai } 4377dda4fb85SAurabindo Pillai 4378dda4fb85SAurabindo Pillai if (BytePerPixelDETC[k] > 0) { 43793c3abac6SAlex Deucher st_vars->LinesInDETC[k] = DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k]; 43803c3abac6SAlex Deucher st_vars->LinesInDETCRoundedDownToSwath[k] = dml_floor(st_vars->LinesInDETC[k], SwathHeightC[k]); 43813c3abac6SAlex Deucher st_vars->FullDETBufferingTimeC = st_vars->LinesInDETCRoundedDownToSwath[k] * (HTotal[k] / PixelClock[k]) 4382dda4fb85SAurabindo Pillai / VRatioChroma[k]; 43833c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHidingC = st_vars->EffectiveLBLatencyHidingC + st_vars->FullDETBufferingTimeC 4384dda4fb85SAurabindo Pillai - (DSTXAfterScaler[k] / HTotal[k] + DSTYAfterScaler[k]) * HTotal[k] 4385dda4fb85SAurabindo Pillai / PixelClock[k]; 4386dda4fb85SAurabindo Pillai if (NumberOfActiveSurfaces > 1) { 43873c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHidingC = st_vars->ActiveClockChangeLatencyHidingC 4388dda4fb85SAurabindo Pillai - (1 - 1 / NumberOfActiveSurfaces) * SwathHeightC[k] * HTotal[k] 4389dda4fb85SAurabindo Pillai / PixelClock[k] / VRatioChroma[k]; 4390dda4fb85SAurabindo Pillai } 43913c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHiding = dml_min(st_vars->ActiveClockChangeLatencyHidingY, 43923c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHidingC); 4393dda4fb85SAurabindo Pillai } else { 43943c3abac6SAlex Deucher st_vars->ActiveClockChangeLatencyHiding = st_vars->ActiveClockChangeLatencyHidingY; 4395dda4fb85SAurabindo Pillai } 4396dda4fb85SAurabindo Pillai 43973c3abac6SAlex Deucher ActiveDRAMClockChangeLatencyMargin[k] = st_vars->ActiveClockChangeLatencyHiding - Watermark->UrgentWatermark 4398dda4fb85SAurabindo Pillai - Watermark->DRAMClockChangeWatermark; 43993c3abac6SAlex Deucher st_vars->ActiveFCLKChangeLatencyMargin[k] = st_vars->ActiveClockChangeLatencyHiding - Watermark->UrgentWatermark 4400dda4fb85SAurabindo Pillai - Watermark->FCLKChangeWatermark; 44013c3abac6SAlex Deucher st_vars->USRRetrainingLatencyMargin[k] = st_vars->ActiveClockChangeLatencyHiding - Watermark->USRRetrainingWatermark; 4402dda4fb85SAurabindo Pillai 4403dda4fb85SAurabindo Pillai if (WritebackEnable[k]) { 44043c3abac6SAlex Deucher st_vars->WritebackLatencyHiding = WritebackInterfaceBufferSize * 1024 4405dda4fb85SAurabindo Pillai / (WritebackDestinationWidth[k] * WritebackDestinationHeight[k] 4406dda4fb85SAurabindo Pillai / (WritebackSourceHeight[k] * HTotal[k] / PixelClock[k]) * 4); 4407dda4fb85SAurabindo Pillai if (WritebackPixelFormat[k] == dm_444_64) 44083c3abac6SAlex Deucher st_vars->WritebackLatencyHiding = st_vars->WritebackLatencyHiding / 2; 4409dda4fb85SAurabindo Pillai 44103c3abac6SAlex Deucher st_vars->WritebackDRAMClockChangeLatencyMargin = st_vars->WritebackLatencyHiding 4411dda4fb85SAurabindo Pillai - Watermark->WritebackDRAMClockChangeWatermark; 4412dda4fb85SAurabindo Pillai 44133c3abac6SAlex Deucher st_vars->WritebackFCLKChangeLatencyMargin = st_vars->WritebackLatencyHiding 4414dda4fb85SAurabindo Pillai - Watermark->WritebackFCLKChangeWatermark; 4415dda4fb85SAurabindo Pillai 4416dda4fb85SAurabindo Pillai ActiveDRAMClockChangeLatencyMargin[k] = dml_min(ActiveDRAMClockChangeLatencyMargin[k], 44173c3abac6SAlex Deucher st_vars->WritebackFCLKChangeLatencyMargin); 44183c3abac6SAlex Deucher st_vars->ActiveFCLKChangeLatencyMargin[k] = dml_min(st_vars->ActiveFCLKChangeLatencyMargin[k], 44193c3abac6SAlex Deucher st_vars->WritebackDRAMClockChangeLatencyMargin); 4420dda4fb85SAurabindo Pillai } 4421dda4fb85SAurabindo Pillai MaxActiveDRAMClockChangeLatencySupported[k] = 4422dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) ? 4423dda4fb85SAurabindo Pillai 0 : 4424dda4fb85SAurabindo Pillai (ActiveDRAMClockChangeLatencyMargin[k] 4425dda4fb85SAurabindo Pillai + mmSOCParameters.DRAMClockChangeLatency); 4426dda4fb85SAurabindo Pillai } 4427dda4fb85SAurabindo Pillai 4428dda4fb85SAurabindo Pillai for (i = 0; i < NumberOfActiveSurfaces; ++i) { 4429dda4fb85SAurabindo Pillai for (j = 0; j < NumberOfActiveSurfaces; ++j) { 4430dda4fb85SAurabindo Pillai if (i == j || 4431dda4fb85SAurabindo Pillai (BlendingAndTiming[i] == i && BlendingAndTiming[j] == i) || 4432dda4fb85SAurabindo Pillai (BlendingAndTiming[j] == j && BlendingAndTiming[i] == j) || 4433dda4fb85SAurabindo Pillai (BlendingAndTiming[i] == BlendingAndTiming[j] && BlendingAndTiming[i] != i) || 4434dda4fb85SAurabindo Pillai (SynchronizeTimingsFinal && PixelClock[i] == PixelClock[j] && 4435dda4fb85SAurabindo Pillai HTotal[i] == HTotal[j] && VTotal[i] == VTotal[j] && 4436dda4fb85SAurabindo Pillai VActive[i] == VActive[j]) || (SynchronizeDRRDisplaysForUCLKPStateChangeFinal && 4437dda4fb85SAurabindo Pillai (DRRDisplay[i] || DRRDisplay[j]))) { 44383c3abac6SAlex Deucher st_vars->SynchronizedSurfaces[i][j] = true; 4439dda4fb85SAurabindo Pillai } else { 44403c3abac6SAlex Deucher st_vars->SynchronizedSurfaces[i][j] = false; 4441dda4fb85SAurabindo Pillai } 4442dda4fb85SAurabindo Pillai } 4443dda4fb85SAurabindo Pillai } 4444dda4fb85SAurabindo Pillai 4445dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4446dda4fb85SAurabindo Pillai if ((UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) && 44473c3abac6SAlex Deucher (!st_vars->FoundFirstSurfaceWithMinActiveFCLKChangeMargin || 44483c3abac6SAlex Deucher st_vars->ActiveFCLKChangeLatencyMargin[k] < st_vars->MinActiveFCLKChangeMargin)) { 44493c3abac6SAlex Deucher st_vars->FoundFirstSurfaceWithMinActiveFCLKChangeMargin = true; 44503c3abac6SAlex Deucher st_vars->MinActiveFCLKChangeMargin = st_vars->ActiveFCLKChangeLatencyMargin[k]; 44513c3abac6SAlex Deucher st_vars->SurfaceWithMinActiveFCLKChangeMargin = k; 4452dda4fb85SAurabindo Pillai } 4453dda4fb85SAurabindo Pillai } 4454dda4fb85SAurabindo Pillai 44553c3abac6SAlex Deucher *MinActiveFCLKChangeLatencySupported = st_vars->MinActiveFCLKChangeMargin + mmSOCParameters.FCLKChangeLatency; 4456dda4fb85SAurabindo Pillai 44573c3abac6SAlex Deucher st_vars->SameTimingForFCLKChange = true; 4458dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 44593c3abac6SAlex Deucher if (!st_vars->SynchronizedSurfaces[k][st_vars->SurfaceWithMinActiveFCLKChangeMargin]) { 4460dda4fb85SAurabindo Pillai if ((UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) && 44613c3abac6SAlex Deucher (st_vars->SameTimingForFCLKChange || 44623c3abac6SAlex Deucher st_vars->ActiveFCLKChangeLatencyMargin[k] < 44633c3abac6SAlex Deucher st_vars->SecondMinActiveFCLKChangeMarginOneDisplayInVBLank)) { 44643c3abac6SAlex Deucher st_vars->SecondMinActiveFCLKChangeMarginOneDisplayInVBLank = st_vars->ActiveFCLKChangeLatencyMargin[k]; 4465dda4fb85SAurabindo Pillai } 44663c3abac6SAlex Deucher st_vars->SameTimingForFCLKChange = false; 4467dda4fb85SAurabindo Pillai } 4468dda4fb85SAurabindo Pillai } 4469dda4fb85SAurabindo Pillai 44703c3abac6SAlex Deucher if (st_vars->MinActiveFCLKChangeMargin > 0) { 4471dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_vactive; 44723c3abac6SAlex Deucher } else if ((st_vars->SameTimingForFCLKChange || st_vars->SecondMinActiveFCLKChangeMarginOneDisplayInVBLank > 0) && 4473dda4fb85SAurabindo Pillai (PrefetchMode <= 1)) { 4474dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_vblank; 4475dda4fb85SAurabindo Pillai } else { 4476dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_unsupported; 4477dda4fb85SAurabindo Pillai } 4478dda4fb85SAurabindo Pillai 4479dda4fb85SAurabindo Pillai *USRRetrainingSupport = true; 4480dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4481dda4fb85SAurabindo Pillai if ((UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) && 44823c3abac6SAlex Deucher (st_vars->USRRetrainingLatencyMargin[k] < 0)) { 4483dda4fb85SAurabindo Pillai *USRRetrainingSupport = false; 4484dda4fb85SAurabindo Pillai } 4485dda4fb85SAurabindo Pillai } 4486dda4fb85SAurabindo Pillai 4487dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4488dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_full_frame && 4489dda4fb85SAurabindo Pillai UseMALLForPStateChange[k] != dm_use_mall_pstate_change_sub_viewport && 4490dda4fb85SAurabindo Pillai UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe && 4491dda4fb85SAurabindo Pillai ActiveDRAMClockChangeLatencyMargin[k] < 0) { 4492dda4fb85SAurabindo Pillai if (PrefetchMode > 0) { 44933c3abac6SAlex Deucher st_vars->DRAMClockChangeSupportNumber = 2; 44943c3abac6SAlex Deucher } else if (st_vars->DRAMClockChangeSupportNumber == 0) { 44953c3abac6SAlex Deucher st_vars->DRAMClockChangeSupportNumber = 1; 44963c3abac6SAlex Deucher st_vars->LastSurfaceWithoutMargin = k; 44973c3abac6SAlex Deucher } else if (st_vars->DRAMClockChangeSupportNumber == 1 && 44983c3abac6SAlex Deucher !st_vars->SynchronizedSurfaces[st_vars->LastSurfaceWithoutMargin][k]) { 44993c3abac6SAlex Deucher st_vars->DRAMClockChangeSupportNumber = 2; 4500dda4fb85SAurabindo Pillai } 4501dda4fb85SAurabindo Pillai } 4502dda4fb85SAurabindo Pillai } 4503dda4fb85SAurabindo Pillai 4504dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4505dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame) 45063c3abac6SAlex Deucher st_vars->DRAMClockChangeMethod = 1; 4507dda4fb85SAurabindo Pillai else if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport) 45083c3abac6SAlex Deucher st_vars->DRAMClockChangeMethod = 2; 4509dda4fb85SAurabindo Pillai } 4510dda4fb85SAurabindo Pillai 45113c3abac6SAlex Deucher if (st_vars->DRAMClockChangeMethod == 0) { 45123c3abac6SAlex Deucher if (st_vars->DRAMClockChangeSupportNumber == 0) 4513dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive; 45143c3abac6SAlex Deucher else if (st_vars->DRAMClockChangeSupportNumber == 1) 4515dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank; 4516dda4fb85SAurabindo Pillai else 4517dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported; 45183c3abac6SAlex Deucher } else if (st_vars->DRAMClockChangeMethod == 1) { 45193c3abac6SAlex Deucher if (st_vars->DRAMClockChangeSupportNumber == 0) 4520dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive_w_mall_full_frame; 45213c3abac6SAlex Deucher else if (st_vars->DRAMClockChangeSupportNumber == 1) 4522dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank_w_mall_full_frame; 4523dda4fb85SAurabindo Pillai else 4524dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported; 4525dda4fb85SAurabindo Pillai } else { 45263c3abac6SAlex Deucher if (st_vars->DRAMClockChangeSupportNumber == 0) 4527dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive_w_mall_sub_vp; 45283c3abac6SAlex Deucher else if (st_vars->DRAMClockChangeSupportNumber == 1) 4529dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank_w_mall_sub_vp; 4530dda4fb85SAurabindo Pillai else 4531dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported; 4532dda4fb85SAurabindo Pillai } 4533dda4fb85SAurabindo Pillai 4534dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4535dda4fb85SAurabindo Pillai unsigned int dst_y_pstate; 4536dda4fb85SAurabindo Pillai unsigned int src_y_pstate_l; 4537dda4fb85SAurabindo Pillai unsigned int src_y_pstate_c; 4538dda4fb85SAurabindo Pillai unsigned int src_y_ahead_l, src_y_ahead_c, sub_vp_lines_l, sub_vp_lines_c; 4539dda4fb85SAurabindo Pillai 4540dda4fb85SAurabindo Pillai dst_y_pstate = dml_ceil((mmSOCParameters.DRAMClockChangeLatency + mmSOCParameters.UrgentLatency) / (HTotal[k] / PixelClock[k]), 1); 4541dda4fb85SAurabindo Pillai src_y_pstate_l = dml_ceil(dst_y_pstate * VRatio[k], SwathHeightY[k]); 45423c3abac6SAlex Deucher src_y_ahead_l = dml_floor(DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k], SwathHeightY[k]) + st_vars->LBLatencyHidingSourceLinesY[k]; 4543dda4fb85SAurabindo Pillai sub_vp_lines_l = src_y_pstate_l + src_y_ahead_l + meta_row_height[k]; 4544dda4fb85SAurabindo Pillai 4545dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4546dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]); 4547dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, BytePerPixelDETY = %f\n", __func__, k, BytePerPixelDETY[k]); 4548dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SwathWidthY = %d\n", __func__, k, SwathWidthY[k]); 4549dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SwathHeightY = %d\n", __func__, k, SwathHeightY[k]); 45503c3abac6SAlex Deucher dml_print("DML::%s: k=%d, LBLatencyHidingSourceLinesY = %d\n", __func__, k, st_vars->LBLatencyHidingSourceLinesY[k]); 4551dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dst_y_pstate = %d\n", __func__, k, dst_y_pstate); 4552dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_pstate_l = %d\n", __func__, k, src_y_pstate_l); 4553dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_ahead_l = %d\n", __func__, k, src_y_ahead_l); 4554dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, meta_row_height = %d\n", __func__, k, meta_row_height[k]); 4555dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, sub_vp_lines_l = %d\n", __func__, k, sub_vp_lines_l); 4556dda4fb85SAurabindo Pillai #endif 4557dda4fb85SAurabindo Pillai SubViewportLinesNeededInMALL[k] = sub_vp_lines_l; 4558dda4fb85SAurabindo Pillai 4559dda4fb85SAurabindo Pillai if (BytePerPixelDETC[k] > 0) { 4560dda4fb85SAurabindo Pillai src_y_pstate_c = dml_ceil(dst_y_pstate * VRatioChroma[k], SwathHeightC[k]); 45613c3abac6SAlex Deucher src_y_ahead_c = dml_floor(DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k], SwathHeightC[k]) + st_vars->LBLatencyHidingSourceLinesC[k]; 4562dda4fb85SAurabindo Pillai sub_vp_lines_c = src_y_pstate_c + src_y_ahead_c + meta_row_height_chroma[k]; 4563dda4fb85SAurabindo Pillai SubViewportLinesNeededInMALL[k] = dml_max(sub_vp_lines_l, sub_vp_lines_c); 4564dda4fb85SAurabindo Pillai 4565dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4566dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_pstate_c = %d\n", __func__, k, src_y_pstate_c); 4567dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_ahead_c = %d\n", __func__, k, src_y_ahead_c); 4568dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, meta_row_height_chroma = %d\n", __func__, k, meta_row_height_chroma[k]); 4569dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, sub_vp_lines_c = %d\n", __func__, k, sub_vp_lines_c); 4570dda4fb85SAurabindo Pillai #endif 4571dda4fb85SAurabindo Pillai } 4572dda4fb85SAurabindo Pillai } 4573dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4574dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMClockChangeSupport = %d\n", __func__, *DRAMClockChangeSupport); 4575dda4fb85SAurabindo Pillai dml_print("DML::%s: FCLKChangeSupport = %d\n", __func__, *FCLKChangeSupport); 4576dda4fb85SAurabindo Pillai dml_print("DML::%s: MinActiveFCLKChangeLatencySupported = %f\n", 4577dda4fb85SAurabindo Pillai __func__, *MinActiveFCLKChangeLatencySupported); 4578dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingSupport = %d\n", __func__, *USRRetrainingSupport); 4579dda4fb85SAurabindo Pillai #endif 4580dda4fb85SAurabindo Pillai } // CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport 4581dda4fb85SAurabindo Pillai 4582dda4fb85SAurabindo Pillai double dml32_CalculateWriteBackDISPCLK( 4583dda4fb85SAurabindo Pillai enum source_format_class WritebackPixelFormat, 4584dda4fb85SAurabindo Pillai double PixelClock, 4585dda4fb85SAurabindo Pillai double WritebackHRatio, 4586dda4fb85SAurabindo Pillai double WritebackVRatio, 4587dda4fb85SAurabindo Pillai unsigned int WritebackHTaps, 4588dda4fb85SAurabindo Pillai unsigned int WritebackVTaps, 4589dda4fb85SAurabindo Pillai unsigned int WritebackSourceWidth, 4590dda4fb85SAurabindo Pillai unsigned int WritebackDestinationWidth, 4591dda4fb85SAurabindo Pillai unsigned int HTotal, 4592dda4fb85SAurabindo Pillai unsigned int WritebackLineBufferSize, 4593dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed) 4594dda4fb85SAurabindo Pillai { 4595dda4fb85SAurabindo Pillai double DISPCLK_H, DISPCLK_V, DISPCLK_HB; 4596dda4fb85SAurabindo Pillai 4597dda4fb85SAurabindo Pillai DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio; 4598dda4fb85SAurabindo Pillai DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / HTotal; 4599dda4fb85SAurabindo Pillai DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth * 4600dda4fb85SAurabindo Pillai WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / WritebackSourceWidth; 4601dda4fb85SAurabindo Pillai return dml32_RoundToDFSGranularity(dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB), 1, DISPCLKDPPCLKVCOSpeed); 4602dda4fb85SAurabindo Pillai } 4603dda4fb85SAurabindo Pillai 4604dda4fb85SAurabindo Pillai void dml32_CalculateMinAndMaxPrefetchMode( 4605dda4fb85SAurabindo Pillai enum dm_prefetch_modes AllowForPStateChangeOrStutterInVBlankFinal, 4606dda4fb85SAurabindo Pillai unsigned int *MinPrefetchMode, 4607dda4fb85SAurabindo Pillai unsigned int *MaxPrefetchMode) 4608dda4fb85SAurabindo Pillai { 4609dda4fb85SAurabindo Pillai if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_none) { 4610dda4fb85SAurabindo Pillai *MinPrefetchMode = 3; 4611dda4fb85SAurabindo Pillai *MaxPrefetchMode = 3; 4612dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_stutter) { 4613dda4fb85SAurabindo Pillai *MinPrefetchMode = 2; 4614dda4fb85SAurabindo Pillai *MaxPrefetchMode = 2; 4615dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_fclk_and_stutter) { 4616dda4fb85SAurabindo Pillai *MinPrefetchMode = 1; 4617dda4fb85SAurabindo Pillai *MaxPrefetchMode = 1; 4618dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_uclk_fclk_and_stutter) { 4619dda4fb85SAurabindo Pillai *MinPrefetchMode = 0; 4620dda4fb85SAurabindo Pillai *MaxPrefetchMode = 0; 4621dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == 4622dda4fb85SAurabindo Pillai dm_prefetch_support_uclk_fclk_and_stutter_if_possible) { 4623dda4fb85SAurabindo Pillai *MinPrefetchMode = 0; 4624dda4fb85SAurabindo Pillai *MaxPrefetchMode = 3; 4625dda4fb85SAurabindo Pillai } else { 4626dda4fb85SAurabindo Pillai *MinPrefetchMode = 0; 4627dda4fb85SAurabindo Pillai *MaxPrefetchMode = 3; 4628dda4fb85SAurabindo Pillai } 4629dda4fb85SAurabindo Pillai } // CalculateMinAndMaxPrefetchMode 4630dda4fb85SAurabindo Pillai 4631dda4fb85SAurabindo Pillai void dml32_CalculatePixelDeliveryTimes( 4632dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 4633dda4fb85SAurabindo Pillai double VRatio[], 4634dda4fb85SAurabindo Pillai double VRatioChroma[], 4635dda4fb85SAurabindo Pillai double VRatioPrefetchY[], 4636dda4fb85SAurabindo Pillai double VRatioPrefetchC[], 4637dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[], 4638dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[], 4639dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 4640dda4fb85SAurabindo Pillai double HRatio[], 4641dda4fb85SAurabindo Pillai double HRatioChroma[], 4642dda4fb85SAurabindo Pillai double PixelClock[], 4643dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT[], 4644dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT_CHROMA[], 4645dda4fb85SAurabindo Pillai double Dppclk[], 4646dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[], 4647dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[], 4648dda4fb85SAurabindo Pillai unsigned int NumberOfCursors[], 4649dda4fb85SAurabindo Pillai unsigned int CursorWidth[][DC__NUM_CURSOR__MAX], 4650dda4fb85SAurabindo Pillai unsigned int CursorBPP[][DC__NUM_CURSOR__MAX], 4651dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesY[], 4652dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesY[], 4653dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesC[], 4654dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesC[], 4655dda4fb85SAurabindo Pillai 4656dda4fb85SAurabindo Pillai /* Output */ 4657dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLuma[], 4658dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChroma[], 4659dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLumaPrefetch[], 4660dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChromaPrefetch[], 4661dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeLuma[], 4662dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeChroma[], 4663dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeLumaPrefetch[], 4664dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeChromaPrefetch[], 4665dda4fb85SAurabindo Pillai double CursorRequestDeliveryTime[], 4666dda4fb85SAurabindo Pillai double CursorRequestDeliveryTimePrefetch[]) 4667dda4fb85SAurabindo Pillai { 4668dda4fb85SAurabindo Pillai double req_per_swath_ub; 4669dda4fb85SAurabindo Pillai unsigned int k; 4670dda4fb85SAurabindo Pillai 4671dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4672dda4fb85SAurabindo Pillai 4673dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4674dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : HRatio = %f\n", __func__, k, HRatio[k]); 4675dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : VRatio = %f\n", __func__, k, VRatio[k]); 4676dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : HRatioChroma = %f\n", __func__, k, HRatioChroma[k]); 4677dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : VRatioChroma = %f\n", __func__, k, VRatioChroma[k]); 4678dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : swath_width_luma_ub = %d\n", __func__, k, swath_width_luma_ub[k]); 4679dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : swath_width_chroma_ub = %d\n", __func__, k, swath_width_chroma_ub[k]); 4680dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PSCL_THROUGHPUT = %f\n", __func__, k, PSCL_THROUGHPUT[k]); 4681dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PSCL_THROUGHPUT_CHROMA = %f\n", __func__, k, PSCL_THROUGHPUT_CHROMA[k]); 4682dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]); 4683dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PixelClock = %f\n", __func__, k, PixelClock[k]); 4684dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : Dppclk = %f\n", __func__, k, Dppclk[k]); 4685dda4fb85SAurabindo Pillai #endif 4686dda4fb85SAurabindo Pillai 4687dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) { 4688dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma[k] = 4689dda4fb85SAurabindo Pillai swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k]; 4690dda4fb85SAurabindo Pillai } else { 4691dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k]; 4692dda4fb85SAurabindo Pillai } 4693dda4fb85SAurabindo Pillai 4694dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 4695dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] = 0; 4696dda4fb85SAurabindo Pillai } else { 4697dda4fb85SAurabindo Pillai if (VRatioChroma[k] <= 1) { 4698dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] = 4699dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k]; 4700dda4fb85SAurabindo Pillai } else { 4701dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] = 4702dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k]; 4703dda4fb85SAurabindo Pillai } 4704dda4fb85SAurabindo Pillai } 4705dda4fb85SAurabindo Pillai 4706dda4fb85SAurabindo Pillai if (VRatioPrefetchY[k] <= 1) { 4707dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] = 4708dda4fb85SAurabindo Pillai swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k]; 4709dda4fb85SAurabindo Pillai } else { 4710dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] = 4711dda4fb85SAurabindo Pillai swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k]; 4712dda4fb85SAurabindo Pillai } 4713dda4fb85SAurabindo Pillai 4714dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 4715dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0; 4716dda4fb85SAurabindo Pillai } else { 4717dda4fb85SAurabindo Pillai if (VRatioPrefetchC[k] <= 1) { 4718dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] * 4719dda4fb85SAurabindo Pillai DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k]; 4720dda4fb85SAurabindo Pillai } else { 4721dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 4722dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k]; 4723dda4fb85SAurabindo Pillai } 4724dda4fb85SAurabindo Pillai } 4725dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4726dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeLuma = %f\n", 4727dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeLuma[k]); 4728dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeLumaPrefetch = %f\n", 4729dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeLumaPrefetch[k]); 4730dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeChroma = %f\n", 4731dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeChroma[k]); 4732dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeChromaPrefetch = %f\n", 4733dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeChromaPrefetch[k]); 4734dda4fb85SAurabindo Pillai #endif 4735dda4fb85SAurabindo Pillai } 4736dda4fb85SAurabindo Pillai 4737dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4738dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) 4739dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k]; 4740dda4fb85SAurabindo Pillai else 4741dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k]; 4742dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4743dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : req_per_swath_ub = %f (Luma)\n", __func__, k, req_per_swath_ub); 4744dda4fb85SAurabindo Pillai #endif 4745dda4fb85SAurabindo Pillai 4746dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub; 4747dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeLumaPrefetch[k] = 4748dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub; 4749dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 4750dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChroma[k] = 0; 4751dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0; 4752dda4fb85SAurabindo Pillai } else { 4753dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) 4754dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k]; 4755dda4fb85SAurabindo Pillai else 4756dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k]; 4757dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4758dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : req_per_swath_ub = %f (Chroma)\n", __func__, k, req_per_swath_ub); 4759dda4fb85SAurabindo Pillai #endif 4760dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChroma[k] = 4761dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub; 4762dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 4763dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub; 4764dda4fb85SAurabindo Pillai } 4765dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4766dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeLuma = %f\n", 4767dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeLuma[k]); 4768dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeLumaPrefetch = %f\n", 4769dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeLumaPrefetch[k]); 4770dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeChroma = %f\n", 4771dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeChroma[k]); 4772dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeChromaPrefetch = %f\n", 4773dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeChromaPrefetch[k]); 4774dda4fb85SAurabindo Pillai #endif 4775dda4fb85SAurabindo Pillai } 4776dda4fb85SAurabindo Pillai 4777dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4778dda4fb85SAurabindo Pillai unsigned int cursor_req_per_width; 4779dda4fb85SAurabindo Pillai 4780dda4fb85SAurabindo Pillai cursor_req_per_width = dml_ceil((double) CursorWidth[k][0] * (double) CursorBPP[k][0] / 4781dda4fb85SAurabindo Pillai 256.0 / 8.0, 1.0); 4782dda4fb85SAurabindo Pillai if (NumberOfCursors[k] > 0) { 4783dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) { 4784dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = (double) CursorWidth[k][0] / 4785dda4fb85SAurabindo Pillai HRatio[k] / PixelClock[k] / cursor_req_per_width; 4786dda4fb85SAurabindo Pillai } else { 4787dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = (double) CursorWidth[k][0] / 4788dda4fb85SAurabindo Pillai PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width; 4789dda4fb85SAurabindo Pillai } 4790dda4fb85SAurabindo Pillai if (VRatioPrefetchY[k] <= 1) { 4791dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = (double) CursorWidth[k][0] / 4792dda4fb85SAurabindo Pillai HRatio[k] / PixelClock[k] / cursor_req_per_width; 4793dda4fb85SAurabindo Pillai } else { 4794dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = (double) CursorWidth[k][0] / 4795dda4fb85SAurabindo Pillai PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width; 4796dda4fb85SAurabindo Pillai } 4797dda4fb85SAurabindo Pillai } else { 4798dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = 0; 4799dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = 0; 4800dda4fb85SAurabindo Pillai } 4801dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4802dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : NumberOfCursors = %d\n", 4803dda4fb85SAurabindo Pillai __func__, k, NumberOfCursors[k]); 4804dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : CursorRequestDeliveryTime = %f\n", 4805dda4fb85SAurabindo Pillai __func__, k, CursorRequestDeliveryTime[k]); 4806dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : CursorRequestDeliveryTimePrefetch = %f\n", 4807dda4fb85SAurabindo Pillai __func__, k, CursorRequestDeliveryTimePrefetch[k]); 4808dda4fb85SAurabindo Pillai #endif 4809dda4fb85SAurabindo Pillai } 4810dda4fb85SAurabindo Pillai } // CalculatePixelDeliveryTimes 4811dda4fb85SAurabindo Pillai 4812dda4fb85SAurabindo Pillai void dml32_CalculateMetaAndPTETimes( 4813dda4fb85SAurabindo Pillai bool use_one_row_for_frame[], 4814dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 4815dda4fb85SAurabindo Pillai bool GPUVMEnable, 4816dda4fb85SAurabindo Pillai unsigned int MetaChunkSize, 4817dda4fb85SAurabindo Pillai unsigned int MinMetaChunkSizeBytes, 4818dda4fb85SAurabindo Pillai unsigned int HTotal[], 4819dda4fb85SAurabindo Pillai double VRatio[], 4820dda4fb85SAurabindo Pillai double VRatioChroma[], 4821dda4fb85SAurabindo Pillai double DestinationLinesToRequestRowInVBlank[], 4822dda4fb85SAurabindo Pillai double DestinationLinesToRequestRowInImmediateFlip[], 4823dda4fb85SAurabindo Pillai bool DCCEnable[], 4824dda4fb85SAurabindo Pillai double PixelClock[], 4825dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[], 4826dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[], 4827dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[], 4828dda4fb85SAurabindo Pillai unsigned int dpte_row_height[], 4829dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma[], 4830dda4fb85SAurabindo Pillai unsigned int meta_row_width[], 4831dda4fb85SAurabindo Pillai unsigned int meta_row_width_chroma[], 4832dda4fb85SAurabindo Pillai unsigned int meta_row_height[], 4833dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma[], 4834dda4fb85SAurabindo Pillai unsigned int meta_req_width[], 4835dda4fb85SAurabindo Pillai unsigned int meta_req_width_chroma[], 4836dda4fb85SAurabindo Pillai unsigned int meta_req_height[], 4837dda4fb85SAurabindo Pillai unsigned int meta_req_height_chroma[], 4838dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[], 4839dda4fb85SAurabindo Pillai unsigned int PTERequestSizeY[], 4840dda4fb85SAurabindo Pillai unsigned int PTERequestSizeC[], 4841dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthY[], 4842dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightY[], 4843dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthC[], 4844dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightC[], 4845dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[], 4846dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[], 4847dda4fb85SAurabindo Pillai 4848dda4fb85SAurabindo Pillai /* Output */ 4849dda4fb85SAurabindo Pillai double DST_Y_PER_PTE_ROW_NOM_L[], 4850dda4fb85SAurabindo Pillai double DST_Y_PER_PTE_ROW_NOM_C[], 4851dda4fb85SAurabindo Pillai double DST_Y_PER_META_ROW_NOM_L[], 4852dda4fb85SAurabindo Pillai double DST_Y_PER_META_ROW_NOM_C[], 4853dda4fb85SAurabindo Pillai double TimePerMetaChunkNominal[], 4854dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkNominal[], 4855dda4fb85SAurabindo Pillai double TimePerMetaChunkVBlank[], 4856dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkVBlank[], 4857dda4fb85SAurabindo Pillai double TimePerMetaChunkFlip[], 4858dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkFlip[], 4859dda4fb85SAurabindo Pillai double time_per_pte_group_nom_luma[], 4860dda4fb85SAurabindo Pillai double time_per_pte_group_vblank_luma[], 4861dda4fb85SAurabindo Pillai double time_per_pte_group_flip_luma[], 4862dda4fb85SAurabindo Pillai double time_per_pte_group_nom_chroma[], 4863dda4fb85SAurabindo Pillai double time_per_pte_group_vblank_chroma[], 4864dda4fb85SAurabindo Pillai double time_per_pte_group_flip_chroma[]) 4865dda4fb85SAurabindo Pillai { 4866dda4fb85SAurabindo Pillai unsigned int meta_chunk_width; 4867dda4fb85SAurabindo Pillai unsigned int min_meta_chunk_width; 4868dda4fb85SAurabindo Pillai unsigned int meta_chunk_per_row_int; 4869dda4fb85SAurabindo Pillai unsigned int meta_row_remainder; 4870dda4fb85SAurabindo Pillai unsigned int meta_chunk_threshold; 4871dda4fb85SAurabindo Pillai unsigned int meta_chunks_per_row_ub; 4872dda4fb85SAurabindo Pillai unsigned int meta_chunk_width_chroma; 4873dda4fb85SAurabindo Pillai unsigned int min_meta_chunk_width_chroma; 4874dda4fb85SAurabindo Pillai unsigned int meta_chunk_per_row_int_chroma; 4875dda4fb85SAurabindo Pillai unsigned int meta_row_remainder_chroma; 4876dda4fb85SAurabindo Pillai unsigned int meta_chunk_threshold_chroma; 4877dda4fb85SAurabindo Pillai unsigned int meta_chunks_per_row_ub_chroma; 4878dda4fb85SAurabindo Pillai unsigned int dpte_group_width_luma; 4879dda4fb85SAurabindo Pillai unsigned int dpte_groups_per_row_luma_ub; 4880dda4fb85SAurabindo Pillai unsigned int dpte_group_width_chroma; 4881dda4fb85SAurabindo Pillai unsigned int dpte_groups_per_row_chroma_ub; 4882dda4fb85SAurabindo Pillai unsigned int k; 4883dda4fb85SAurabindo Pillai 4884dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4885dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k]; 4886dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) 4887dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_C[k] = 0; 4888dda4fb85SAurabindo Pillai else 4889dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k]; 4890dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k]; 4891dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) 4892dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_C[k] = 0; 4893dda4fb85SAurabindo Pillai else 4894dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k]; 4895dda4fb85SAurabindo Pillai } 4896dda4fb85SAurabindo Pillai 4897dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4898dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) { 4899dda4fb85SAurabindo Pillai meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k]; 4900dda4fb85SAurabindo Pillai min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k]; 4901dda4fb85SAurabindo Pillai meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width; 4902dda4fb85SAurabindo Pillai meta_row_remainder = meta_row_width[k] % meta_chunk_width; 4903dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) 4904dda4fb85SAurabindo Pillai meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k]; 4905dda4fb85SAurabindo Pillai else 4906dda4fb85SAurabindo Pillai meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k]; 4907dda4fb85SAurabindo Pillai 4908dda4fb85SAurabindo Pillai if (meta_row_remainder <= meta_chunk_threshold) 4909dda4fb85SAurabindo Pillai meta_chunks_per_row_ub = meta_chunk_per_row_int + 1; 4910dda4fb85SAurabindo Pillai else 4911dda4fb85SAurabindo Pillai meta_chunks_per_row_ub = meta_chunk_per_row_int + 2; 4912dda4fb85SAurabindo Pillai 4913dda4fb85SAurabindo Pillai TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] * 4914dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub; 4915dda4fb85SAurabindo Pillai TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * 4916dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub; 4917dda4fb85SAurabindo Pillai TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * 4918dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub; 4919dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 4920dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = 0; 4921dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = 0; 4922dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = 0; 4923dda4fb85SAurabindo Pillai } else { 4924dda4fb85SAurabindo Pillai meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] / 4925dda4fb85SAurabindo Pillai meta_row_height_chroma[k]; 4926dda4fb85SAurabindo Pillai min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] / 4927dda4fb85SAurabindo Pillai meta_row_height_chroma[k]; 4928dda4fb85SAurabindo Pillai meta_chunk_per_row_int_chroma = (double) meta_row_width_chroma[k] / 4929dda4fb85SAurabindo Pillai meta_chunk_width_chroma; 4930dda4fb85SAurabindo Pillai meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma; 4931dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) { 4932dda4fb85SAurabindo Pillai meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - 4933dda4fb85SAurabindo Pillai meta_req_width_chroma[k]; 4934dda4fb85SAurabindo Pillai } else { 4935dda4fb85SAurabindo Pillai meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma - 4936dda4fb85SAurabindo Pillai meta_req_height_chroma[k]; 4937dda4fb85SAurabindo Pillai } 4938dda4fb85SAurabindo Pillai if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma) 4939dda4fb85SAurabindo Pillai meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1; 4940dda4fb85SAurabindo Pillai else 4941dda4fb85SAurabindo Pillai meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2; 4942dda4fb85SAurabindo Pillai 4943dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] * 4944dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma; 4945dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] * 4946dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma; 4947dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] * 4948dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma; 4949dda4fb85SAurabindo Pillai } 4950dda4fb85SAurabindo Pillai } else { 4951dda4fb85SAurabindo Pillai TimePerMetaChunkNominal[k] = 0; 4952dda4fb85SAurabindo Pillai TimePerMetaChunkVBlank[k] = 0; 4953dda4fb85SAurabindo Pillai TimePerMetaChunkFlip[k] = 0; 4954dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = 0; 4955dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = 0; 4956dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = 0; 4957dda4fb85SAurabindo Pillai } 4958dda4fb85SAurabindo Pillai } 4959dda4fb85SAurabindo Pillai 4960dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 4961dda4fb85SAurabindo Pillai if (GPUVMEnable == true) { 4962dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) { 4963dda4fb85SAurabindo Pillai dpte_group_width_luma = (double) dpte_group_bytes[k] / 4964dda4fb85SAurabindo Pillai (double) PTERequestSizeY[k] * PixelPTEReqWidthY[k]; 4965dda4fb85SAurabindo Pillai } else { 4966dda4fb85SAurabindo Pillai dpte_group_width_luma = (double) dpte_group_bytes[k] / 4967dda4fb85SAurabindo Pillai (double) PTERequestSizeY[k] * PixelPTEReqHeightY[k]; 4968dda4fb85SAurabindo Pillai } 4969dda4fb85SAurabindo Pillai 4970dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) { 4971dda4fb85SAurabindo Pillai dpte_groups_per_row_luma_ub = dml_ceil((double) dpte_row_width_luma_ub[k] / 4972dda4fb85SAurabindo Pillai (double) dpte_group_width_luma / 2.0, 1.0); 4973dda4fb85SAurabindo Pillai } else { 4974dda4fb85SAurabindo Pillai dpte_groups_per_row_luma_ub = dml_ceil((double) dpte_row_width_luma_ub[k] / 4975dda4fb85SAurabindo Pillai (double) dpte_group_width_luma, 1.0); 4976dda4fb85SAurabindo Pillai } 4977dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 4978dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, use_one_row_for_frame = %d\n", 4979dda4fb85SAurabindo Pillai __func__, k, use_one_row_for_frame[k]); 4980dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_bytes = %d\n", 4981dda4fb85SAurabindo Pillai __func__, k, dpte_group_bytes[k]); 4982dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PTERequestSizeY = %d\n", 4983dda4fb85SAurabindo Pillai __func__, k, PTERequestSizeY[k]); 4984dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelPTEReqWidthY = %d\n", 4985dda4fb85SAurabindo Pillai __func__, k, PixelPTEReqWidthY[k]); 4986dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelPTEReqHeightY = %d\n", 4987dda4fb85SAurabindo Pillai __func__, k, PixelPTEReqHeightY[k]); 4988dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_row_width_luma_ub = %d\n", 4989dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_luma_ub[k]); 4990dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_width_luma = %d\n", 4991dda4fb85SAurabindo Pillai __func__, k, dpte_group_width_luma); 4992dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_groups_per_row_luma_ub = %d\n", 4993dda4fb85SAurabindo Pillai __func__, k, dpte_groups_per_row_luma_ub); 4994dda4fb85SAurabindo Pillai #endif 4995dda4fb85SAurabindo Pillai 4996dda4fb85SAurabindo Pillai time_per_pte_group_nom_luma[k] = DST_Y_PER_PTE_ROW_NOM_L[k] * 4997dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub; 4998dda4fb85SAurabindo Pillai time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] * 4999dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub; 5000dda4fb85SAurabindo Pillai time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * 5001dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub; 5002dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) { 5003dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = 0; 5004dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = 0; 5005dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = 0; 5006dda4fb85SAurabindo Pillai } else { 5007dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) { 5008dda4fb85SAurabindo Pillai dpte_group_width_chroma = (double) dpte_group_bytes[k] / 5009dda4fb85SAurabindo Pillai (double) PTERequestSizeC[k] * PixelPTEReqWidthC[k]; 5010dda4fb85SAurabindo Pillai } else { 5011dda4fb85SAurabindo Pillai dpte_group_width_chroma = (double) dpte_group_bytes[k] / 5012dda4fb85SAurabindo Pillai (double) PTERequestSizeC[k] * PixelPTEReqHeightC[k]; 5013dda4fb85SAurabindo Pillai } 5014dda4fb85SAurabindo Pillai 5015dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) { 5016dda4fb85SAurabindo Pillai dpte_groups_per_row_chroma_ub = dml_ceil((double) dpte_row_width_chroma_ub[k] / 5017dda4fb85SAurabindo Pillai (double) dpte_group_width_chroma / 2.0, 1.0); 5018dda4fb85SAurabindo Pillai } else { 5019dda4fb85SAurabindo Pillai dpte_groups_per_row_chroma_ub = dml_ceil((double) dpte_row_width_chroma_ub[k] / 5020dda4fb85SAurabindo Pillai (double) dpte_group_width_chroma, 1.0); 5021dda4fb85SAurabindo Pillai } 5022dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5023dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_row_width_chroma_ub = %d\n", 5024dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_chroma_ub[k]); 5025dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_width_chroma = %d\n", 5026dda4fb85SAurabindo Pillai __func__, k, dpte_group_width_chroma); 5027dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_groups_per_row_chroma_ub = %d\n", 5028dda4fb85SAurabindo Pillai __func__, k, dpte_groups_per_row_chroma_ub); 5029dda4fb85SAurabindo Pillai #endif 5030dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = DST_Y_PER_PTE_ROW_NOM_C[k] * 5031dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub; 5032dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] * 5033dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub; 5034dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] * 5035dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub; 5036dda4fb85SAurabindo Pillai } 5037dda4fb85SAurabindo Pillai } else { 5038dda4fb85SAurabindo Pillai time_per_pte_group_nom_luma[k] = 0; 5039dda4fb85SAurabindo Pillai time_per_pte_group_vblank_luma[k] = 0; 5040dda4fb85SAurabindo Pillai time_per_pte_group_flip_luma[k] = 0; 5041dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = 0; 5042dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = 0; 5043dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = 0; 5044dda4fb85SAurabindo Pillai } 5045dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5046dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DestinationLinesToRequestRowInVBlank = %f\n", 5047dda4fb85SAurabindo Pillai __func__, k, DestinationLinesToRequestRowInVBlank[k]); 5048dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DestinationLinesToRequestRowInImmediateFlip = %f\n", 5049dda4fb85SAurabindo Pillai __func__, k, DestinationLinesToRequestRowInImmediateFlip[k]); 5050dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_PTE_ROW_NOM_L = %f\n", 5051dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_PTE_ROW_NOM_L[k]); 5052dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_PTE_ROW_NOM_C = %f\n", 5053dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_PTE_ROW_NOM_C[k]); 5054dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_META_ROW_NOM_L = %f\n", 5055dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_META_ROW_NOM_L[k]); 5056dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_META_ROW_NOM_C = %f\n", 5057dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_META_ROW_NOM_C[k]); 5058dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkNominal = %f\n", 5059dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkNominal[k]); 5060dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkVBlank = %f\n", 5061dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkVBlank[k]); 5062dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkFlip = %f\n", 5063dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkFlip[k]); 5064dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkNominal = %f\n", 5065dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkNominal[k]); 5066dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkVBlank = %f\n", 5067dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkVBlank[k]); 5068dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkFlip = %f\n", 5069dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkFlip[k]); 5070dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_nom_luma = %f\n", 5071dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_nom_luma[k]); 5072dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_vblank_luma = %f\n", 5073dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_vblank_luma[k]); 5074dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_flip_luma = %f\n", 5075dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_flip_luma[k]); 5076dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_nom_chroma = %f\n", 5077dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_nom_chroma[k]); 5078dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_vblank_chroma = %f\n", 5079dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_vblank_chroma[k]); 5080dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_flip_chroma = %f\n", 5081dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_flip_chroma[k]); 5082dda4fb85SAurabindo Pillai #endif 5083dda4fb85SAurabindo Pillai } 5084dda4fb85SAurabindo Pillai } // CalculateMetaAndPTETimes 5085dda4fb85SAurabindo Pillai 5086dda4fb85SAurabindo Pillai void dml32_CalculateVMGroupAndRequestTimes( 5087dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 5088dda4fb85SAurabindo Pillai bool GPUVMEnable, 5089dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels, 5090dda4fb85SAurabindo Pillai unsigned int HTotal[], 5091dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[], 5092dda4fb85SAurabindo Pillai double DestinationLinesToRequestVMInVBlank[], 5093dda4fb85SAurabindo Pillai double DestinationLinesToRequestVMInImmediateFlip[], 5094dda4fb85SAurabindo Pillai bool DCCEnable[], 5095dda4fb85SAurabindo Pillai double PixelClock[], 5096dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[], 5097dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[], 5098dda4fb85SAurabindo Pillai unsigned int vm_group_bytes[], 5099dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_l[], 5100dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_c[], 5101dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_l[], 5102dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_c[], 5103dda4fb85SAurabindo Pillai 5104dda4fb85SAurabindo Pillai /* Output */ 5105dda4fb85SAurabindo Pillai double TimePerVMGroupVBlank[], 5106dda4fb85SAurabindo Pillai double TimePerVMGroupFlip[], 5107dda4fb85SAurabindo Pillai double TimePerVMRequestVBlank[], 5108dda4fb85SAurabindo Pillai double TimePerVMRequestFlip[]) 5109dda4fb85SAurabindo Pillai { 5110dda4fb85SAurabindo Pillai unsigned int k; 5111dda4fb85SAurabindo Pillai unsigned int num_group_per_lower_vm_stage; 5112dda4fb85SAurabindo Pillai unsigned int num_req_per_lower_vm_stage; 5113dda4fb85SAurabindo Pillai 5114dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5115dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces); 5116dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable); 5117dda4fb85SAurabindo Pillai #endif 5118dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 5119dda4fb85SAurabindo Pillai 5120dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5121dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DCCEnable = %d\n", __func__, k, DCCEnable[k]); 5122dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, vm_group_bytes = %d\n", __func__, k, vm_group_bytes[k]); 5123dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpde0_bytes_per_frame_ub_l = %d\n", 5124dda4fb85SAurabindo Pillai __func__, k, dpde0_bytes_per_frame_ub_l[k]); 5125dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpde0_bytes_per_frame_ub_c = %d\n", 5126dda4fb85SAurabindo Pillai __func__, k, dpde0_bytes_per_frame_ub_c[k]); 5127dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, meta_pte_bytes_per_frame_ub_l = %d\n", 5128dda4fb85SAurabindo Pillai __func__, k, meta_pte_bytes_per_frame_ub_l[k]); 5129dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, meta_pte_bytes_per_frame_ub_c = %d\n", 5130dda4fb85SAurabindo Pillai __func__, k, meta_pte_bytes_per_frame_ub_c[k]); 5131dda4fb85SAurabindo Pillai #endif 5132dda4fb85SAurabindo Pillai 5133dda4fb85SAurabindo Pillai if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) { 5134dda4fb85SAurabindo Pillai if (DCCEnable[k] == false) { 5135dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5136dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil( 5137dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) / 5138dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0) + 5139dda4fb85SAurabindo Pillai dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) / 5140dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0); 5141dda4fb85SAurabindo Pillai } else { 5142dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil( 5143dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) / 5144dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0); 5145dda4fb85SAurabindo Pillai } 5146dda4fb85SAurabindo Pillai } else { 5147dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels == 1) { 5148dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5149dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil( 5150dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) / 5151dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0) + 5152dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) / 5153dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0); 5154dda4fb85SAurabindo Pillai } else { 5155dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil( 5156dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) / 5157dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0); 5158dda4fb85SAurabindo Pillai } 5159dda4fb85SAurabindo Pillai } else { 5160dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5161dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = 2 + dml_ceil( 5162dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) / 5163dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) + 5164dda4fb85SAurabindo Pillai dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) / 5165dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) + 5166dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) / 5167dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) + 5168dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) / 5169dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1); 5170dda4fb85SAurabindo Pillai } else { 5171dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = 1 + dml_ceil( 5172dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) / 5173dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) + dml_ceil( 5174dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) / 5175dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1); 5176dda4fb85SAurabindo Pillai } 5177dda4fb85SAurabindo Pillai } 5178dda4fb85SAurabindo Pillai } 5179dda4fb85SAurabindo Pillai 5180dda4fb85SAurabindo Pillai if (DCCEnable[k] == false) { 5181dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5182dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 + 5183dda4fb85SAurabindo Pillai dpde0_bytes_per_frame_ub_c[k] / 64; 5184dda4fb85SAurabindo Pillai } else { 5185dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64; 5186dda4fb85SAurabindo Pillai } 5187dda4fb85SAurabindo Pillai } else { 5188dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels == 1) { 5189dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5190dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64 + 5191dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_c[k] / 64; 5192dda4fb85SAurabindo Pillai } else { 5193dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64; 5194dda4fb85SAurabindo Pillai } 5195dda4fb85SAurabindo Pillai } else { 5196dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) { 5197dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 5198dda4fb85SAurabindo Pillai 64 + dpde0_bytes_per_frame_ub_c[k] / 64 + 5199dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_l[k] / 64 + 5200dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_c[k] / 64; 5201dda4fb85SAurabindo Pillai } else { 5202dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 5203dda4fb85SAurabindo Pillai 64 + meta_pte_bytes_per_frame_ub_l[k] / 64; 5204dda4fb85SAurabindo Pillai } 5205dda4fb85SAurabindo Pillai } 5206dda4fb85SAurabindo Pillai } 5207dda4fb85SAurabindo Pillai 5208dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * 5209dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage; 5210dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * 5211dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage; 5212dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] * 5213dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage; 5214dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] * 5215dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage; 5216dda4fb85SAurabindo Pillai 5217dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels > 2) { 5218dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2; 5219dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2; 5220dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2; 5221dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = TimePerVMRequestFlip[k] / 2; 5222dda4fb85SAurabindo Pillai } 5223dda4fb85SAurabindo Pillai 5224dda4fb85SAurabindo Pillai } else { 5225dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = 0; 5226dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = 0; 5227dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = 0; 5228dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = 0; 5229dda4fb85SAurabindo Pillai } 5230dda4fb85SAurabindo Pillai 5231dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5232dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMGroupVBlank = %f\n", __func__, k, TimePerVMGroupVBlank[k]); 5233dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMGroupFlip = %f\n", __func__, k, TimePerVMGroupFlip[k]); 5234dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMRequestVBlank = %f\n", __func__, k, TimePerVMRequestVBlank[k]); 5235dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMRequestFlip = %f\n", __func__, k, TimePerVMRequestFlip[k]); 5236dda4fb85SAurabindo Pillai #endif 5237dda4fb85SAurabindo Pillai } 5238dda4fb85SAurabindo Pillai } // CalculateVMGroupAndRequestTimes 5239dda4fb85SAurabindo Pillai 5240dda4fb85SAurabindo Pillai void dml32_CalculateDCCConfiguration( 5241dda4fb85SAurabindo Pillai bool DCCEnabled, 5242dda4fb85SAurabindo Pillai bool DCCProgrammingAssumesScanDirectionUnknown, 5243dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat, 5244dda4fb85SAurabindo Pillai unsigned int SurfaceWidthLuma, 5245dda4fb85SAurabindo Pillai unsigned int SurfaceWidthChroma, 5246dda4fb85SAurabindo Pillai unsigned int SurfaceHeightLuma, 5247dda4fb85SAurabindo Pillai unsigned int SurfaceHeightChroma, 5248dda4fb85SAurabindo Pillai unsigned int nomDETInKByte, 5249dda4fb85SAurabindo Pillai unsigned int RequestHeight256ByteLuma, 5250dda4fb85SAurabindo Pillai unsigned int RequestHeight256ByteChroma, 5251dda4fb85SAurabindo Pillai enum dm_swizzle_mode TilingFormat, 5252dda4fb85SAurabindo Pillai unsigned int BytePerPixelY, 5253dda4fb85SAurabindo Pillai unsigned int BytePerPixelC, 5254dda4fb85SAurabindo Pillai double BytePerPixelDETY, 5255dda4fb85SAurabindo Pillai double BytePerPixelDETC, 5256dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation, 5257dda4fb85SAurabindo Pillai /* Output */ 5258dda4fb85SAurabindo Pillai unsigned int *MaxUncompressedBlockLuma, 5259dda4fb85SAurabindo Pillai unsigned int *MaxUncompressedBlockChroma, 5260dda4fb85SAurabindo Pillai unsigned int *MaxCompressedBlockLuma, 5261dda4fb85SAurabindo Pillai unsigned int *MaxCompressedBlockChroma, 5262dda4fb85SAurabindo Pillai unsigned int *IndependentBlockLuma, 5263dda4fb85SAurabindo Pillai unsigned int *IndependentBlockChroma) 5264dda4fb85SAurabindo Pillai { 5265ce19bbe4SChandan Vurdigere Nataraj typedef enum { 5266ce19bbe4SChandan Vurdigere Nataraj REQ_256Bytes, 5267ce19bbe4SChandan Vurdigere Nataraj REQ_128BytesNonContiguous, 5268ce19bbe4SChandan Vurdigere Nataraj REQ_128BytesContiguous, 5269ce19bbe4SChandan Vurdigere Nataraj REQ_NA 5270ce19bbe4SChandan Vurdigere Nataraj } RequestType; 5271dda4fb85SAurabindo Pillai 5272ce19bbe4SChandan Vurdigere Nataraj RequestType RequestLuma; 5273ce19bbe4SChandan Vurdigere Nataraj RequestType RequestChroma; 5274dda4fb85SAurabindo Pillai 5275dda4fb85SAurabindo Pillai unsigned int segment_order_horz_contiguous_luma; 5276dda4fb85SAurabindo Pillai unsigned int segment_order_horz_contiguous_chroma; 5277dda4fb85SAurabindo Pillai unsigned int segment_order_vert_contiguous_luma; 5278dda4fb85SAurabindo Pillai unsigned int segment_order_vert_contiguous_chroma; 5279dda4fb85SAurabindo Pillai unsigned int req128_horz_wc_l; 5280dda4fb85SAurabindo Pillai unsigned int req128_horz_wc_c; 5281dda4fb85SAurabindo Pillai unsigned int req128_vert_wc_l; 5282dda4fb85SAurabindo Pillai unsigned int req128_vert_wc_c; 5283dda4fb85SAurabindo Pillai unsigned int MAS_vp_horz_limit; 5284dda4fb85SAurabindo Pillai unsigned int MAS_vp_vert_limit; 5285dda4fb85SAurabindo Pillai unsigned int max_vp_horz_width; 5286dda4fb85SAurabindo Pillai unsigned int max_vp_vert_height; 5287dda4fb85SAurabindo Pillai unsigned int eff_surf_width_l; 5288dda4fb85SAurabindo Pillai unsigned int eff_surf_width_c; 5289dda4fb85SAurabindo Pillai unsigned int eff_surf_height_l; 5290dda4fb85SAurabindo Pillai unsigned int eff_surf_height_c; 5291dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_horz_wc_l; 5292dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_horz_wc_c; 5293dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_vert_wc_l; 5294dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_vert_wc_c; 5295dda4fb85SAurabindo Pillai unsigned int DETBufferSizeForDCC = nomDETInKByte * 1024; 5296dda4fb85SAurabindo Pillai 5297dda4fb85SAurabindo Pillai unsigned int yuv420; 5298dda4fb85SAurabindo Pillai unsigned int horz_div_l; 5299dda4fb85SAurabindo Pillai unsigned int horz_div_c; 5300dda4fb85SAurabindo Pillai unsigned int vert_div_l; 5301dda4fb85SAurabindo Pillai unsigned int vert_div_c; 5302dda4fb85SAurabindo Pillai 5303dda4fb85SAurabindo Pillai unsigned int swath_buf_size; 5304dda4fb85SAurabindo Pillai double detile_buf_vp_horz_limit; 5305dda4fb85SAurabindo Pillai double detile_buf_vp_vert_limit; 5306dda4fb85SAurabindo Pillai 5307dda4fb85SAurabindo Pillai yuv420 = ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || 5308dda4fb85SAurabindo Pillai SourcePixelFormat == dm_420_12) ? 1 : 0); 5309dda4fb85SAurabindo Pillai horz_div_l = 1; 5310dda4fb85SAurabindo Pillai horz_div_c = 1; 5311dda4fb85SAurabindo Pillai vert_div_l = 1; 5312dda4fb85SAurabindo Pillai vert_div_c = 1; 5313dda4fb85SAurabindo Pillai 5314dda4fb85SAurabindo Pillai if (BytePerPixelY == 1) 5315dda4fb85SAurabindo Pillai vert_div_l = 0; 5316dda4fb85SAurabindo Pillai if (BytePerPixelC == 1) 5317dda4fb85SAurabindo Pillai vert_div_c = 0; 5318dda4fb85SAurabindo Pillai 5319dda4fb85SAurabindo Pillai if (BytePerPixelC == 0) { 5320dda4fb85SAurabindo Pillai swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 256; 5321dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = (double) swath_buf_size / ((double) RequestHeight256ByteLuma * 5322dda4fb85SAurabindo Pillai BytePerPixelY / (1 + horz_div_l)); 5323dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = (double) swath_buf_size / (256.0 / RequestHeight256ByteLuma / 5324dda4fb85SAurabindo Pillai (1 + vert_div_l)); 5325dda4fb85SAurabindo Pillai } else { 5326dda4fb85SAurabindo Pillai swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 2 * 256; 5327dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = (double) swath_buf_size / ((double) RequestHeight256ByteLuma * 5328dda4fb85SAurabindo Pillai BytePerPixelY / (1 + horz_div_l) + (double) RequestHeight256ByteChroma * 5329dda4fb85SAurabindo Pillai BytePerPixelC / (1 + horz_div_c) / (1 + yuv420)); 5330dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = (double) swath_buf_size / (256.0 / RequestHeight256ByteLuma / 5331dda4fb85SAurabindo Pillai (1 + vert_div_l) + 256.0 / RequestHeight256ByteChroma / 5332dda4fb85SAurabindo Pillai (1 + vert_div_c) / (1 + yuv420)); 5333dda4fb85SAurabindo Pillai } 5334dda4fb85SAurabindo Pillai 5335dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_10) { 5336dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit; 5337dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit; 5338dda4fb85SAurabindo Pillai } 5339dda4fb85SAurabindo Pillai 5340dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16); 5341dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16); 5342dda4fb85SAurabindo Pillai 5343dda4fb85SAurabindo Pillai MAS_vp_horz_limit = SourcePixelFormat == dm_rgbe_alpha ? 3840 : 6144; 5344dda4fb85SAurabindo Pillai MAS_vp_vert_limit = SourcePixelFormat == dm_rgbe_alpha ? 3840 : (BytePerPixelY == 8 ? 3072 : 6144); 5345dda4fb85SAurabindo Pillai max_vp_horz_width = dml_min((double) MAS_vp_horz_limit, detile_buf_vp_horz_limit); 5346dda4fb85SAurabindo Pillai max_vp_vert_height = dml_min((double) MAS_vp_vert_limit, detile_buf_vp_vert_limit); 5347dda4fb85SAurabindo Pillai eff_surf_width_l = (SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma); 5348dda4fb85SAurabindo Pillai eff_surf_width_c = eff_surf_width_l / (1 + yuv420); 5349dda4fb85SAurabindo Pillai eff_surf_height_l = (SurfaceHeightLuma > max_vp_vert_height ? max_vp_vert_height : SurfaceHeightLuma); 5350dda4fb85SAurabindo Pillai eff_surf_height_c = eff_surf_height_l / (1 + yuv420); 5351dda4fb85SAurabindo Pillai 5352dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY; 5353dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma; 5354dda4fb85SAurabindo Pillai if (BytePerPixelC > 0) { 5355dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma * BytePerPixelC; 5356dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma; 5357dda4fb85SAurabindo Pillai } else { 5358dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = 0; 5359dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = 0; 5360dda4fb85SAurabindo Pillai } 5361dda4fb85SAurabindo Pillai 5362dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_10) { 5363dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_l = dml_ceil((double) full_swath_bytes_horz_wc_l * 2.0 / 3.0, 256.0); 5364dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = dml_ceil((double) full_swath_bytes_horz_wc_c * 2.0 / 3.0, 256.0); 5365dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l = dml_ceil((double) full_swath_bytes_vert_wc_l * 2.0 / 3.0, 256.0); 5366dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = dml_ceil((double) full_swath_bytes_vert_wc_c * 2.0 / 3.0, 256.0); 5367dda4fb85SAurabindo Pillai } 5368dda4fb85SAurabindo Pillai 5369dda4fb85SAurabindo Pillai if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) { 5370dda4fb85SAurabindo Pillai req128_horz_wc_l = 0; 5371dda4fb85SAurabindo Pillai req128_horz_wc_c = 0; 5372dda4fb85SAurabindo Pillai } else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c && 2 * full_swath_bytes_horz_wc_l + 5373dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) { 5374dda4fb85SAurabindo Pillai req128_horz_wc_l = 0; 5375dda4fb85SAurabindo Pillai req128_horz_wc_c = 1; 5376dda4fb85SAurabindo Pillai } else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c && full_swath_bytes_horz_wc_l + 2 * 5377dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) { 5378dda4fb85SAurabindo Pillai req128_horz_wc_l = 1; 5379dda4fb85SAurabindo Pillai req128_horz_wc_c = 0; 5380dda4fb85SAurabindo Pillai } else { 5381dda4fb85SAurabindo Pillai req128_horz_wc_l = 1; 5382dda4fb85SAurabindo Pillai req128_horz_wc_c = 1; 5383dda4fb85SAurabindo Pillai } 5384dda4fb85SAurabindo Pillai 5385dda4fb85SAurabindo Pillai if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) { 5386dda4fb85SAurabindo Pillai req128_vert_wc_l = 0; 5387dda4fb85SAurabindo Pillai req128_vert_wc_c = 0; 5388dda4fb85SAurabindo Pillai } else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c && 2 * 5389dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) { 5390dda4fb85SAurabindo Pillai req128_vert_wc_l = 0; 5391dda4fb85SAurabindo Pillai req128_vert_wc_c = 1; 5392dda4fb85SAurabindo Pillai } else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c && 5393dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) { 5394dda4fb85SAurabindo Pillai req128_vert_wc_l = 1; 5395dda4fb85SAurabindo Pillai req128_vert_wc_c = 0; 5396dda4fb85SAurabindo Pillai } else { 5397dda4fb85SAurabindo Pillai req128_vert_wc_l = 1; 5398dda4fb85SAurabindo Pillai req128_vert_wc_c = 1; 5399dda4fb85SAurabindo Pillai } 5400dda4fb85SAurabindo Pillai 5401dda4fb85SAurabindo Pillai if (BytePerPixelY == 2) { 5402dda4fb85SAurabindo Pillai segment_order_horz_contiguous_luma = 0; 5403dda4fb85SAurabindo Pillai segment_order_vert_contiguous_luma = 1; 5404dda4fb85SAurabindo Pillai } else { 5405dda4fb85SAurabindo Pillai segment_order_horz_contiguous_luma = 1; 5406dda4fb85SAurabindo Pillai segment_order_vert_contiguous_luma = 0; 5407dda4fb85SAurabindo Pillai } 5408dda4fb85SAurabindo Pillai 5409dda4fb85SAurabindo Pillai if (BytePerPixelC == 2) { 5410dda4fb85SAurabindo Pillai segment_order_horz_contiguous_chroma = 0; 5411dda4fb85SAurabindo Pillai segment_order_vert_contiguous_chroma = 1; 5412dda4fb85SAurabindo Pillai } else { 5413dda4fb85SAurabindo Pillai segment_order_horz_contiguous_chroma = 1; 5414dda4fb85SAurabindo Pillai segment_order_vert_contiguous_chroma = 0; 5415dda4fb85SAurabindo Pillai } 5416dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5417dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnabled = %d\n", __func__, DCCEnabled); 5418dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte); 5419dda4fb85SAurabindo Pillai dml_print("DML::%s: DETBufferSizeForDCC = %d\n", __func__, DETBufferSizeForDCC); 5420dda4fb85SAurabindo Pillai dml_print("DML::%s: req128_horz_wc_l = %d\n", __func__, req128_horz_wc_l); 5421dda4fb85SAurabindo Pillai dml_print("DML::%s: req128_horz_wc_c = %d\n", __func__, req128_horz_wc_c); 5422dda4fb85SAurabindo Pillai dml_print("DML::%s: full_swath_bytes_horz_wc_l = %d\n", __func__, full_swath_bytes_horz_wc_l); 5423dda4fb85SAurabindo Pillai dml_print("DML::%s: full_swath_bytes_vert_wc_c = %d\n", __func__, full_swath_bytes_vert_wc_c); 5424dda4fb85SAurabindo Pillai dml_print("DML::%s: segment_order_horz_contiguous_luma = %d\n", __func__, segment_order_horz_contiguous_luma); 5425dda4fb85SAurabindo Pillai dml_print("DML::%s: segment_order_horz_contiguous_chroma = %d\n", 5426dda4fb85SAurabindo Pillai __func__, segment_order_horz_contiguous_chroma); 5427dda4fb85SAurabindo Pillai #endif 5428dda4fb85SAurabindo Pillai 5429dda4fb85SAurabindo Pillai if (DCCProgrammingAssumesScanDirectionUnknown == true) { 5430dda4fb85SAurabindo Pillai if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0) 5431dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes; 5432dda4fb85SAurabindo Pillai else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0) || 5433dda4fb85SAurabindo Pillai (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0)) 5434dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous; 5435dda4fb85SAurabindo Pillai else 5436dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous; 5437dda4fb85SAurabindo Pillai 5438dda4fb85SAurabindo Pillai if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0) 5439dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes; 5440dda4fb85SAurabindo Pillai else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0) || 5441dda4fb85SAurabindo Pillai (req128_vert_wc_c == 1 && segment_order_vert_contiguous_chroma == 0)) 5442dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous; 5443dda4fb85SAurabindo Pillai else 5444dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous; 5445dda4fb85SAurabindo Pillai 5446dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) { 5447dda4fb85SAurabindo Pillai if (req128_horz_wc_l == 0) 5448dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes; 5449dda4fb85SAurabindo Pillai else if (segment_order_horz_contiguous_luma == 0) 5450dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous; 5451dda4fb85SAurabindo Pillai else 5452dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous; 5453dda4fb85SAurabindo Pillai 5454dda4fb85SAurabindo Pillai if (req128_horz_wc_c == 0) 5455dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes; 5456dda4fb85SAurabindo Pillai else if (segment_order_horz_contiguous_chroma == 0) 5457dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous; 5458dda4fb85SAurabindo Pillai else 5459dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous; 5460dda4fb85SAurabindo Pillai 5461dda4fb85SAurabindo Pillai } else { 5462dda4fb85SAurabindo Pillai if (req128_vert_wc_l == 0) 5463dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes; 5464dda4fb85SAurabindo Pillai else if (segment_order_vert_contiguous_luma == 0) 5465dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous; 5466dda4fb85SAurabindo Pillai else 5467dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous; 5468dda4fb85SAurabindo Pillai 5469dda4fb85SAurabindo Pillai if (req128_vert_wc_c == 0) 5470dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes; 5471dda4fb85SAurabindo Pillai else if (segment_order_vert_contiguous_chroma == 0) 5472dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous; 5473dda4fb85SAurabindo Pillai else 5474dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous; 5475dda4fb85SAurabindo Pillai } 5476dda4fb85SAurabindo Pillai 5477ce19bbe4SChandan Vurdigere Nataraj if (RequestLuma == REQ_256Bytes) { 5478dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256; 5479dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 256; 5480dda4fb85SAurabindo Pillai *IndependentBlockLuma = 0; 5481ce19bbe4SChandan Vurdigere Nataraj } else if (RequestLuma == REQ_128BytesContiguous) { 5482dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256; 5483dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 128; 5484dda4fb85SAurabindo Pillai *IndependentBlockLuma = 128; 5485dda4fb85SAurabindo Pillai } else { 5486dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256; 5487dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 64; 5488dda4fb85SAurabindo Pillai *IndependentBlockLuma = 64; 5489dda4fb85SAurabindo Pillai } 5490dda4fb85SAurabindo Pillai 5491ce19bbe4SChandan Vurdigere Nataraj if (RequestChroma == REQ_256Bytes) { 5492dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256; 5493dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 256; 5494dda4fb85SAurabindo Pillai *IndependentBlockChroma = 0; 5495ce19bbe4SChandan Vurdigere Nataraj } else if (RequestChroma == REQ_128BytesContiguous) { 5496dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256; 5497dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 128; 5498dda4fb85SAurabindo Pillai *IndependentBlockChroma = 128; 5499dda4fb85SAurabindo Pillai } else { 5500dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256; 5501dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 64; 5502dda4fb85SAurabindo Pillai *IndependentBlockChroma = 64; 5503dda4fb85SAurabindo Pillai } 5504dda4fb85SAurabindo Pillai 5505dda4fb85SAurabindo Pillai if (DCCEnabled != true || BytePerPixelC == 0) { 5506dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 0; 5507dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 0; 5508dda4fb85SAurabindo Pillai *IndependentBlockChroma = 0; 5509dda4fb85SAurabindo Pillai } 5510dda4fb85SAurabindo Pillai 5511dda4fb85SAurabindo Pillai if (DCCEnabled != true) { 5512dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 0; 5513dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 0; 5514dda4fb85SAurabindo Pillai *IndependentBlockLuma = 0; 5515dda4fb85SAurabindo Pillai } 5516dda4fb85SAurabindo Pillai 5517dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5518dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxUncompressedBlockLuma = %d\n", __func__, *MaxUncompressedBlockLuma); 5519dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxCompressedBlockLuma = %d\n", __func__, *MaxCompressedBlockLuma); 5520dda4fb85SAurabindo Pillai dml_print("DML::%s: IndependentBlockLuma = %d\n", __func__, *IndependentBlockLuma); 5521dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxUncompressedBlockChroma = %d\n", __func__, *MaxUncompressedBlockChroma); 5522dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxCompressedBlockChroma = %d\n", __func__, *MaxCompressedBlockChroma); 5523dda4fb85SAurabindo Pillai dml_print("DML::%s: IndependentBlockChroma = %d\n", __func__, *IndependentBlockChroma); 5524dda4fb85SAurabindo Pillai #endif 5525dda4fb85SAurabindo Pillai 5526dda4fb85SAurabindo Pillai } // CalculateDCCConfiguration 5527dda4fb85SAurabindo Pillai 5528dda4fb85SAurabindo Pillai void dml32_CalculateStutterEfficiency( 5529dda4fb85SAurabindo Pillai unsigned int CompressedBufferSizeInkByte, 5530dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[], 5531dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled, 5532dda4fb85SAurabindo Pillai unsigned int MetaFIFOSizeInKEntries, 5533dda4fb85SAurabindo Pillai unsigned int ZeroSizeBufferEntries, 5534dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte, 5535dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces, 5536dda4fb85SAurabindo Pillai unsigned int ROBBufferSizeInKByte, 5537dda4fb85SAurabindo Pillai double TotalDataReadBandwidth, 5538dda4fb85SAurabindo Pillai double DCFCLK, 5539dda4fb85SAurabindo Pillai double ReturnBW, 5540dda4fb85SAurabindo Pillai unsigned int CompbufReservedSpace64B, 5541dda4fb85SAurabindo Pillai unsigned int CompbufReservedSpaceZs, 5542dda4fb85SAurabindo Pillai double SRExitTime, 5543dda4fb85SAurabindo Pillai double SRExitZ8Time, 5544dda4fb85SAurabindo Pillai bool SynchronizeTimingsFinal, 5545dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[], 5546dda4fb85SAurabindo Pillai double StutterEnterPlusExitWatermark, 5547dda4fb85SAurabindo Pillai double Z8StutterEnterPlusExitWatermark, 5548dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP, 5549dda4fb85SAurabindo Pillai bool Interlace[], 5550dda4fb85SAurabindo Pillai double MinTTUVBlank[], 5551dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[], 5552dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[], 5553dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[], 5554dda4fb85SAurabindo Pillai double BytePerPixelDETY[], 5555dda4fb85SAurabindo Pillai double SwathWidthY[], 5556dda4fb85SAurabindo Pillai unsigned int SwathHeightY[], 5557dda4fb85SAurabindo Pillai unsigned int SwathHeightC[], 5558dda4fb85SAurabindo Pillai double NetDCCRateLuma[], 5559dda4fb85SAurabindo Pillai double NetDCCRateChroma[], 5560dda4fb85SAurabindo Pillai double DCCFractionOfZeroSizeRequestsLuma[], 5561dda4fb85SAurabindo Pillai double DCCFractionOfZeroSizeRequestsChroma[], 5562dda4fb85SAurabindo Pillai unsigned int HTotal[], 5563dda4fb85SAurabindo Pillai unsigned int VTotal[], 5564dda4fb85SAurabindo Pillai double PixelClock[], 5565dda4fb85SAurabindo Pillai double VRatio[], 5566dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[], 5567dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesY[], 5568dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesY[], 5569dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesC[], 5570dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesC[], 5571dda4fb85SAurabindo Pillai unsigned int DCCYMaxUncompressedBlock[], 5572dda4fb85SAurabindo Pillai unsigned int DCCCMaxUncompressedBlock[], 5573dda4fb85SAurabindo Pillai unsigned int VActive[], 5574dda4fb85SAurabindo Pillai bool DCCEnable[], 5575dda4fb85SAurabindo Pillai bool WritebackEnable[], 5576dda4fb85SAurabindo Pillai double ReadBandwidthSurfaceLuma[], 5577dda4fb85SAurabindo Pillai double ReadBandwidthSurfaceChroma[], 5578dda4fb85SAurabindo Pillai double meta_row_bw[], 5579dda4fb85SAurabindo Pillai double dpte_row_bw[], 5580dda4fb85SAurabindo Pillai 5581dda4fb85SAurabindo Pillai /* Output */ 5582dda4fb85SAurabindo Pillai double *StutterEfficiencyNotIncludingVBlank, 5583dda4fb85SAurabindo Pillai double *StutterEfficiency, 5584dda4fb85SAurabindo Pillai unsigned int *NumberOfStutterBurstsPerFrame, 5585dda4fb85SAurabindo Pillai double *Z8StutterEfficiencyNotIncludingVBlank, 5586dda4fb85SAurabindo Pillai double *Z8StutterEfficiency, 5587dda4fb85SAurabindo Pillai unsigned int *Z8NumberOfStutterBurstsPerFrame, 5588dda4fb85SAurabindo Pillai double *StutterPeriod, 5589dda4fb85SAurabindo Pillai bool *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE) 5590dda4fb85SAurabindo Pillai { 5591dda4fb85SAurabindo Pillai 5592dda4fb85SAurabindo Pillai bool FoundCriticalSurface = false; 5593dda4fb85SAurabindo Pillai unsigned int SwathSizeCriticalSurface = 0; 5594dda4fb85SAurabindo Pillai unsigned int LastChunkOfSwathSize; 5595dda4fb85SAurabindo Pillai unsigned int MissingPartOfLastSwathOfDETSize; 5596dda4fb85SAurabindo Pillai double LastZ8StutterPeriod = 0.0; 5597dda4fb85SAurabindo Pillai double LastStutterPeriod = 0.0; 5598dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveOTG = 0; 5599dda4fb85SAurabindo Pillai double doublePixelClock; 5600dda4fb85SAurabindo Pillai unsigned int doubleHTotal; 5601dda4fb85SAurabindo Pillai unsigned int doubleVTotal; 5602dda4fb85SAurabindo Pillai bool SameTiming = true; 5603dda4fb85SAurabindo Pillai double DETBufferingTimeY; 5604dda4fb85SAurabindo Pillai double SwathWidthYCriticalSurface = 0.0; 5605dda4fb85SAurabindo Pillai double SwathHeightYCriticalSurface = 0.0; 5606dda4fb85SAurabindo Pillai double VActiveTimeCriticalSurface = 0.0; 5607dda4fb85SAurabindo Pillai double FrameTimeCriticalSurface = 0.0; 5608dda4fb85SAurabindo Pillai unsigned int BytePerPixelYCriticalSurface = 0; 5609dda4fb85SAurabindo Pillai double LinesToFinishSwathTransferStutterCriticalSurface = 0.0; 5610dda4fb85SAurabindo Pillai unsigned int DETBufferSizeYCriticalSurface = 0; 5611dda4fb85SAurabindo Pillai double MinTTUVBlankCriticalSurface = 0.0; 5612dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesYCriticalSurface = 0; 5613dda4fb85SAurabindo Pillai bool doublePlaneCriticalSurface = 0; 5614dda4fb85SAurabindo Pillai bool doublePipeCriticalSurface = 0; 5615dda4fb85SAurabindo Pillai double TotalCompressedReadBandwidth; 5616dda4fb85SAurabindo Pillai double TotalRowReadBandwidth; 5617dda4fb85SAurabindo Pillai double AverageDCCCompressionRate; 5618dda4fb85SAurabindo Pillai double EffectiveCompressedBufferSize; 5619dda4fb85SAurabindo Pillai double PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer; 5620dda4fb85SAurabindo Pillai double StutterBurstTime; 5621dda4fb85SAurabindo Pillai unsigned int TotalActiveWriteback; 5622dda4fb85SAurabindo Pillai double LinesInDETY; 5623dda4fb85SAurabindo Pillai double LinesInDETYRoundedDownToSwath; 5624dda4fb85SAurabindo Pillai double MaximumEffectiveCompressionLuma; 5625dda4fb85SAurabindo Pillai double MaximumEffectiveCompressionChroma; 5626dda4fb85SAurabindo Pillai double TotalZeroSizeRequestReadBandwidth; 5627dda4fb85SAurabindo Pillai double TotalZeroSizeCompressedReadBandwidth; 5628dda4fb85SAurabindo Pillai double AverageDCCZeroSizeFraction; 5629dda4fb85SAurabindo Pillai double AverageZeroSizeCompressionRate; 5630dda4fb85SAurabindo Pillai unsigned int k; 5631dda4fb85SAurabindo Pillai 5632dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = 0; 5633dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = 0; 5634dda4fb85SAurabindo Pillai TotalRowReadBandwidth = 0; 5635dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = 0; 5636dda4fb85SAurabindo Pillai 5637dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 5638dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) { 5639dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) { 5640dda4fb85SAurabindo Pillai if ((IsVertical(SourceRotation[k]) && BlockWidth256BytesY[k] > SwathHeightY[k]) 5641dda4fb85SAurabindo Pillai || (!IsVertical(SourceRotation[k]) 5642dda4fb85SAurabindo Pillai && BlockHeight256BytesY[k] > SwathHeightY[k]) 5643dda4fb85SAurabindo Pillai || DCCYMaxUncompressedBlock[k] < 256) { 5644dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma = 2; 5645dda4fb85SAurabindo Pillai } else { 5646dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma = 4; 5647dda4fb85SAurabindo Pillai } 5648dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = TotalCompressedReadBandwidth 5649dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] 5650dda4fb85SAurabindo Pillai / dml_min(NetDCCRateLuma[k], 5651dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma); 5652dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5653dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceLuma = %f\n", 5654dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceLuma[k]); 5655dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, NetDCCRateLuma = %f\n", 5656dda4fb85SAurabindo Pillai __func__, k, NetDCCRateLuma[k]); 5657dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MaximumEffectiveCompressionLuma = %f\n", 5658dda4fb85SAurabindo Pillai __func__, k, MaximumEffectiveCompressionLuma); 5659dda4fb85SAurabindo Pillai #endif 5660dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth 5661dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] * DCCFractionOfZeroSizeRequestsLuma[k]; 5662dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth 5663dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] * DCCFractionOfZeroSizeRequestsLuma[k] 5664dda4fb85SAurabindo Pillai / MaximumEffectiveCompressionLuma; 5665dda4fb85SAurabindo Pillai 5666dda4fb85SAurabindo Pillai if (ReadBandwidthSurfaceChroma[k] > 0) { 5667dda4fb85SAurabindo Pillai if ((IsVertical(SourceRotation[k]) && BlockWidth256BytesC[k] > SwathHeightC[k]) 5668dda4fb85SAurabindo Pillai || (!IsVertical(SourceRotation[k]) 5669dda4fb85SAurabindo Pillai && BlockHeight256BytesC[k] > SwathHeightC[k]) 5670dda4fb85SAurabindo Pillai || DCCCMaxUncompressedBlock[k] < 256) { 5671dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma = 2; 5672dda4fb85SAurabindo Pillai } else { 5673dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma = 4; 5674dda4fb85SAurabindo Pillai } 5675dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = 5676dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth 5677dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k] 5678dda4fb85SAurabindo Pillai / dml_min(NetDCCRateChroma[k], 5679dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma); 5680dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5681dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceChroma = %f\n", 5682dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceChroma[k]); 5683dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, NetDCCRateChroma = %f\n", 5684dda4fb85SAurabindo Pillai __func__, k, NetDCCRateChroma[k]); 5685dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MaximumEffectiveCompressionChroma = %f\n", 5686dda4fb85SAurabindo Pillai __func__, k, MaximumEffectiveCompressionChroma); 5687dda4fb85SAurabindo Pillai #endif 5688dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth 5689dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k] 5690dda4fb85SAurabindo Pillai * DCCFractionOfZeroSizeRequestsChroma[k]; 5691dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth 5692dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k] 5693dda4fb85SAurabindo Pillai * DCCFractionOfZeroSizeRequestsChroma[k] 5694dda4fb85SAurabindo Pillai / MaximumEffectiveCompressionChroma; 5695dda4fb85SAurabindo Pillai } 5696dda4fb85SAurabindo Pillai } else { 5697dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = TotalCompressedReadBandwidth 5698dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] + ReadBandwidthSurfaceChroma[k]; 5699dda4fb85SAurabindo Pillai } 5700dda4fb85SAurabindo Pillai TotalRowReadBandwidth = TotalRowReadBandwidth 5701dda4fb85SAurabindo Pillai + DPPPerSurface[k] * (meta_row_bw[k] + dpte_row_bw[k]); 5702dda4fb85SAurabindo Pillai } 5703dda4fb85SAurabindo Pillai } 5704dda4fb85SAurabindo Pillai 5705dda4fb85SAurabindo Pillai AverageDCCCompressionRate = TotalDataReadBandwidth / TotalCompressedReadBandwidth; 5706dda4fb85SAurabindo Pillai AverageDCCZeroSizeFraction = TotalZeroSizeRequestReadBandwidth / TotalDataReadBandwidth; 5707dda4fb85SAurabindo Pillai 5708dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5709dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, UnboundedRequestEnabled); 5710dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalCompressedReadBandwidth = %f\n", __func__, TotalCompressedReadBandwidth); 5711dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalZeroSizeRequestReadBandwidth = %f\n", __func__, TotalZeroSizeRequestReadBandwidth); 5712dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalZeroSizeCompressedReadBandwidth = %f\n", 5713dda4fb85SAurabindo Pillai __func__, TotalZeroSizeCompressedReadBandwidth); 5714dda4fb85SAurabindo Pillai dml_print("DML::%s: MaximumEffectiveCompressionLuma = %f\n", __func__, MaximumEffectiveCompressionLuma); 5715dda4fb85SAurabindo Pillai dml_print("DML::%s: MaximumEffectiveCompressionChroma = %f\n", __func__, MaximumEffectiveCompressionChroma); 5716dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate); 5717dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCZeroSizeFraction = %f\n", __func__, AverageDCCZeroSizeFraction); 5718dda4fb85SAurabindo Pillai dml_print("DML::%s: CompbufReservedSpace64B = %d\n", __func__, CompbufReservedSpace64B); 5719dda4fb85SAurabindo Pillai dml_print("DML::%s: CompbufReservedSpaceZs = %d\n", __func__, CompbufReservedSpaceZs); 5720dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, CompressedBufferSizeInkByte); 5721dda4fb85SAurabindo Pillai #endif 5722dda4fb85SAurabindo Pillai if (AverageDCCZeroSizeFraction == 1) { 5723dda4fb85SAurabindo Pillai AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth 5724dda4fb85SAurabindo Pillai / TotalZeroSizeCompressedReadBandwidth; 5725dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = (double) MetaFIFOSizeInKEntries * 1024 * 64 5726dda4fb85SAurabindo Pillai * AverageZeroSizeCompressionRate 5727dda4fb85SAurabindo Pillai + ((double) ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64 5728dda4fb85SAurabindo Pillai * AverageZeroSizeCompressionRate; 5729dda4fb85SAurabindo Pillai } else if (AverageDCCZeroSizeFraction > 0) { 5730dda4fb85SAurabindo Pillai AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth 5731dda4fb85SAurabindo Pillai / TotalZeroSizeCompressedReadBandwidth; 5732dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = dml_min( 5733dda4fb85SAurabindo Pillai (double) CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate, 5734dda4fb85SAurabindo Pillai (double) MetaFIFOSizeInKEntries * 1024 * 64 5735dda4fb85SAurabindo Pillai / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate 5736dda4fb85SAurabindo Pillai + 1 / AverageDCCCompressionRate)) 5737dda4fb85SAurabindo Pillai + dml_min(((double) ROBBufferSizeInKByte * 1024 - CompbufReservedSpace64B * 64) 5738dda4fb85SAurabindo Pillai * AverageDCCCompressionRate, 5739dda4fb85SAurabindo Pillai ((double) ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64 5740dda4fb85SAurabindo Pillai / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate)); 5741dda4fb85SAurabindo Pillai 5742dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5743dda4fb85SAurabindo Pillai dml_print("DML::%s: min 1 = %f\n", __func__, 5744dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate); 5745dda4fb85SAurabindo Pillai dml_print("DML::%s: min 2 = %f\n", __func__, MetaFIFOSizeInKEntries * 1024 * 64 / 5746dda4fb85SAurabindo Pillai (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 / 5747dda4fb85SAurabindo Pillai AverageDCCCompressionRate)); 5748dda4fb85SAurabindo Pillai dml_print("DML::%s: min 3 = %f\n", __func__, (ROBBufferSizeInKByte * 1024 - 5749dda4fb85SAurabindo Pillai CompbufReservedSpace64B * 64) * AverageDCCCompressionRate); 5750dda4fb85SAurabindo Pillai dml_print("DML::%s: min 4 = %f\n", __func__, (ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64 / 5751dda4fb85SAurabindo Pillai (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate)); 5752dda4fb85SAurabindo Pillai #endif 5753dda4fb85SAurabindo Pillai } else { 5754dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = dml_min( 5755dda4fb85SAurabindo Pillai (double) CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate, 5756dda4fb85SAurabindo Pillai (double) MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate) 5757dda4fb85SAurabindo Pillai + ((double) ROBBufferSizeInKByte * 1024 - CompbufReservedSpace64B * 64) 5758dda4fb85SAurabindo Pillai * AverageDCCCompressionRate; 5759dda4fb85SAurabindo Pillai 5760dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5761dda4fb85SAurabindo Pillai dml_print("DML::%s: min 1 = %f\n", __func__, 5762dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate); 5763dda4fb85SAurabindo Pillai dml_print("DML::%s: min 2 = %f\n", __func__, 5764dda4fb85SAurabindo Pillai MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate); 5765dda4fb85SAurabindo Pillai #endif 5766dda4fb85SAurabindo Pillai } 5767dda4fb85SAurabindo Pillai 5768dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5769dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaFIFOSizeInKEntries = %d\n", __func__, MetaFIFOSizeInKEntries); 5770dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageZeroSizeCompressionRate = %f\n", __func__, AverageZeroSizeCompressionRate); 5771dda4fb85SAurabindo Pillai dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize); 5772dda4fb85SAurabindo Pillai #endif 5773dda4fb85SAurabindo Pillai 5774dda4fb85SAurabindo Pillai *StutterPeriod = 0; 5775dda4fb85SAurabindo Pillai 5776dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 5777dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) { 5778dda4fb85SAurabindo Pillai LinesInDETY = ((double) DETBufferSizeY[k] 5779dda4fb85SAurabindo Pillai + (UnboundedRequestEnabled == true ? EffectiveCompressedBufferSize : 0) 5780dda4fb85SAurabindo Pillai * ReadBandwidthSurfaceLuma[k] / TotalDataReadBandwidth) 5781dda4fb85SAurabindo Pillai / BytePerPixelDETY[k] / SwathWidthY[k]; 5782dda4fb85SAurabindo Pillai LinesInDETYRoundedDownToSwath = dml_floor(LinesInDETY, SwathHeightY[k]); 5783dda4fb85SAurabindo Pillai DETBufferingTimeY = LinesInDETYRoundedDownToSwath * ((double) HTotal[k] / PixelClock[k]) 5784dda4fb85SAurabindo Pillai / VRatio[k]; 5785dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5786dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]); 5787dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BytePerPixelDETY = %f\n", __func__, k, BytePerPixelDETY[k]); 5788dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathWidthY = %d\n", __func__, k, SwathWidthY[k]); 5789dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceLuma = %f\n", 5790dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceLuma[k]); 5791dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TotalDataReadBandwidth = %f\n", __func__, k, TotalDataReadBandwidth); 5792dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesInDETY = %f\n", __func__, k, LinesInDETY); 5793dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesInDETYRoundedDownToSwath = %f\n", 5794dda4fb85SAurabindo Pillai __func__, k, LinesInDETYRoundedDownToSwath); 5795dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, HTotal = %d\n", __func__, k, HTotal[k]); 5796dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelClock = %f\n", __func__, k, PixelClock[k]); 5797dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, VRatio = %f\n", __func__, k, VRatio[k]); 5798dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DETBufferingTimeY = %f\n", __func__, k, DETBufferingTimeY); 5799dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelClock = %f\n", __func__, k, PixelClock[k]); 5800dda4fb85SAurabindo Pillai #endif 5801dda4fb85SAurabindo Pillai 5802dda4fb85SAurabindo Pillai if (!FoundCriticalSurface || DETBufferingTimeY < *StutterPeriod) { 5803dda4fb85SAurabindo Pillai bool isInterlaceTiming = Interlace[k] && !ProgressiveToInterlaceUnitInOPP; 5804dda4fb85SAurabindo Pillai 5805dda4fb85SAurabindo Pillai FoundCriticalSurface = true; 5806dda4fb85SAurabindo Pillai *StutterPeriod = DETBufferingTimeY; 5807dda4fb85SAurabindo Pillai FrameTimeCriticalSurface = ( 5808dda4fb85SAurabindo Pillai isInterlaceTiming ? 5809dda4fb85SAurabindo Pillai dml_floor((double) VTotal[k] / 2.0, 1.0) : VTotal[k]) 5810dda4fb85SAurabindo Pillai * (double) HTotal[k] / PixelClock[k]; 5811dda4fb85SAurabindo Pillai VActiveTimeCriticalSurface = ( 5812dda4fb85SAurabindo Pillai isInterlaceTiming ? 5813dda4fb85SAurabindo Pillai dml_floor((double) VActive[k] / 2.0, 1.0) : VActive[k]) 5814dda4fb85SAurabindo Pillai * (double) HTotal[k] / PixelClock[k]; 5815dda4fb85SAurabindo Pillai BytePerPixelYCriticalSurface = BytePerPixelY[k]; 5816dda4fb85SAurabindo Pillai SwathWidthYCriticalSurface = SwathWidthY[k]; 5817dda4fb85SAurabindo Pillai SwathHeightYCriticalSurface = SwathHeightY[k]; 5818dda4fb85SAurabindo Pillai BlockWidth256BytesYCriticalSurface = BlockWidth256BytesY[k]; 5819dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface = SwathHeightY[k] 5820dda4fb85SAurabindo Pillai - (LinesInDETY - LinesInDETYRoundedDownToSwath); 5821dda4fb85SAurabindo Pillai DETBufferSizeYCriticalSurface = DETBufferSizeY[k]; 5822dda4fb85SAurabindo Pillai MinTTUVBlankCriticalSurface = MinTTUVBlank[k]; 5823dda4fb85SAurabindo Pillai doublePlaneCriticalSurface = (ReadBandwidthSurfaceChroma[k] == 0); 5824dda4fb85SAurabindo Pillai doublePipeCriticalSurface = (DPPPerSurface[k] == 1); 5825dda4fb85SAurabindo Pillai 5826dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5827dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, FoundCriticalSurface = %d\n", 5828dda4fb85SAurabindo Pillai __func__, k, FoundCriticalSurface); 5829dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, StutterPeriod = %f\n", 5830dda4fb85SAurabindo Pillai __func__, k, *StutterPeriod); 5831dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MinTTUVBlankCriticalSurface = %f\n", 5832dda4fb85SAurabindo Pillai __func__, k, MinTTUVBlankCriticalSurface); 5833dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, FrameTimeCriticalSurface = %f\n", 5834dda4fb85SAurabindo Pillai __func__, k, FrameTimeCriticalSurface); 5835dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, VActiveTimeCriticalSurface = %f\n", 5836dda4fb85SAurabindo Pillai __func__, k, VActiveTimeCriticalSurface); 5837dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BytePerPixelYCriticalSurface = %d\n", 5838dda4fb85SAurabindo Pillai __func__, k, BytePerPixelYCriticalSurface); 5839dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathWidthYCriticalSurface = %f\n", 5840dda4fb85SAurabindo Pillai __func__, k, SwathWidthYCriticalSurface); 5841dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathHeightYCriticalSurface = %f\n", 5842dda4fb85SAurabindo Pillai __func__, k, SwathHeightYCriticalSurface); 5843dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BlockWidth256BytesYCriticalSurface = %d\n", 5844dda4fb85SAurabindo Pillai __func__, k, BlockWidth256BytesYCriticalSurface); 5845dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, doublePlaneCriticalSurface = %d\n", 5846dda4fb85SAurabindo Pillai __func__, k, doublePlaneCriticalSurface); 5847dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, doublePipeCriticalSurface = %d\n", 5848dda4fb85SAurabindo Pillai __func__, k, doublePipeCriticalSurface); 5849dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesToFinishSwathTransferStutterCriticalSurface = %f\n", 5850dda4fb85SAurabindo Pillai __func__, k, LinesToFinishSwathTransferStutterCriticalSurface); 5851dda4fb85SAurabindo Pillai #endif 5852dda4fb85SAurabindo Pillai } 5853dda4fb85SAurabindo Pillai } 5854dda4fb85SAurabindo Pillai } 5855dda4fb85SAurabindo Pillai 5856dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = dml_min(*StutterPeriod * TotalDataReadBandwidth, 5857dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize); 5858dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5859dda4fb85SAurabindo Pillai dml_print("DML::%s: ROBBufferSizeInKByte = %d\n", __func__, ROBBufferSizeInKByte); 5860dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate); 5861dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", 5862dda4fb85SAurabindo Pillai __func__, *StutterPeriod * TotalDataReadBandwidth); 5863dda4fb85SAurabindo Pillai dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize); 5864dda4fb85SAurabindo Pillai dml_print("DML::%s: PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = %f\n", __func__, 5865dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer); 5866dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW); 5867dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalDataReadBandwidth = %f\n", __func__, TotalDataReadBandwidth); 5868dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalRowReadBandwidth = %f\n", __func__, TotalRowReadBandwidth); 5869dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK); 5870dda4fb85SAurabindo Pillai #endif 5871dda4fb85SAurabindo Pillai 5872dda4fb85SAurabindo Pillai StutterBurstTime = PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate 5873dda4fb85SAurabindo Pillai / ReturnBW 5874dda4fb85SAurabindo Pillai + (*StutterPeriod * TotalDataReadBandwidth 5875dda4fb85SAurabindo Pillai - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (DCFCLK * 64) 5876dda4fb85SAurabindo Pillai + *StutterPeriod * TotalRowReadBandwidth / ReturnBW; 5877dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5878dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 1 = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / 5879dda4fb85SAurabindo Pillai AverageDCCCompressionRate / ReturnBW); 5880dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n", 5881dda4fb85SAurabindo Pillai __func__, (*StutterPeriod * TotalDataReadBandwidth)); 5882dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 2 = %f\n", __func__, (*StutterPeriod * TotalDataReadBandwidth - 5883dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (DCFCLK * 64)); 5884dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 3 = %f\n", __func__, *StutterPeriod * TotalRowReadBandwidth / ReturnBW); 5885dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime); 5886dda4fb85SAurabindo Pillai #endif 5887dda4fb85SAurabindo Pillai StutterBurstTime = dml_max(StutterBurstTime, 5888dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface 5889dda4fb85SAurabindo Pillai * SwathWidthYCriticalSurface / ReturnBW); 5890dda4fb85SAurabindo Pillai 5891dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5892dda4fb85SAurabindo Pillai dml_print("DML::%s: Time to finish residue swath=%f\n", 5893dda4fb85SAurabindo Pillai __func__, 5894dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface * 5895dda4fb85SAurabindo Pillai BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / ReturnBW); 5896dda4fb85SAurabindo Pillai #endif 5897dda4fb85SAurabindo Pillai 5898dda4fb85SAurabindo Pillai TotalActiveWriteback = 0; 5899dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 5900dda4fb85SAurabindo Pillai if (WritebackEnable[k]) 5901dda4fb85SAurabindo Pillai TotalActiveWriteback = TotalActiveWriteback + 1; 5902dda4fb85SAurabindo Pillai } 5903dda4fb85SAurabindo Pillai 5904dda4fb85SAurabindo Pillai if (TotalActiveWriteback == 0) { 5905dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5906dda4fb85SAurabindo Pillai dml_print("DML::%s: SRExitTime = %f\n", __func__, SRExitTime); 5907dda4fb85SAurabindo Pillai dml_print("DML::%s: SRExitZ8Time = %f\n", __func__, SRExitZ8Time); 5908dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f (final)\n", __func__, StutterBurstTime); 5909dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod = %f\n", __func__, *StutterPeriod); 5910dda4fb85SAurabindo Pillai #endif 5911dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank = dml_max(0., 5912dda4fb85SAurabindo Pillai 1 - (SRExitTime + StutterBurstTime) / *StutterPeriod) * 100; 5913dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank = dml_max(0., 5914dda4fb85SAurabindo Pillai 1 - (SRExitZ8Time + StutterBurstTime) / *StutterPeriod) * 100; 5915dda4fb85SAurabindo Pillai *NumberOfStutterBurstsPerFrame = ( 5916dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank > 0 ? 5917dda4fb85SAurabindo Pillai dml_ceil(VActiveTimeCriticalSurface / *StutterPeriod, 1) : 0); 5918dda4fb85SAurabindo Pillai *Z8NumberOfStutterBurstsPerFrame = ( 5919dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank > 0 ? 5920dda4fb85SAurabindo Pillai dml_ceil(VActiveTimeCriticalSurface / *StutterPeriod, 1) : 0); 5921dda4fb85SAurabindo Pillai } else { 5922dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank = 0.; 5923dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank = 0.; 5924dda4fb85SAurabindo Pillai *NumberOfStutterBurstsPerFrame = 0; 5925dda4fb85SAurabindo Pillai *Z8NumberOfStutterBurstsPerFrame = 0; 5926dda4fb85SAurabindo Pillai } 5927dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5928dda4fb85SAurabindo Pillai dml_print("DML::%s: VActiveTimeCriticalSurface = %f\n", __func__, VActiveTimeCriticalSurface); 5929dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", 5930dda4fb85SAurabindo Pillai __func__, *StutterEfficiencyNotIncludingVBlank); 5931dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEfficiencyNotIncludingVBlank = %f\n", 5932dda4fb85SAurabindo Pillai __func__, *Z8StutterEfficiencyNotIncludingVBlank); 5933dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfStutterBurstsPerFrame = %d\n", __func__, *NumberOfStutterBurstsPerFrame); 5934dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %d\n", __func__, *Z8NumberOfStutterBurstsPerFrame); 5935dda4fb85SAurabindo Pillai #endif 5936dda4fb85SAurabindo Pillai 5937dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 5938dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) { 5939dda4fb85SAurabindo Pillai if (BlendingAndTiming[k] == k) { 5940dda4fb85SAurabindo Pillai if (TotalNumberOfActiveOTG == 0) { 5941dda4fb85SAurabindo Pillai doublePixelClock = PixelClock[k]; 5942dda4fb85SAurabindo Pillai doubleHTotal = HTotal[k]; 5943dda4fb85SAurabindo Pillai doubleVTotal = VTotal[k]; 5944dda4fb85SAurabindo Pillai } else if (doublePixelClock != PixelClock[k] || doubleHTotal != HTotal[k] 5945dda4fb85SAurabindo Pillai || doubleVTotal != VTotal[k]) { 5946dda4fb85SAurabindo Pillai SameTiming = false; 5947dda4fb85SAurabindo Pillai } 5948dda4fb85SAurabindo Pillai TotalNumberOfActiveOTG = TotalNumberOfActiveOTG + 1; 5949dda4fb85SAurabindo Pillai } 5950dda4fb85SAurabindo Pillai } 5951dda4fb85SAurabindo Pillai } 5952dda4fb85SAurabindo Pillai 5953dda4fb85SAurabindo Pillai if (*StutterEfficiencyNotIncludingVBlank > 0) { 5954dda4fb85SAurabindo Pillai LastStutterPeriod = VActiveTimeCriticalSurface - (*NumberOfStutterBurstsPerFrame - 1) * *StutterPeriod; 5955dda4fb85SAurabindo Pillai 5956dda4fb85SAurabindo Pillai if ((SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming 5957dda4fb85SAurabindo Pillai && LastStutterPeriod + MinTTUVBlankCriticalSurface > StutterEnterPlusExitWatermark) { 5958dda4fb85SAurabindo Pillai *StutterEfficiency = (1 - (*NumberOfStutterBurstsPerFrame * SRExitTime 5959dda4fb85SAurabindo Pillai + StutterBurstTime * VActiveTimeCriticalSurface 5960dda4fb85SAurabindo Pillai / *StutterPeriod) / FrameTimeCriticalSurface) * 100; 5961dda4fb85SAurabindo Pillai } else { 5962dda4fb85SAurabindo Pillai *StutterEfficiency = *StutterEfficiencyNotIncludingVBlank; 5963dda4fb85SAurabindo Pillai } 5964dda4fb85SAurabindo Pillai } else { 5965dda4fb85SAurabindo Pillai *StutterEfficiency = 0; 5966dda4fb85SAurabindo Pillai } 5967dda4fb85SAurabindo Pillai 5968dda4fb85SAurabindo Pillai if (*Z8StutterEfficiencyNotIncludingVBlank > 0) { 5969dda4fb85SAurabindo Pillai LastZ8StutterPeriod = VActiveTimeCriticalSurface 5970dda4fb85SAurabindo Pillai - (*NumberOfStutterBurstsPerFrame - 1) * *StutterPeriod; 5971dda4fb85SAurabindo Pillai if ((SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming && LastZ8StutterPeriod + 5972dda4fb85SAurabindo Pillai MinTTUVBlankCriticalSurface > Z8StutterEnterPlusExitWatermark) { 5973dda4fb85SAurabindo Pillai *Z8StutterEfficiency = (1 - (*NumberOfStutterBurstsPerFrame * SRExitZ8Time + StutterBurstTime 5974dda4fb85SAurabindo Pillai * VActiveTimeCriticalSurface / *StutterPeriod) / FrameTimeCriticalSurface) * 100; 5975dda4fb85SAurabindo Pillai } else { 5976dda4fb85SAurabindo Pillai *Z8StutterEfficiency = *Z8StutterEfficiencyNotIncludingVBlank; 5977dda4fb85SAurabindo Pillai } 5978dda4fb85SAurabindo Pillai } else { 5979dda4fb85SAurabindo Pillai *Z8StutterEfficiency = 0.; 5980dda4fb85SAurabindo Pillai } 5981dda4fb85SAurabindo Pillai 5982dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 5983dda4fb85SAurabindo Pillai dml_print("DML::%s: LastZ8StutterPeriod = %f\n", __func__, LastZ8StutterPeriod); 5984dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, Z8StutterEnterPlusExitWatermark); 5985dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime); 5986dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod = %f\n", __func__, *StutterPeriod); 5987dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiency = %f\n", __func__, *StutterEfficiency); 5988dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEfficiency = %f\n", __func__, *Z8StutterEfficiency); 5989dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n", 5990dda4fb85SAurabindo Pillai __func__, *StutterEfficiencyNotIncludingVBlank); 5991dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %d\n", __func__, *Z8NumberOfStutterBurstsPerFrame); 5992dda4fb85SAurabindo Pillai #endif 5993dda4fb85SAurabindo Pillai 5994dda4fb85SAurabindo Pillai SwathSizeCriticalSurface = BytePerPixelYCriticalSurface * SwathHeightYCriticalSurface 5995dda4fb85SAurabindo Pillai * dml_ceil(SwathWidthYCriticalSurface, BlockWidth256BytesYCriticalSurface); 5996dda4fb85SAurabindo Pillai LastChunkOfSwathSize = SwathSizeCriticalSurface % (PixelChunkSizeInKByte * 1024); 5997dda4fb85SAurabindo Pillai MissingPartOfLastSwathOfDETSize = dml_ceil(DETBufferSizeYCriticalSurface, SwathSizeCriticalSurface) 5998dda4fb85SAurabindo Pillai - DETBufferSizeYCriticalSurface; 5999dda4fb85SAurabindo Pillai 6000dda4fb85SAurabindo Pillai *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = !(!UnboundedRequestEnabled && (NumberOfActiveSurfaces == 1) 6001dda4fb85SAurabindo Pillai && doublePlaneCriticalSurface && doublePipeCriticalSurface && (LastChunkOfSwathSize > 0) 6002dda4fb85SAurabindo Pillai && (LastChunkOfSwathSize <= 4096) && (MissingPartOfLastSwathOfDETSize > 0) 6003dda4fb85SAurabindo Pillai && (MissingPartOfLastSwathOfDETSize <= LastChunkOfSwathSize)); 6004dda4fb85SAurabindo Pillai 6005dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 6006dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathSizeCriticalSurface = %d\n", __func__, SwathSizeCriticalSurface); 6007dda4fb85SAurabindo Pillai dml_print("DML::%s: LastChunkOfSwathSize = %d\n", __func__, LastChunkOfSwathSize); 6008dda4fb85SAurabindo Pillai dml_print("DML::%s: MissingPartOfLastSwathOfDETSize = %d\n", __func__, MissingPartOfLastSwathOfDETSize); 6009dda4fb85SAurabindo Pillai dml_print("DML::%s: DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = %d\n", __func__, *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE); 6010dda4fb85SAurabindo Pillai #endif 6011dda4fb85SAurabindo Pillai } // CalculateStutterEfficiency 6012dda4fb85SAurabindo Pillai 6013dda4fb85SAurabindo Pillai void dml32_CalculateMaxDETAndMinCompressedBufferSize( 6014dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte, 6015dda4fb85SAurabindo Pillai unsigned int ROBBufferSizeInKByte, 6016dda4fb85SAurabindo Pillai unsigned int MaxNumDPP, 6017dda4fb85SAurabindo Pillai bool nomDETInKByteOverrideEnable, // VBA_DELTA, allow DV to override default DET size 6018dda4fb85SAurabindo Pillai unsigned int nomDETInKByteOverrideValue, // VBA_DELTA 6019dda4fb85SAurabindo Pillai 6020dda4fb85SAurabindo Pillai /* Output */ 6021dda4fb85SAurabindo Pillai unsigned int *MaxTotalDETInKByte, 6022dda4fb85SAurabindo Pillai unsigned int *nomDETInKByte, 6023dda4fb85SAurabindo Pillai unsigned int *MinCompressedBufferSizeInKByte) 6024dda4fb85SAurabindo Pillai { 6025dda4fb85SAurabindo Pillai bool det_buff_size_override_en = nomDETInKByteOverrideEnable; 6026dda4fb85SAurabindo Pillai unsigned int det_buff_size_override_val = nomDETInKByteOverrideValue; 6027dda4fb85SAurabindo Pillai 6028dda4fb85SAurabindo Pillai *MaxTotalDETInKByte = dml_ceil(((double)ConfigReturnBufferSizeInKByte + 6029dda4fb85SAurabindo Pillai (double) ROBBufferSizeInKByte) * 4.0 / 5.0, 64); 6030dda4fb85SAurabindo Pillai *nomDETInKByte = dml_floor((double) *MaxTotalDETInKByte / (double) MaxNumDPP, 64); 6031dda4fb85SAurabindo Pillai *MinCompressedBufferSizeInKByte = ConfigReturnBufferSizeInKByte - *MaxTotalDETInKByte; 6032dda4fb85SAurabindo Pillai 6033dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 6034dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %0d\n", __func__, ConfigReturnBufferSizeInKByte); 6035dda4fb85SAurabindo Pillai dml_print("DML::%s: ROBBufferSizeInKByte = %0d\n", __func__, ROBBufferSizeInKByte); 6036dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumDPP = %0d\n", __func__, MaxNumDPP); 6037dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxTotalDETInKByte = %0d\n", __func__, *MaxTotalDETInKByte); 6038dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %0d\n", __func__, *nomDETInKByte); 6039dda4fb85SAurabindo Pillai dml_print("DML::%s: MinCompressedBufferSizeInKByte = %0d\n", __func__, *MinCompressedBufferSizeInKByte); 6040dda4fb85SAurabindo Pillai #endif 6041dda4fb85SAurabindo Pillai 6042dda4fb85SAurabindo Pillai if (det_buff_size_override_en) { 6043dda4fb85SAurabindo Pillai *nomDETInKByte = det_buff_size_override_val; 6044dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 6045dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %0d (override)\n", __func__, *nomDETInKByte); 6046dda4fb85SAurabindo Pillai #endif 6047dda4fb85SAurabindo Pillai } 6048dda4fb85SAurabindo Pillai } // CalculateMaxDETAndMinCompressedBufferSize 6049dda4fb85SAurabindo Pillai 6050dda4fb85SAurabindo Pillai bool dml32_CalculateVActiveBandwithSupport(unsigned int NumberOfActiveSurfaces, 6051dda4fb85SAurabindo Pillai double ReturnBW, 6052dda4fb85SAurabindo Pillai bool NotUrgentLatencyHiding[], 6053dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 6054dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 6055dda4fb85SAurabindo Pillai double cursor_bw[], 6056dda4fb85SAurabindo Pillai double meta_row_bandwidth[], 6057dda4fb85SAurabindo Pillai double dpte_row_bandwidth[], 6058dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 6059dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[], 6060dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[], 6061dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[]) 6062dda4fb85SAurabindo Pillai { 6063dda4fb85SAurabindo Pillai unsigned int k; 6064dda4fb85SAurabindo Pillai bool NotEnoughUrgentLatencyHiding = false; 6065dda4fb85SAurabindo Pillai bool CalculateVActiveBandwithSupport_val = false; 6066dda4fb85SAurabindo Pillai double VActiveBandwith = 0; 6067dda4fb85SAurabindo Pillai 6068dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6069dda4fb85SAurabindo Pillai if (NotUrgentLatencyHiding[k]) { 6070dda4fb85SAurabindo Pillai NotEnoughUrgentLatencyHiding = true; 6071dda4fb85SAurabindo Pillai } 6072dda4fb85SAurabindo Pillai } 6073dda4fb85SAurabindo Pillai 6074dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6075dda4fb85SAurabindo Pillai VActiveBandwith = VActiveBandwith + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * meta_row_bandwidth[k] + NumberOfDPP[k] * dpte_row_bandwidth[k]; 6076dda4fb85SAurabindo Pillai } 6077dda4fb85SAurabindo Pillai 6078dda4fb85SAurabindo Pillai CalculateVActiveBandwithSupport_val = (VActiveBandwith <= ReturnBW) && !NotEnoughUrgentLatencyHiding; 6079dda4fb85SAurabindo Pillai 6080dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__ 6081dda4fb85SAurabindo Pillai dml_print("DML::%s: NotEnoughUrgentLatencyHiding = %d\n", __func__, NotEnoughUrgentLatencyHiding); 6082dda4fb85SAurabindo Pillai dml_print("DML::%s: VActiveBandwith = %f\n", __func__, VActiveBandwith); 6083dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW); 6084dda4fb85SAurabindo Pillai dml_print("DML::%s: CalculateVActiveBandwithSupport_val = %d\n", __func__, CalculateVActiveBandwithSupport_val); 6085dda4fb85SAurabindo Pillai #endif 6086dda4fb85SAurabindo Pillai return CalculateVActiveBandwithSupport_val; 6087dda4fb85SAurabindo Pillai } 6088dda4fb85SAurabindo Pillai 6089dda4fb85SAurabindo Pillai void dml32_CalculatePrefetchBandwithSupport(unsigned int NumberOfActiveSurfaces, 6090dda4fb85SAurabindo Pillai double ReturnBW, 6091dda4fb85SAurabindo Pillai bool NotUrgentLatencyHiding[], 6092dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 6093dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 6094dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[], 6095dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[], 6096dda4fb85SAurabindo Pillai double cursor_bw[], 6097dda4fb85SAurabindo Pillai double meta_row_bandwidth[], 6098dda4fb85SAurabindo Pillai double dpte_row_bandwidth[], 6099dda4fb85SAurabindo Pillai double cursor_bw_pre[], 6100dda4fb85SAurabindo Pillai double prefetch_vmrow_bw[], 6101dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 6102dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[], 6103dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[], 6104dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[], 6105dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[], 6106dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[], 6107dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[], 6108dda4fb85SAurabindo Pillai 6109dda4fb85SAurabindo Pillai /* output */ 6110dda4fb85SAurabindo Pillai double *PrefetchBandwidth, 6111dda4fb85SAurabindo Pillai double *FractionOfUrgentBandwidth, 6112dda4fb85SAurabindo Pillai bool *PrefetchBandwidthSupport) 6113dda4fb85SAurabindo Pillai { 6114dda4fb85SAurabindo Pillai unsigned int k; 6115dda4fb85SAurabindo Pillai bool NotEnoughUrgentLatencyHiding = false; 6116dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6117dda4fb85SAurabindo Pillai if (NotUrgentLatencyHiding[k]) { 6118dda4fb85SAurabindo Pillai NotEnoughUrgentLatencyHiding = true; 6119dda4fb85SAurabindo Pillai } 6120dda4fb85SAurabindo Pillai } 6121dda4fb85SAurabindo Pillai 6122dda4fb85SAurabindo Pillai *PrefetchBandwidth = 0; 6123dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6124dda4fb85SAurabindo Pillai *PrefetchBandwidth = *PrefetchBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k], 6125dda4fb85SAurabindo Pillai ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]), 6126dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]); 6127dda4fb85SAurabindo Pillai } 6128dda4fb85SAurabindo Pillai 6129dda4fb85SAurabindo Pillai *PrefetchBandwidthSupport = (*PrefetchBandwidth <= ReturnBW) && !NotEnoughUrgentLatencyHiding; 6130dda4fb85SAurabindo Pillai *FractionOfUrgentBandwidth = *PrefetchBandwidth / ReturnBW; 6131dda4fb85SAurabindo Pillai } 6132dda4fb85SAurabindo Pillai 6133dda4fb85SAurabindo Pillai double dml32_CalculateBandwidthAvailableForImmediateFlip(unsigned int NumberOfActiveSurfaces, 6134dda4fb85SAurabindo Pillai double ReturnBW, 6135dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 6136dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 6137dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[], 6138dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[], 6139dda4fb85SAurabindo Pillai double cursor_bw[], 6140dda4fb85SAurabindo Pillai double cursor_bw_pre[], 6141dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 6142dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[], 6143dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[], 6144dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[], 6145dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[], 6146dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[], 6147dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[]) 6148dda4fb85SAurabindo Pillai { 6149dda4fb85SAurabindo Pillai unsigned int k; 6150dda4fb85SAurabindo Pillai double CalculateBandwidthAvailableForImmediateFlip_val = ReturnBW; 6151dda4fb85SAurabindo Pillai 6152dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6153dda4fb85SAurabindo Pillai CalculateBandwidthAvailableForImmediateFlip_val = CalculateBandwidthAvailableForImmediateFlip_val - dml_max(ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k], 6154dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]); 6155dda4fb85SAurabindo Pillai } 6156dda4fb85SAurabindo Pillai 6157dda4fb85SAurabindo Pillai return CalculateBandwidthAvailableForImmediateFlip_val; 6158dda4fb85SAurabindo Pillai } 6159dda4fb85SAurabindo Pillai 6160dda4fb85SAurabindo Pillai void dml32_CalculateImmediateFlipBandwithSupport(unsigned int NumberOfActiveSurfaces, 6161dda4fb85SAurabindo Pillai double ReturnBW, 6162dda4fb85SAurabindo Pillai enum immediate_flip_requirement ImmediateFlipRequirement[], 6163dda4fb85SAurabindo Pillai double final_flip_bw[], 6164dda4fb85SAurabindo Pillai double ReadBandwidthLuma[], 6165dda4fb85SAurabindo Pillai double ReadBandwidthChroma[], 6166dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[], 6167dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[], 6168dda4fb85SAurabindo Pillai double cursor_bw[], 6169dda4fb85SAurabindo Pillai double meta_row_bandwidth[], 6170dda4fb85SAurabindo Pillai double dpte_row_bandwidth[], 6171dda4fb85SAurabindo Pillai double cursor_bw_pre[], 6172dda4fb85SAurabindo Pillai double prefetch_vmrow_bw[], 6173dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[], 6174dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[], 6175dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[], 6176dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[], 6177dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[], 6178dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[], 6179dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[], 6180dda4fb85SAurabindo Pillai 6181dda4fb85SAurabindo Pillai /* output */ 6182dda4fb85SAurabindo Pillai double *TotalBandwidth, 6183dda4fb85SAurabindo Pillai double *FractionOfUrgentBandwidth, 6184dda4fb85SAurabindo Pillai bool *ImmediateFlipBandwidthSupport) 6185dda4fb85SAurabindo Pillai { 6186dda4fb85SAurabindo Pillai unsigned int k; 6187dda4fb85SAurabindo Pillai *TotalBandwidth = 0; 6188dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) { 6189dda4fb85SAurabindo Pillai if (ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) { 6190dda4fb85SAurabindo Pillai *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k], 6191dda4fb85SAurabindo Pillai NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k], 6192dda4fb85SAurabindo Pillai NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]); 6193dda4fb85SAurabindo Pillai } else { 6194dda4fb85SAurabindo Pillai *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k], 6195dda4fb85SAurabindo Pillai NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]) + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k], 6196dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]); 6197dda4fb85SAurabindo Pillai } 6198dda4fb85SAurabindo Pillai } 6199dda4fb85SAurabindo Pillai *ImmediateFlipBandwidthSupport = (*TotalBandwidth <= ReturnBW); 6200dda4fb85SAurabindo Pillai *FractionOfUrgentBandwidth = *TotalBandwidth / ReturnBW; 6201dda4fb85SAurabindo Pillai } 6202