1 /* 2 ************************************************************************************************************************ 3 * 4 * Copyright (C) 2007-2024 Advanced Micro Devices, Inc. All rights reserved. 5 * SPDX-License-Identifier: MIT 6 * 7 ***********************************************************************************************************************/ 8 9 10 /** 11 **************************************************************************************************** 12 * @file addrlib1.h 13 * @brief Contains the Addr::V1::Lib class definition. 14 **************************************************************************************************** 15 */ 16 17 #ifndef __ADDR_LIB1_H__ 18 #define __ADDR_LIB1_H__ 19 20 #include "addrlib.h" 21 22 namespace Addr 23 { 24 namespace V1 25 { 26 27 /** 28 **************************************************************************************************** 29 * @brief Neutral enums that define bank swap size 30 **************************************************************************************************** 31 */ 32 enum SampleSplitSize 33 { 34 ADDR_SAMPLESPLIT_1KB = 1024, 35 ADDR_SAMPLESPLIT_2KB = 2048, 36 ADDR_SAMPLESPLIT_4KB = 4096, 37 ADDR_SAMPLESPLIT_8KB = 8192, 38 }; 39 40 /** 41 **************************************************************************************************** 42 * @brief Flags for AddrTileMode 43 **************************************************************************************************** 44 */ 45 struct TileModeFlags 46 { 47 UINT_32 thickness : 4; 48 UINT_32 isLinear : 1; 49 UINT_32 isMicro : 1; 50 UINT_32 isMacro : 1; 51 UINT_32 isMacro3d : 1; 52 UINT_32 isPrt : 1; 53 UINT_32 isPrtNoRotation : 1; 54 UINT_32 isBankSwapped : 1; 55 }; 56 57 static const UINT_32 Block64K = 0x10000; 58 static const UINT_32 PrtTileSize = Block64K; 59 60 /** 61 **************************************************************************************************** 62 * @brief This class contains asic independent address lib functionalities 63 **************************************************************************************************** 64 */ 65 class Lib : public Addr::Lib 66 { 67 public: 68 virtual ~Lib(); 69 70 static Lib* GetLib( 71 ADDR_HANDLE hLib); 72 GetInterfaceVersion()73 virtual UINT_32 GetInterfaceVersion() const 74 { 75 return 1; 76 } 77 78 /// Returns tileIndex support UseTileIndex(INT_32 index)79 BOOL_32 UseTileIndex(INT_32 index) const 80 { 81 return m_configFlags.useTileIndex && (index != TileIndexInvalid); 82 } 83 84 /// Returns combined swizzle support UseCombinedSwizzle()85 BOOL_32 UseCombinedSwizzle() const 86 { 87 return m_configFlags.useCombinedSwizzle; 88 } 89 90 // 91 // Interface stubs 92 // 93 ADDR_E_RETURNCODE ComputeSurfaceInfo( 94 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, 95 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 96 97 ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoord( 98 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 99 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const; 100 101 ADDR_E_RETURNCODE ComputeSurfaceCoordFromAddr( 102 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, 103 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const; 104 105 ADDR_E_RETURNCODE ComputeSliceTileSwizzle( 106 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, 107 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut) const; 108 109 ADDR_E_RETURNCODE ExtractBankPipeSwizzle( 110 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, 111 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) const; 112 113 ADDR_E_RETURNCODE CombineBankPipeSwizzle( 114 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, 115 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut) const; 116 117 ADDR_E_RETURNCODE ComputeBaseSwizzle( 118 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn, 119 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) const; 120 121 ADDR_E_RETURNCODE ComputeFmaskInfo( 122 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, 123 ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut); 124 125 ADDR_E_RETURNCODE ComputeFmaskAddrFromCoord( 126 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, 127 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) const; 128 129 ADDR_E_RETURNCODE ComputeFmaskCoordFromAddr( 130 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, 131 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) const; 132 133 ADDR_E_RETURNCODE ConvertTileInfoToHW( 134 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, 135 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) const; 136 137 ADDR_E_RETURNCODE ConvertTileIndex( 138 const ADDR_CONVERT_TILEINDEX_INPUT* pIn, 139 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) const; 140 141 ADDR_E_RETURNCODE GetMacroModeIndex( 142 const ADDR_GET_MACROMODEINDEX_INPUT* pIn, 143 ADDR_GET_MACROMODEINDEX_OUTPUT* pOut) const; 144 145 ADDR_E_RETURNCODE ConvertTileIndex1( 146 const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, 147 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) const; 148 149 ADDR_E_RETURNCODE GetTileIndex( 150 const ADDR_GET_TILEINDEX_INPUT* pIn, 151 ADDR_GET_TILEINDEX_OUTPUT* pOut) const; 152 153 ADDR_E_RETURNCODE ComputeHtileInfo( 154 const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, 155 ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) const; 156 157 ADDR_E_RETURNCODE ComputeCmaskInfo( 158 const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, 159 ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) const; 160 161 ADDR_E_RETURNCODE ComputeDccInfo( 162 const ADDR_COMPUTE_DCCINFO_INPUT* pIn, 163 ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) const; 164 165 ADDR_E_RETURNCODE ComputeHtileAddrFromCoord( 166 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, 167 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) const; 168 169 ADDR_E_RETURNCODE ComputeCmaskAddrFromCoord( 170 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, 171 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) const; 172 173 ADDR_E_RETURNCODE ComputeHtileCoordFromAddr( 174 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, 175 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) const; 176 177 ADDR_E_RETURNCODE ComputeCmaskCoordFromAddr( 178 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, 179 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) const; 180 181 ADDR_E_RETURNCODE ComputePrtInfo( 182 const ADDR_PRT_INFO_INPUT* pIn, 183 ADDR_PRT_INFO_OUTPUT* pOut) const; 184 protected: 185 Lib(); // Constructor is protected 186 Lib(const Client* pClient); 187 188 /// Pure Virtual function for Hwl computing surface info 189 virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo( 190 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, 191 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const = 0; 192 193 /// Pure Virtual function for Hwl computing surface address from coord 194 virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoord( 195 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 196 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const = 0; 197 198 /// Pure Virtual function for Hwl computing surface coord from address 199 virtual ADDR_E_RETURNCODE HwlComputeSurfaceCoordFromAddr( 200 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, 201 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const = 0; 202 203 /// Pure Virtual function for Hwl computing surface tile swizzle 204 virtual ADDR_E_RETURNCODE HwlComputeSliceTileSwizzle( 205 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, 206 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut) const = 0; 207 208 /// Pure Virtual function for Hwl extracting bank/pipe swizzle from base256b 209 virtual ADDR_E_RETURNCODE HwlExtractBankPipeSwizzle( 210 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, 211 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) const = 0; 212 213 /// Pure Virtual function for Hwl combining bank/pipe swizzle 214 virtual ADDR_E_RETURNCODE HwlCombineBankPipeSwizzle( 215 UINT_32 bankSwizzle, UINT_32 pipeSwizzle, ADDR_TILEINFO* pTileInfo, 216 UINT_64 baseAddr, UINT_32* pTileSwizzle) const = 0; 217 218 /// Pure Virtual function for Hwl computing base swizzle 219 virtual ADDR_E_RETURNCODE HwlComputeBaseSwizzle( 220 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn, 221 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) const = 0; 222 223 /// Pure Virtual function for Hwl computing HTILE base align 224 virtual UINT_32 HwlComputeHtileBaseAlign( 225 BOOL_32 isTcCompatible, BOOL_32 isLinear, ADDR_TILEINFO* pTileInfo) const = 0; 226 227 /// Pure Virtual function for Hwl computing HTILE bpp 228 virtual UINT_32 HwlComputeHtileBpp( 229 BOOL_32 isWidth8, BOOL_32 isHeight8) const = 0; 230 231 /// Pure Virtual function for Hwl computing HTILE bytes 232 virtual UINT_64 HwlComputeHtileBytes( 233 UINT_32 pitch, UINT_32 height, UINT_32 bpp, 234 BOOL_32 isLinear, UINT_32 numSlices, UINT_64* pSliceBytes, UINT_32 baseAlign) const = 0; 235 236 /// Pure Virtual function for Hwl computing FMASK info 237 virtual ADDR_E_RETURNCODE HwlComputeFmaskInfo( 238 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, 239 ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) = 0; 240 241 /// Pure Virtual function for Hwl FMASK address from coord 242 virtual ADDR_E_RETURNCODE HwlComputeFmaskAddrFromCoord( 243 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, 244 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) const = 0; 245 246 /// Pure Virtual function for Hwl FMASK coord from address 247 virtual ADDR_E_RETURNCODE HwlComputeFmaskCoordFromAddr( 248 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, 249 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) const = 0; 250 251 /// Pure Virtual function for Hwl convert tile info from real value to HW value 252 virtual ADDR_E_RETURNCODE HwlConvertTileInfoToHW( 253 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, 254 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) const = 0; 255 256 /// Pure Virtual function for Hwl compute mipmap info 257 virtual BOOL_32 HwlComputeMipLevel( 258 ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const = 0; 259 260 /// Pure Virtual function for Hwl compute max cmask blockMax value 261 virtual BOOL_32 HwlGetMaxCmaskBlockMax() const = 0; 262 263 /// Pure Virtual function for Hwl compute fmask bits 264 virtual UINT_32 HwlComputeFmaskBits( 265 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, 266 UINT_32* pNumSamples) const = 0; 267 268 /// Virtual function to get index (not pure then no need to implement this in all hwls HwlGetTileIndex(const ADDR_GET_TILEINDEX_INPUT * pIn,ADDR_GET_TILEINDEX_OUTPUT * pOut)269 virtual ADDR_E_RETURNCODE HwlGetTileIndex( 270 const ADDR_GET_TILEINDEX_INPUT* pIn, 271 ADDR_GET_TILEINDEX_OUTPUT* pOut) const 272 { 273 return ADDR_NOTSUPPORTED; 274 } 275 276 /// Virtual function for Hwl to compute Dcc info HwlComputeDccInfo(const ADDR_COMPUTE_DCCINFO_INPUT * pIn,ADDR_COMPUTE_DCCINFO_OUTPUT * pOut)277 virtual ADDR_E_RETURNCODE HwlComputeDccInfo( 278 const ADDR_COMPUTE_DCCINFO_INPUT* pIn, 279 ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) const 280 { 281 return ADDR_NOTSUPPORTED; 282 } 283 284 /// Virtual function to get cmask address for tc compatible cmask HwlComputeCmaskAddrFromCoord(const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)285 virtual ADDR_E_RETURNCODE HwlComputeCmaskAddrFromCoord( 286 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, 287 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) const 288 { 289 return ADDR_NOTSUPPORTED; 290 } 291 292 /// Virtual function to get htile address for tc compatible htile HwlComputeHtileAddrFromCoord(const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)293 virtual ADDR_E_RETURNCODE HwlComputeHtileAddrFromCoord( 294 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, 295 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) const 296 { 297 return ADDR_NOTSUPPORTED; 298 } 299 300 // Compute attributes 301 302 // HTILE 303 UINT_32 ComputeHtileInfo( 304 ADDR_HTILE_FLAGS flags, 305 UINT_32 pitchIn, UINT_32 heightIn, UINT_32 numSlices, 306 BOOL_32 isLinear, BOOL_32 isWidth8, BOOL_32 isHeight8, 307 ADDR_TILEINFO* pTileInfo, 308 UINT_32* pPitchOut, UINT_32* pHeightOut, UINT_64* pHtileBytes, 309 UINT_32* pMacroWidth = NULL, UINT_32* pMacroHeight = NULL, 310 UINT_64* pSliceSize = NULL, UINT_32* pBaseAlign = NULL) const; 311 312 // CMASK 313 ADDR_E_RETURNCODE ComputeCmaskInfo( 314 ADDR_CMASK_FLAGS flags, 315 UINT_32 pitchIn, UINT_32 heightIn, UINT_32 numSlices, BOOL_32 isLinear, 316 ADDR_TILEINFO* pTileInfo, UINT_32* pPitchOut, UINT_32* pHeightOut, UINT_64* pCmaskBytes, 317 UINT_32* pMacroWidth, UINT_32* pMacroHeight, UINT_64* pSliceSize = NULL, 318 UINT_32* pBaseAlign = NULL, UINT_32* pBlockMax = NULL) const; 319 320 virtual VOID HwlComputeTileDataWidthAndHeightLinear( 321 UINT_32* pMacroWidth, UINT_32* pMacroHeight, 322 UINT_32 bpp, ADDR_TILEINFO* pTileInfo) const; 323 324 // CMASK & HTILE addressing 325 virtual UINT_64 HwlComputeXmaskAddrFromCoord( 326 UINT_32 pitch, UINT_32 height, UINT_32 x, UINT_32 y, UINT_32 slice, 327 UINT_32 numSlices, UINT_32 factor, BOOL_32 isLinear, BOOL_32 isWidth8, 328 BOOL_32 isHeight8, ADDR_TILEINFO* pTileInfo, 329 UINT_32* bitPosition) const; 330 331 virtual VOID HwlComputeXmaskCoordFromAddr( 332 UINT_64 addr, UINT_32 bitPosition, UINT_32 pitch, UINT_32 height, UINT_32 numSlices, 333 UINT_32 factor, BOOL_32 isLinear, BOOL_32 isWidth8, BOOL_32 isHeight8, 334 ADDR_TILEINFO* pTileInfo, UINT_32* pX, UINT_32* pY, UINT_32* pSlice) const; 335 336 // Surface mipmap 337 VOID ComputeMipLevel( 338 ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 339 340 /// Pure Virtual function for Hwl to get macro tiled alignment info 341 virtual BOOL_32 HwlGetAlignmentInfoMacroTiled( 342 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, 343 UINT_32* pPitchAlign, UINT_32* pHeightAlign, UINT_32* pSizeAlign) const = 0; 344 345 HwlOverrideTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT * pInOut)346 virtual VOID HwlOverrideTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut) const 347 { 348 // not supported in hwl layer 349 } 350 HwlOptimizeTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT * pInOut)351 virtual VOID HwlOptimizeTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut) const 352 { 353 // not supported in hwl layer 354 } 355 HwlSelectTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT * pInOut)356 virtual VOID HwlSelectTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut) const 357 { 358 // not supported in hwl layer 359 } 360 361 AddrTileMode DegradeLargeThickTile(AddrTileMode tileMode, UINT_32 bpp) const; 362 363 VOID PadDimensions( 364 AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags, 365 UINT_32 numSamples, ADDR_TILEINFO* pTileInfo, UINT_32 padDims, UINT_32 mipLevel, 366 UINT_32* pPitch, UINT_32* pPitchAlign, UINT_32* pHeight, UINT_32 heightAlign, 367 UINT_32* pSlices, UINT_32 sliceAlign) const; 368 HwlPadDimensions(AddrTileMode tileMode,UINT_32 bpp,ADDR_SURFACE_FLAGS flags,UINT_32 numSamples,ADDR_TILEINFO * pTileInfo,UINT_32 mipLevel,UINT_32 * pPitch,UINT_32 * pPitchAlign,UINT_32 height,UINT_32 heightAlign)369 virtual VOID HwlPadDimensions( 370 AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags, 371 UINT_32 numSamples, ADDR_TILEINFO* pTileInfo, UINT_32 mipLevel, 372 UINT_32* pPitch, UINT_32* pPitchAlign, UINT_32 height, UINT_32 heightAlign) const 373 { 374 } 375 376 // 377 // Addressing shared for linear/1D tiling 378 // 379 UINT_64 ComputeSurfaceAddrFromCoordLinear( 380 UINT_32 x, UINT_32 y, UINT_32 slice, UINT_32 sample, 381 UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSlices, 382 UINT_32* pBitPosition) const; 383 384 VOID ComputeSurfaceCoordFromAddrLinear( 385 UINT_64 addr, UINT_32 bitPosition, UINT_32 bpp, 386 UINT_32 pitch, UINT_32 height, UINT_32 numSlices, 387 UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample) const; 388 389 VOID ComputeSurfaceCoordFromAddrMicroTiled( 390 UINT_64 addr, UINT_32 bitPosition, 391 UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples, 392 AddrTileMode tileMode, UINT_32 tileBase, UINT_32 compBits, 393 UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample, 394 AddrTileType microTileType, BOOL_32 isDepthSampleOrder) const; 395 396 ADDR_E_RETURNCODE ComputeMicroTileEquation( 397 UINT_32 bpp, AddrTileMode tileMode, 398 AddrTileType microTileType, ADDR_EQUATION* pEquation) const; 399 400 UINT_32 ComputePixelIndexWithinMicroTile( 401 UINT_32 x, UINT_32 y, UINT_32 z, 402 UINT_32 bpp, AddrTileMode tileMode, AddrTileType microTileType) const; 403 404 /// Pure Virtual function for Hwl computing coord from offset inside micro tile 405 virtual VOID HwlComputePixelCoordFromOffset( 406 UINT_32 offset, UINT_32 bpp, UINT_32 numSamples, 407 AddrTileMode tileMode, UINT_32 tileBase, UINT_32 compBits, 408 UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample, 409 AddrTileType microTileType, BOOL_32 isDepthSampleOrder) const = 0; 410 411 // 412 // Addressing shared by all 413 // 414 virtual UINT_32 HwlGetPipes( 415 const ADDR_TILEINFO* pTileInfo) const; 416 417 UINT_32 ComputePipeFromAddr( 418 UINT_64 addr, UINT_32 numPipes) const; 419 ComputePipeEquation(UINT_32 log2BytesPP,UINT_32 threshX,UINT_32 threshY,ADDR_TILEINFO * pTileInfo,ADDR_EQUATION * pEquation)420 virtual ADDR_E_RETURNCODE ComputePipeEquation( 421 UINT_32 log2BytesPP, UINT_32 threshX, UINT_32 threshY, ADDR_TILEINFO* pTileInfo, ADDR_EQUATION* pEquation) const 422 { 423 return ADDR_NOTSUPPORTED; 424 } 425 426 /// Pure Virtual function for Hwl computing pipe from coord 427 virtual UINT_32 ComputePipeFromCoord( 428 UINT_32 x, UINT_32 y, UINT_32 slice, AddrTileMode tileMode, 429 UINT_32 pipeSwizzle, BOOL_32 flags, ADDR_TILEINFO* pTileInfo) const = 0; 430 431 /// Pure Virtual function for Hwl computing coord Y for 8 pipe cmask/htile 432 virtual UINT_32 HwlComputeXmaskCoordYFrom8Pipe( 433 UINT_32 pipe, UINT_32 x) const = 0; 434 435 // 436 // Misc helper 437 // 438 static const TileModeFlags ModeFlags[ADDR_TM_COUNT]; 439 440 static UINT_32 Thickness( 441 AddrTileMode tileMode); 442 443 // Checking tile mode 444 static BOOL_32 IsMacroTiled(AddrTileMode tileMode); 445 static BOOL_32 IsMacro3dTiled(AddrTileMode tileMode); 446 static BOOL_32 IsLinear(AddrTileMode tileMode); 447 static BOOL_32 IsMicroTiled(AddrTileMode tileMode); 448 static BOOL_32 IsPrtTileMode(AddrTileMode tileMode); 449 static BOOL_32 IsPrtNoRotationTileMode(AddrTileMode tileMode); 450 451 /// Return TRUE if tile info is needed UseTileInfo()452 BOOL_32 UseTileInfo() const 453 { 454 return !m_configFlags.ignoreTileInfo; 455 } 456 457 /// Adjusts pitch alignment for flipping surface 458 VOID AdjustPitchAlignment( 459 ADDR_SURFACE_FLAGS flags, UINT_32* pPitchAlign) const; 460 461 /// Overwrite tile config according to tile index 462 virtual ADDR_E_RETURNCODE HwlSetupTileCfg( 463 UINT_32 bpp, INT_32 index, INT_32 macroModeIndex, 464 ADDR_TILEINFO* pInfo, AddrTileMode* mode = NULL, AddrTileType* type = NULL) const; 465 466 /// Overwrite macro tile config according to tile index 467 virtual INT_32 HwlComputeMacroModeIndex( 468 INT_32 index, ADDR_SURFACE_FLAGS flags, UINT_32 bpp, UINT_32 numSamples, 469 ADDR_TILEINFO* pTileInfo, AddrTileMode *pTileMode = NULL, AddrTileType *pTileType = NULL 470 ) const 471 { 472 return TileIndexNoMacroIndex; 473 } 474 475 /// Pre-handler of 3x pitch (96 bit) adjustment 476 virtual UINT_32 HwlPreHandleBaseLvl3xPitch( 477 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, UINT_32 expPitch) const; 478 /// Post-handler of 3x pitch adjustment 479 virtual UINT_32 HwlPostHandleBaseLvl3xPitch( 480 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, UINT_32 expPitch) const; 481 /// Check miplevel after surface adjustment 482 ADDR_E_RETURNCODE PostComputeMipLevel( 483 ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, 484 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 485 486 /// Quad buffer stereo support, has its implementation in ind. layer 487 VOID ComputeQbStereoInfo( 488 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 489 490 /// Pure virutual function to compute stereo bank swizzle for right eye 491 virtual UINT_32 HwlComputeQbStereoRightSwizzle( 492 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const = 0; 493 494 VOID OptimizeTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut) const; 495 496 /// Overwrite tile setting to PRT HwlSetPrtTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT * pInOut)497 virtual VOID HwlSetPrtTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut) const 498 { 499 } 500 501 static BOOL_32 DegradeTo1D( 502 UINT_32 width, UINT_32 height, 503 UINT_32 macroTilePitchAlign, UINT_32 macroTileHeightAlign); 504 505 private: 506 // Disallow the copy constructor 507 Lib(const Lib& a); 508 509 // Disallow the assignment operator 510 Lib& operator=(const Lib& a); 511 512 UINT_32 ComputeCmaskBaseAlign( 513 ADDR_CMASK_FLAGS flags, ADDR_TILEINFO* pTileInfo) const; 514 515 UINT_64 ComputeCmaskBytes( 516 UINT_32 pitch, UINT_32 height, UINT_32 numSlices) const; 517 518 // 519 // CMASK/HTILE shared methods 520 // 521 VOID ComputeTileDataWidthAndHeight( 522 UINT_32 bpp, UINT_32 cacheBits, ADDR_TILEINFO* pTileInfo, 523 UINT_32* pMacroWidth, UINT_32* pMacroHeight) const; 524 525 UINT_32 ComputeXmaskCoordYFromPipe( 526 UINT_32 pipe, UINT_32 x) const; 527 }; 528 529 } // V1 530 } // Addr 531 532 #endif 533 534