1 /* 2 ************************************************************************************************************************ 3 * 4 * Copyright (C) 2022-2024 Advanced Micro Devices, Inc. All rights reserved. 5 * SPDX-License-Identifier: MIT 6 * 7 ***********************************************************************************************************************/ 8 9 /** 10 ************************************************************************************************************************ 11 * @file gfx12addrlib.h 12 * @brief Contains the Gfx12Lib class definition. 13 ************************************************************************************************************************ 14 */ 15 16 #ifndef __GFX12_ADDR_LIB_H__ 17 #define __GFX12_ADDR_LIB_H__ 18 19 #include "addrlib3.h" 20 #include "coord.h" 21 #include "gfx12SwizzlePattern.h" 22 23 24 namespace Addr 25 { 26 namespace V3 27 { 28 29 /** 30 ************************************************************************************************************************ 31 * @brief This class is the GFX12 specific address library 32 * function set. 33 ************************************************************************************************************************ 34 */ 35 class Gfx12Lib : public Lib 36 { 37 public: 38 /// Creates Gfx12Lib object CreateObj(const Client * pClient)39 static Addr::Lib* CreateObj(const Client* pClient) 40 { 41 VOID* pMem = Object::ClientAlloc(sizeof(Gfx12Lib), pClient); 42 return (pMem != NULL) ? new (pMem) Gfx12Lib(pClient) : NULL; 43 } 44 45 protected: 46 Gfx12Lib(const Client* pClient); 47 virtual ~Gfx12Lib(); 48 49 // Meta surfaces such as Hi-S/Z are essentially images on GFX12, so just return the max 50 // image alignment. HwlComputeMaxMetaBaseAlignments()51 virtual UINT_32 HwlComputeMaxMetaBaseAlignments() const override { return 256 * 1024; } 52 53 UINT_32 GetMaxNumMipsInTail( 54 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn) const; 55 IsInMipTail(const ADDR_EXTENT3D & mipTailDim,const ADDR_EXTENT3D & mipDims,INT_32 maxNumMipsInTail,INT_32 numMipsToTheEnd)56 BOOL_32 IsInMipTail( 57 const ADDR_EXTENT3D& mipTailDim, ///< The output of GetMipTailDim() function which is dimensions of the 58 /// largest mip level in the tail (again, only 4kb/64kb/256kb block). 59 const ADDR_EXTENT3D& mipDims, ///< The dimensions of the mip level being queried now. 60 INT_32 maxNumMipsInTail, ///< The output of GetMaxNumMipsInTail() function which is the maximal 61 /// number of the mip levels that could fit in the tail of larger 62 /// block. 63 INT_32 numMipsToTheEnd ///< This is (numMipLevels - mipIdx) and it may be negative when called 64 /// in SanityCheckSurfSize() since mipIdx has to be in [0, 16]. 65 ) const 66 { 67 BOOL_32 inTail = ((mipDims.width <= mipTailDim.width) && 68 (mipDims.height <= mipTailDim.height) && 69 (numMipsToTheEnd <= maxNumMipsInTail)); 70 71 return inTail; 72 } 73 74 virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordLinear( 75 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 76 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pSurfInfoIn, 77 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const override; 78 79 virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordTiled( 80 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 81 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const override; 82 83 virtual ADDR_E_RETURNCODE HwlComputeNonBlockCompressedView( 84 const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, 85 ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) const override; 86 87 virtual VOID HwlComputeSubResourceOffsetForSwizzlePattern( 88 const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, 89 ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const override; 90 91 virtual ADDR_E_RETURNCODE HwlComputeSlicePipeBankXor( 92 const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, 93 ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const override; 94 95 virtual UINT_32 HwlGetEquationIndex( 96 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const override; 97 HwlGetEquationTableInfo(const ADDR_EQUATION ** ppEquationTable)98 virtual UINT_32 HwlGetEquationTableInfo(const ADDR_EQUATION** ppEquationTable) const override 99 { 100 *ppEquationTable = m_equationTable; 101 102 return m_numEquations; 103 } 104 105 BOOL_32 HwlValidateNonSwModeParams(const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn) const override; 106 107 virtual ADDR_E_RETURNCODE HwlGetPossibleSwizzleModes( 108 const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn, 109 ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT* pOut) const override; 110 111 virtual ChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision) override; 112 113 protected: 114 virtual VOID HwlCalcBlockSize( 115 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 116 ADDR_EXTENT3D* pExtent) const override final; 117 118 ADDR_EXTENT3D HwlGetMicroBlockSize( 119 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn) const; 120 121 virtual ADDR_EXTENT3D HwlGetMipInTailMaxSize( 122 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 123 const ADDR_EXTENT3D& blockDims) const override final; 124 125 private: 126 static const SwizzleModeFlags SwizzleModeTable[ADDR3_MAX_TYPE]; 127 128 // Number of unique swizzle patterns (one entry per swizzle mode + MSAA + bpp configuration) 129 static const UINT_32 NumSwizzlePatterns = 19 * MaxElementBytesLog2; 130 131 // Equation table 132 ADDR_EQUATION m_equationTable[NumSwizzlePatterns]; 133 134 /** 135 ************************************************************************************************************************ 136 * @brief Bitmasks for swizzle mode determination on GFX12 137 ************************************************************************************************************************ 138 */ 139 static const UINT_32 Blk256KBSwModeMask = (1u << ADDR3_256KB_2D) | 140 (1u << ADDR3_256KB_3D); 141 static const UINT_32 Blk64KBSwModeMask = (1u << ADDR3_64KB_2D) | 142 (1u << ADDR3_64KB_3D); 143 static const UINT_32 Blk4KBSwModeMask = (1u << ADDR3_4KB_2D) | 144 (1u << ADDR3_4KB_3D); 145 static const UINT_32 Blk256BSwModeMask = (1u << ADDR3_256B_2D); 146 147 static const UINT_32 MaxImageDim = 32768; // Max image size is 32k 148 static const UINT_32 MaxMipLevels = 16; 149 150 virtual ADDR_E_RETURNCODE HwlComputePipeBankXor( 151 const ADDR3_COMPUTE_PIPEBANKXOR_INPUT* pIn, 152 ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const override; 153 154 virtual BOOL_32 HwlInitGlobalParams(const ADDR_CREATE_INPUT* pCreateIn) override; 155 156 virtual ADDR_E_RETURNCODE HwlComputeStereoInfo( 157 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 158 UINT_32* pAlignY, 159 UINT_32* pRightXor) const override; 160 161 void SanityCheckSurfSize( 162 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 163 const ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 164 165 virtual ADDR_E_RETURNCODE HwlCopyMemToSurface( 166 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 167 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 168 UINT_32 regionCount) const override; 169 170 virtual ADDR_E_RETURNCODE HwlCopySurfaceToMem( 171 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 172 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 173 UINT_32 regionCount) const override; 174 175 UINT_32 m_numSwizzleBits; 176 177 // Initialize equation table 178 VOID InitEquationTable(); 179 180 // Initialize block dimension table 181 VOID InitBlockDimensionTable(); 182 GetSwizzlePatternFromPatternInfo(const ADDR_SW_PATINFO * pPatInfo,ADDR_BIT_SETTING (& pSwizzle)[Log2Size256K])183 VOID GetSwizzlePatternFromPatternInfo( 184 const ADDR_SW_PATINFO* pPatInfo, 185 ADDR_BIT_SETTING (&pSwizzle)[Log2Size256K]) const 186 { 187 memcpy(pSwizzle, 188 GFX12_SW_PATTERN_NIBBLE1[pPatInfo->nibble1Idx], 189 sizeof(GFX12_SW_PATTERN_NIBBLE1[pPatInfo->nibble1Idx])); 190 191 memcpy(&pSwizzle[8], 192 GFX12_SW_PATTERN_NIBBLE2[pPatInfo->nibble2Idx], 193 sizeof(GFX12_SW_PATTERN_NIBBLE2[pPatInfo->nibble2Idx])); 194 195 memcpy(&pSwizzle[12], 196 GFX12_SW_PATTERN_NIBBLE3[pPatInfo->nibble3Idx], 197 sizeof(GFX12_SW_PATTERN_NIBBLE3[pPatInfo->nibble3Idx])); 198 199 memcpy(&pSwizzle[16], 200 GFX12_SW_PATTERN_NIBBLE4[pPatInfo->nibble4Idx], 201 sizeof(GFX12_SW_PATTERN_NIBBLE4[pPatInfo->nibble4Idx])); 202 } 203 204 VOID ConvertSwizzlePatternToEquation( 205 UINT_32 elemLog2, 206 Addr3SwizzleMode swMode, 207 const ADDR_SW_PATINFO* pPatInfo, 208 ADDR_EQUATION* pEquation) const; 209 210 ADDR_EXTENT3D GetBaseMipExtents( 211 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 212 213 INT_32 CalcMipInTail( 214 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 215 const ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut, 216 UINT_32 mipLevel) const; 217 218 UINT_32 CalcMipOffset( 219 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 220 UINT_32 mipInTail) const; 221 222 virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo( 223 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 224 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const override; 225 GetMipExtent(const ADDR_EXTENT3D & mip0,UINT_32 mipId)226 static ADDR_EXTENT3D GetMipExtent( 227 const ADDR_EXTENT3D& mip0, 228 UINT_32 mipId) 229 { 230 return { 231 ShiftCeil(Max(mip0.width, 1u), mipId), 232 ShiftCeil(Max(mip0.height, 1u), mipId), 233 ShiftCeil(Max(mip0.depth, 1u), mipId) 234 }; 235 } 236 237 UINT_32 ComputeOffsetFromEquation( 238 const ADDR_EQUATION* pEq, 239 UINT_32 x, 240 UINT_32 y, 241 UINT_32 z, 242 UINT_32 s) const; 243 244 const ADDR_SW_PATINFO* GetSwizzlePatternInfo( 245 Addr3SwizzleMode swizzleMode, 246 UINT_32 log2Elem, 247 UINT_32 numFrag) const; 248 249 VOID GetMipOffset( 250 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 251 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 252 253 VOID GetMipOrigin( 254 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 255 const ADDR_EXTENT3D& mipExtentFirstInTail, 256 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 257 258 }; 259 260 } // V3 261 } // Addr 262 263 #endif 264