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