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 ************************************************************************************************************************ 12 * @file addrlib3.h 13 * @brief Contains the Addr::V3::Lib class definition. 14 ************************************************************************************************************************ 15 */ 16 17 #ifndef __ADDR3_LIB3_H__ 18 #define __ADDR3_LIB3_H__ 19 20 #include "addrlib.h" 21 22 namespace Addr 23 { 24 namespace V3 25 { 26 27 constexpr UINT_32 Size256 = 256u; 28 constexpr UINT_32 Size4K = 4 * 1024; 29 constexpr UINT_32 Size64K = 64 * 1024; 30 constexpr UINT_32 Size256K = 256 * 1024; 31 constexpr UINT_32 Addr3MaxMipLevels = 16; // Max Mip Levels across all addr3 chips 32 33 struct ADDR3_COORD 34 { 35 INT_32 x; 36 INT_32 y; 37 INT_32 z; 38 }; 39 40 // The HW address library utilizes an "addr_params" structure that is GPU-specific; therefore, we use a "void" pointer 41 // here to allow the HWL's to interpret this pointer with the appropriate structure. 42 // To reduce the frequency of conversion between the "ADDR3_COMPUTE_SURFACE_INFO_INPUT" structure and the "addr_params" 43 // structure, we create this super-structure to tie the two structures together. 44 struct ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT 45 { 46 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pSurfInfo; 47 void* pvAddrParams; 48 }; 49 50 /** 51 ************************************************************************************************************************ 52 * @brief Flags for SwizzleModeTable 53 ************************************************************************************************************************ 54 */ 55 union SwizzleModeFlags 56 { 57 struct 58 { 59 // Swizzle mode 60 UINT_32 isLinear : 1; // Linear 61 UINT_32 is2d : 1; // 2d mode 62 UINT_32 is3d : 1; // 3d mode 63 64 // Block size 65 UINT_32 is256b : 1; // Block size is 256B 66 UINT_32 is4kb : 1; // Block size is 4KB 67 UINT_32 is64kb : 1; // Block size is 64KB 68 UINT_32 is256kb : 1; // Block size is 256KB 69 70 UINT_32 reserved : 25; // Reserved bits 71 }; 72 73 UINT_32 u32All; 74 }; 75 76 const UINT_32 Log2Size256 = 8u; 77 78 const UINT_32 Log2Size256K = 18u; 79 80 /** 81 ************************************************************************************************************************ 82 * @brief Swizzle pattern information 83 ************************************************************************************************************************ 84 */ 85 // Accessed by index representing the logbase2 of (8bpp/16bpp/32bpp/64bpp/128bpp) 86 // contains the indices which map to 2D arrays SW_PATTERN_NIBBLE[1-4] which contain sections of an index equation. 87 struct ADDR_SW_PATINFO 88 { 89 UINT_8 nibble1Idx; 90 UINT_8 nibble2Idx; 91 UINT_8 nibble3Idx; 92 UINT_8 nibble4Idx; 93 }; 94 95 /** 96 ************************************************************************************************************************ 97 * @brief This class contains asic independent address lib functionalities 98 ************************************************************************************************************************ 99 */ 100 class Lib : public Addr::Lib 101 { 102 public: 103 virtual ~Lib(); 104 105 static Lib* GetLib( 106 ADDR_HANDLE hLib); 107 GetInterfaceVersion()108 virtual UINT_32 GetInterfaceVersion() const 109 { 110 return 3; 111 } 112 113 // 114 // Interface stubs 115 // 116 117 // For data surface 118 ADDR_E_RETURNCODE ComputeSurfaceInfo( 119 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 120 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 121 122 ADDR_E_RETURNCODE GetPossibleSwizzleModes( 123 const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn, 124 ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT* pOut) const; 125 126 ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoord( 127 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 128 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const; 129 130 ADDR_E_RETURNCODE CopyMemToSurface( 131 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 132 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 133 UINT_32 regionCount) const; 134 135 ADDR_E_RETURNCODE CopySurfaceToMem( 136 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 137 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 138 UINT_32 regionCount) const; 139 140 // Misc 141 ADDR_E_RETURNCODE ComputePipeBankXor( 142 const ADDR3_COMPUTE_PIPEBANKXOR_INPUT* pIn, 143 ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT* pOut); 144 145 ADDR_E_RETURNCODE ComputeNonBlockCompressedView( 146 const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, 147 ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut); 148 149 ADDR_E_RETURNCODE ComputeSubResourceOffsetForSwizzlePattern( 150 const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, 151 ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut); 152 153 ADDR_E_RETURNCODE ComputeSlicePipeBankXor( 154 const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, 155 ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut); 156 157 protected: 158 Lib(); // Constructor is protected 159 Lib(const Client* pClient); 160 161 UINT_32 m_pipesLog2; ///< Number of pipe per shader engine Log2 162 UINT_32 m_pipeInterleaveLog2; ///< Log2 of pipe interleave bytes 163 164 SwizzleModeFlags m_swizzleModeTable[ADDR3_MAX_TYPE]; ///< Swizzle mode table 165 166 // Number of unique MSAA sample rates (1/2/4/8) 167 static const UINT_32 MaxNumMsaaRates = 4; 168 169 // Number of equation entries in the table 170 UINT_32 m_numEquations; 171 172 // Swizzle equation lookup table according to swizzle mode, MSAA sample rate and bpp. This does not include linear. 173 UINT_32 m_equationLookupTable[ADDR3_MAX_TYPE - 1][MaxNumMsaaRates][MaxElementBytesLog2]; 174 175 // Block dimension lookup table according to swizzle mode, MSAA sample rate and bpp. This includes linear. 176 ADDR_EXTENT3D m_blockDimensionTable[ADDR3_MAX_TYPE][MaxNumMsaaRates][MaxElementBytesLog2]; 177 178 virtual ADDR_E_RETURNCODE HwlComputeStereoInfo( 179 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 180 UINT_32* pAlignY, 181 UINT_32* pRightXor) const = 0; 182 SetEquationTableEntry(Addr3SwizzleMode swMode,UINT_32 msaaLog2,UINT_32 elementBytesLog2,UINT_32 value)183 void SetEquationTableEntry( 184 Addr3SwizzleMode swMode, 185 UINT_32 msaaLog2, 186 UINT_32 elementBytesLog2, 187 UINT_32 value) 188 { 189 // m_equationLookupTable doesn't include linear, so we must exclude linear when calling this function. 190 ADDR_ASSERT(swMode != ADDR3_LINEAR); 191 m_equationLookupTable[swMode - 1][msaaLog2][elementBytesLog2] = value; 192 } 193 GetEquationTableEntry(Addr3SwizzleMode swMode,UINT_32 msaaLog2,UINT_32 elementBytesLog2)194 const UINT_32 GetEquationTableEntry( 195 Addr3SwizzleMode swMode, 196 UINT_32 msaaLog2, 197 UINT_32 elementBytesLog2) const 198 { 199 UINT_32 res = ADDR_INVALID_EQUATION_INDEX; 200 // m_equationLookupTable doesn't include linear 201 if (swMode != ADDR3_LINEAR) 202 { 203 res = m_equationLookupTable[swMode - 1][msaaLog2][elementBytesLog2]; 204 } 205 206 return res; 207 } 208 GetBlockDimensionTableEntry(Addr3SwizzleMode swMode,UINT_32 msaaLog2,UINT_32 elementBytesLog2)209 const ADDR_EXTENT3D GetBlockDimensionTableEntry( 210 Addr3SwizzleMode swMode, 211 UINT_32 msaaLog2, 212 UINT_32 elementBytesLog2) const 213 { 214 return m_blockDimensionTable[swMode][msaaLog2][elementBytesLog2]; 215 } 216 Valid3DMipSliceIdConstraint(UINT_32 numSlices,UINT_32 mipId,UINT_32 slice)217 static BOOL_32 Valid3DMipSliceIdConstraint( 218 UINT_32 numSlices, 219 UINT_32 mipId, 220 UINT_32 slice) 221 { 222 return (Max((numSlices >> mipId), 1u) > slice); 223 } 224 225 UINT_32 GetBlockSize( 226 Addr3SwizzleMode swizzleMode, 227 BOOL_32 forPitch = FALSE) const; 228 229 UINT_32 GetBlockSizeLog2( 230 Addr3SwizzleMode swizzleMode, 231 BOOL_32 forPitch = FALSE) const; 232 IsValidSwMode(Addr3SwizzleMode swizzleMode)233 BOOL_32 IsValidSwMode(Addr3SwizzleMode swizzleMode) const 234 { 235 return (m_swizzleModeTable[swizzleMode].u32All != 0); 236 } 237 IsLinear(Addr3SwizzleMode swizzleMode)238 UINT_32 IsLinear(Addr3SwizzleMode swizzleMode) const 239 { 240 return m_swizzleModeTable[swizzleMode].isLinear; 241 } 242 243 // Checking block size IsBlock256b(Addr3SwizzleMode swizzleMode)244 BOOL_32 IsBlock256b(Addr3SwizzleMode swizzleMode) const 245 { 246 return m_swizzleModeTable[swizzleMode].is256b; 247 } 248 249 // Checking block size IsBlock4kb(Addr3SwizzleMode swizzleMode)250 BOOL_32 IsBlock4kb(Addr3SwizzleMode swizzleMode) const 251 { 252 return m_swizzleModeTable[swizzleMode].is4kb; 253 } 254 255 // Checking block size IsBlock64kb(Addr3SwizzleMode swizzleMode)256 BOOL_32 IsBlock64kb(Addr3SwizzleMode swizzleMode) const 257 { 258 return m_swizzleModeTable[swizzleMode].is64kb; 259 } 260 261 // Checking block size IsBlock256kb(Addr3SwizzleMode swizzleMode)262 BOOL_32 IsBlock256kb(Addr3SwizzleMode swizzleMode) const 263 { 264 return m_swizzleModeTable[swizzleMode].is256kb; 265 } 266 Is2dSwizzle(Addr3SwizzleMode swizzleMode)267 BOOL_32 Is2dSwizzle(Addr3SwizzleMode swizzleMode) const 268 { 269 return m_swizzleModeTable[swizzleMode].is2d; 270 } 271 Is3dSwizzle(Addr3SwizzleMode swizzleMode)272 BOOL_32 Is3dSwizzle(Addr3SwizzleMode swizzleMode) const 273 { 274 return m_swizzleModeTable[swizzleMode].is3d; 275 } 276 277 // miptail is applied to only larger block size (4kb, 64kb, 256kb), so there is no miptail in linear and 278 // 256b_2d addressing since they are both 256b block. SupportsMipTail(Addr3SwizzleMode swizzleMode)279 BOOL_32 SupportsMipTail(Addr3SwizzleMode swizzleMode) const 280 { 281 return GetBlockSize(swizzleMode) > 256u; 282 } 283 284 // The max alignment is tied to the swizzle mode and since the largest swizzle mode is 256kb, so the maximal 285 // alignment is also 256kb. HwlComputeMaxBaseAlignments()286 virtual UINT_32 HwlComputeMaxBaseAlignments() const { return Size256K; } 287 288 virtual ADDR_E_RETURNCODE HwlGetPossibleSwizzleModes( 289 const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn, 290 ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT* pOut) const = 0; 291 HwlInitGlobalParams(const ADDR_CREATE_INPUT * pCreateIn)292 virtual BOOL_32 HwlInitGlobalParams(const ADDR_CREATE_INPUT* pCreateIn) 293 { 294 ADDR_NOT_IMPLEMENTED(); 295 // Although GFX12 addressing should be consistent regardless of the configuration, we still need to 296 // call some initialization for member variables. 297 return TRUE; 298 } 299 HwlComputeMaxMetaBaseAlignments()300 virtual UINT_32 HwlComputeMaxMetaBaseAlignments() const { return 0; } 301 HwlComputeSurfaceInfo(const ADDR3_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR3_COMPUTE_SURFACE_INFO_OUTPUT * pOut)302 virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo( 303 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 304 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const 305 { 306 ADDR_NOT_IMPLEMENTED(); 307 return ADDR_NOTSUPPORTED; 308 } 309 HwlCopyMemToSurface(const ADDR3_COPY_MEMSURFACE_INPUT * pIn,const ADDR3_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)310 virtual ADDR_E_RETURNCODE HwlCopyMemToSurface( 311 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 312 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 313 UINT_32 regionCount) const 314 { 315 ADDR_NOT_IMPLEMENTED(); 316 return ADDR_NOTSUPPORTED; 317 } 318 HwlCopySurfaceToMem(const ADDR3_COPY_MEMSURFACE_INPUT * pIn,const ADDR3_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)319 virtual ADDR_E_RETURNCODE HwlCopySurfaceToMem( 320 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 321 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 322 UINT_32 regionCount) const 323 { 324 ADDR_NOT_IMPLEMENTED(); 325 return ADDR_NOTSUPPORTED; 326 } 327 HwlComputePipeBankXor(const ADDR3_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)328 virtual ADDR_E_RETURNCODE HwlComputePipeBankXor( 329 const ADDR3_COMPUTE_PIPEBANKXOR_INPUT* pIn, 330 ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const 331 { 332 ADDR_NOT_IMPLEMENTED(); 333 return ADDR_NOTSUPPORTED; 334 } 335 336 VOID ComputeBlockDimensionForSurf( 337 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 338 ADDR_EXTENT3D* pExtent) const; 339 340 ADDR_EXTENT3D GetMipTailDim( 341 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 342 const ADDR_EXTENT3D& blockDims) const; 343 344 ADDR_E_RETURNCODE CopyLinearSurface( 345 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, 346 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, 347 UINT_32 regionCount, 348 bool surfaceIsDst) const; 349 350 ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoordLinear( 351 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 352 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const; 353 354 virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordLinear( 355 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 356 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pSurfInfoIn, 357 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const = 0; 358 359 ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoordTiled( 360 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 361 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const; 362 HwlComputeSurfaceAddrFromCoordTiled(const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)363 virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordTiled( 364 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, 365 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const 366 { 367 ADDR_NOT_IMPLEMENTED(); 368 return ADDR_NOTIMPLEMENTED; 369 } 370 HwlComputeNonBlockCompressedView(const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)371 virtual ADDR_E_RETURNCODE HwlComputeNonBlockCompressedView( 372 const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, 373 ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) const 374 { 375 ADDR_NOT_IMPLEMENTED(); 376 return ADDR_NOTSUPPORTED; 377 } 378 HwlComputeSubResourceOffsetForSwizzlePattern(const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)379 virtual VOID HwlComputeSubResourceOffsetForSwizzlePattern( 380 const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, 381 ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const 382 { 383 ADDR_NOT_IMPLEMENTED(); 384 } 385 HwlComputeSlicePipeBankXor(const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)386 virtual ADDR_E_RETURNCODE HwlComputeSlicePipeBankXor( 387 const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, 388 ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const 389 { 390 ADDR_NOT_IMPLEMENTED(); 391 return ADDR_NOTSUPPORTED; 392 } 393 HwlGetEquationIndex(const ADDR3_COMPUTE_SURFACE_INFO_INPUT * pIn)394 virtual UINT_32 HwlGetEquationIndex( 395 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const 396 { 397 ADDR_NOT_IMPLEMENTED(); 398 return ADDR_INVALID_EQUATION_INDEX; 399 } 400 SetEquationIndex(const ADDR3_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR3_COMPUTE_SURFACE_INFO_OUTPUT * pOut)401 void SetEquationIndex( 402 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 403 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const 404 { 405 UINT_32 equationIdx = HwlGetEquationIndex(pIn); 406 407 if (pOut->pMipInfo != NULL) 408 { 409 for (UINT_32 i = 0; i < pIn->numMipLevels; i++) 410 { 411 pOut->pMipInfo[i].equationIndex = equationIdx; 412 } 413 } 414 } 415 416 ADDR_E_RETURNCODE ApplyCustomizedPitchHeight( 417 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, 418 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 419 420 BOOL_32 UseCustomHeight(const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 421 BOOL_32 UseCustomPitch(const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 422 BOOL_32 CanTrimLinearPadding(const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 423 424 virtual VOID HwlCalcBlockSize( 425 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 426 ADDR_EXTENT3D* pExtent) const = 0; 427 428 virtual ADDR_EXTENT3D HwlGetMipInTailMaxSize( 429 const ADDR3_COMPUTE_SURFACE_INFO_PARAMS_INPUT* pIn, 430 const ADDR_EXTENT3D& blockDims) const = 0; 431 432 virtual BOOL_32 HwlValidateNonSwModeParams(const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn) const = 0; 433 434 ADDR_E_RETURNCODE ComputeSurfaceInfoSanityCheck(const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn) const; 435 436 private: 437 // Disallow the copy constructor 438 Lib(const Lib& a); 439 440 // Disallow the assignment operator 441 Lib& operator=(const Lib& a); 442 443 void Init(); 444 445 VOID ComputeQbStereoInfo(ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const; 446 }; 447 448 } // V3 449 } // Addr 450 451 #endif