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