src/amd/addrlib/src/core/addrlib1.h

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