return returnCode;
}
+/**
+****************************************************************************************************
+* Addr2ComputeDccAddrFromCoord
+*
+* @brief
+* Compute DCC key address according to coordinates
+*
+* @return
+* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
+ ADDR_HANDLE hLib, ///< address lib handle
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] Dcc info and coordinates
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Dcc address
+{
+ V2::Lib* pLib = V2::Lib::GetLib(hLib);
+
+ ADDR_E_RETURNCODE returnCode = ADDR_OK;
+
+ if (pLib != NULL)
+ {
+ returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
+ }
+ else
+ {
+ returnCode = ADDR_ERROR;
+ }
+
+ return returnCode;
+}
+
/**
****************************************************************************************************
* Addr2ComputePipeBankXor
return returnCode;
}
+/**
+****************************************************************************************************
+* Addr2ComputeSlicePipeBankXor
+*
+* @brief
+* Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
+ ADDR_HANDLE hLib, ///< handle of addrlib
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
+{
+ ADDR_E_RETURNCODE returnCode;
+
+ V2::Lib* pLib = V2::Lib::GetLib(hLib);
+
+ if (pLib != NULL)
+ {
+ returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
+ }
+ else
+ {
+ returnCode = ADDR_ERROR;
+ }
+
+ return returnCode;
+}
+
+/**
+****************************************************************************************************
+* Addr2ComputeSubResourceOffsetForSwizzlePattern
+*
+* @brief
+* Calculate sub resource offset for swizzle pattern.
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
+ ADDR_HANDLE hLib, ///< handle of addrlib
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
+{
+ ADDR_E_RETURNCODE returnCode;
+
+ V2::Lib* pLib = V2::Lib::GetLib(hLib);
+
+ if (pLib != NULL)
+ {
+ returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
+ }
+ else
+ {
+ returnCode = ADDR_ERROR;
+ }
+
+ return returnCode;
+}
+
/**
****************************************************************************************************
* Addr2GetPreferredSurfaceSetting
UINT_32 pitch; ///< Pitch in elements
UINT_32 height; ///< Padded height in elements
UINT_32 depth; ///< Padded depth
- UINT_32 offset; ///< Offset in bytes from mip base
-
+ UINT_32 pixelPitch; ///< Pitch in pixels
+ UINT_32 pixelHeight; ///< Padded height in pixels
UINT_32 equationIndex; ///< Equation index in the equation table
- UINT_32 mipOffsetXBytes; ///< Mip start position offset in byte in X direction
- UINT_32 mipOffsetYPixel; ///< Mip start position offset in pixel in Y direction
- UINT_32 mipOffsetZPixel; ///< Mip start position offset in pixel in Z direction
- UINT_32 postSwizzleOffset; ///< Offset which is used to be added directly onto
- /// the address calculated by equation
+ UINT_64 offset; ///< Offset in bytes from mip base, should only be used
+ ///< to setup vam surface descriptor, can't be used
+ ///< to setup swizzle pattern
+ UINT_64 macroBlockOffset; ///< macro block offset in bytes from mip base
+ UINT_32 mipTailOffset; ///< mip tail offset in bytes
+ UINT_32 mipTailCoordX; ///< mip tail coord x
+ UINT_32 mipTailCoordY; ///< mip tail coord y
+ UINT_32 mipTailCoordZ; ///< mip tail coord z
} ADDR2_MIP_INFO;
/**
UINT_32 mipChainPitch; ///< Pitch (of total mip chain) in elements
UINT_32 mipChainHeight; ///< Padded height (of total mip chain) in elements
UINT_32 mipChainSlice; ///< Padded depth (of total mip chain)
- UINT_32 sliceSize; ///< Slice (total mip chain) size in bytes
+ UINT_64 sliceSize; ///< Slice (total mip chain) size in bytes
UINT_64 surfSize; ///< Surface (total mip chain) size in bytes
UINT_32 baseAlign; ///< Base address alignment
UINT_32 bpp; ///< Bits per elements
/// contain numMipLevels entries
UINT_32 equationIndex; ///< Equation index in the equation table of mip0
- BOOL_32 firstMipInTail; ///< If whole mipchain falls into mip tail block
+ BOOL_32 mipChainInTail; ///< If whole mipchain falls into mip tail block
+ UINT_32 firstMipIdInTail; ///< The id of first mip in tail, if there is no mip
+ /// in tail, it will be set to number of mip levels
} ADDR2_COMPUTE_SURFACE_INFO_OUTPUT;
/**
typedef struct _ADDR2_META_MIP_INFO
{
BOOL_32 inMiptail;
- UINT_32 startX;
- UINT_32 startY;
- UINT_32 startZ;
- UINT_32 width;
- UINT_32 height;
- UINT_32 depth;
+ union
+ {
+ struct
+ {
+ UINT_32 startX;
+ UINT_32 startY;
+ UINT_32 startZ;
+ UINT_32 width;
+ UINT_32 height;
+ UINT_32 depth;
+ };
+
+ struct
+ {
+ UINT_32 offset; ///< metadata offset within one slice,
+ /// the thickness of a slice is meta block depth.
+ UINT_32 sliceSize; ///< metadata size within one slice,
+ /// the thickness of a slice is meta block depth.
+ };
+ };
} ADDR2_META_MIP_INFO;
/**
UINT_32 unalignedHeight; ///< Depth surface original height (of mip0)
UINT_32 numSlices; ///< Number of slices of depth surface (of mip0)
UINT_32 numMipLevels; ///< Total mipmap levels of color surface
+ UINT_32 firstMipIdInTail; ///< id of the first mip in tail,
+ /// if no mip is in tail, it should be set to
+ /// number of mip levels
} ADDR2_COMPUTE_HTILE_INFO_INPUT;
/**
UINT_32 unalignedHeight; ///< Color surface original height
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
- /// number of samples for normal AA; Set it to the
- /// number of fragments for EQAA
+ /// number of samples for normal AA; Set it to the
+ /// number of fragments for EQAA
UINT_32 tileSwizzle; ///< Combined swizzle used to do bank/pipe rotation
ADDR2_FMASK_FLAGS fMaskFlags; ///< FMASK flags
UINT_32 numMipLevels; ///< Total mipmap levels of color surface
UINT_32 dataSurfaceSize; ///< The padded size of all slices and mip levels
///< useful in meta linear case
+ UINT_32 firstMipIdInTail; ///< The id of first mip in tail, if no mip is in tail,
+ /// it should be number of mip levels
} ADDR2_COMPUTE_DCCINFO_INPUT;
/**
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut);
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
+*
+* @brief
+* Input structure for Addr2ComputeDccAddrFromCoord
+*
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+
+ UINT_32 x; ///< X coordinate
+ UINT_32 y; ///< Y coordinate
+ UINT_32 slice; ///< Index of slices
+ UINT_32 sample; ///< Index of samples, means fragment index for EQAA
+ UINT_32 mipId; ///< mipmap level id
+
+ ADDR2_META_FLAGS dccKeyFlags; ///< DCC flags
+ ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
+ AddrResourceType resourceType; ///< Color surface type
+ AddrSwizzleMode swizzleMode; ///< Color surface swizzle mode
+ UINT_32 bpp; ///< Color surface bits per pixel
+ UINT_32 unalignedWidth; ///< Color surface original width (of mip0)
+ UINT_32 unalignedHeight; ///< Color surface original height (of mip0)
+ UINT_32 numSlices; ///< Color surface original slices (of mip0)
+ UINT_32 numMipLevels; ///< Color surface mipmap levels
+ UINT_32 numFrags; ///< Color surface fragment number
+
+ UINT_32 pipeXor; ///< pipe Xor setting
+} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT;
+
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
+*
+* @brief
+* Output structure for Addr2ComputeDccAddrFromCoord
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+
+ UINT_64 addr; ///< DCC address in bytes
+} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT;
+
+/**
+****************************************************************************************************
+* Addr2ComputeDccAddrFromCoord
+*
+* @brief
+* Compute DCC address according to coordinates (of MSAA color buffer)
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
+ ADDR_HANDLE hLib,
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// Misc functions for Gfx9
ADDR2_SURFACE_FLAGS flags; ///< Surface flag
AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
AddrResourceType resourceType; ///< Surface resource type
+ AddrFormat format; ///< Surface format
+ UINT_32 numSamples; ///< Number of samples
+ UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
+ /// number of samples for normal AA; Set it to the
+ /// number of fragments for EQAA
} ADDR2_COMPUTE_PIPEBANKXOR_INPUT;
/**
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut);
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
+*
+* @brief
+* Input structure of Addr2ComputeSlicePipeBankXor
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
+ AddrResourceType resourceType; ///< Surface resource type
+ UINT_32 basePipeBankXor; ///< Base pipe bank xor
+ UINT_32 slice; ///< Slice id
+ UINT_32 numSamples; ///< Number of samples
+} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT;
+
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
+*
+* @brief
+* Output structure of Addr2ComputeSlicePipeBankXor
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ UINT_32 pipeBankXor; ///< Pipe bank xor
+} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT;
+
+/**
+****************************************************************************************************
+* Addr2ComputeSlicePipeBankXor
+*
+* @brief
+* Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
+ ADDR_HANDLE hLib,
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut);
+
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
+*
+* @brief
+* Input structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
+ AddrResourceType resourceType; ///< Surface resource type
+ UINT_32 pipeBankXor; ///< Per resource xor
+ UINT_32 slice; ///< Slice id
+ UINT_64 sliceSize; ///< Slice size of a mip chain
+ UINT_64 macroBlockOffset; ///< Macro block offset, returned in ADDR2_MIP_INFO
+ UINT_32 mipTailOffset; ///< Mip tail offset, returned in ADDR2_MIP_INFO
+} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT;
+/**
+****************************************************************************************************
+* ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
+*
+* @brief
+* Output structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
+****************************************************************************************************
+*/
+typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ UINT_64 offset; ///< offset
+} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT;
+
+/**
+****************************************************************************************************
+* Addr2ComputeSubResourceOffsetForSwizzlePattern
+*
+* @brief
+* Calculate sub resource offset to support swizzle pattern.
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
+ ADDR_HANDLE hLib,
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut);
/**
****************************************************************************************************
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 maxAlign; ///< maximum base/size alignment requested by client
+ UINT_32 minSizeAlign; ///< memory allocated for surface in client driver will
+ /// be padded to multiple of this value (in bytes)
} ADDR2_GET_PREFERRED_SURF_SETTING_INPUT;
/**
} // V1
+namespace V2
+{
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Common constants
+////////////////////////////////////////////////////////////////////////////////////////////////////
+static const UINT_32 MaxSurfaceHeight = 16384;
+
+} // V2
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// Common macros
////////////////////////////////////////////////////////////////////////////////////////////////////
static inline UINT_32 NextPow2(
UINT_32 dim) ///< [in] dimension of miplevel
{
- UINT_32 newDim;
-
- newDim = 1;
+ UINT_32 newDim = 1;
if (dim > 0x7fffffff)
{
* ReverseBitVector
*
* @brief
-* Return reversed lowest num bits of v
+* Return reversed lowest num bits of v: v[0]v[1]...v[num-2]v[num-1]
****************************************************************************************************
*/
static inline UINT_32 ReverseBitVector(
{
pChanDst->valid = pChanSrc->valid;
pChanDst->channel = pChanSrc->channel;
- pChanDst->index = pChanSrc->channel;
+ pChanDst->index = pChanSrc->index;
}
/**
****************************************************************************************************
*/
static inline UINT_32 GetMaxValidChannelIndex(
- ADDR_CHANNEL_SETTING *pChanSet, ///< [in] channel setting to be initialized
- UINT_32 searchCount, ///< [in] number of channel setting to be searched
- UINT_32 channel) ///< [in] channel to be searched
+ const ADDR_CHANNEL_SETTING *pChanSet, ///< [in] channel setting to be initialized
+ UINT_32 searchCount,///< [in] number of channel setting to be searched
+ UINT_32 channel) ///< [in] channel to be searched
{
UINT_32 index = 0;
return index;
}
+/**
+****************************************************************************************************
+* GetCoordActiveMask
+*
+* @brief
+* Get bit mask which indicates which positions in the equation match the target coord
+****************************************************************************************************
+*/
+static inline UINT_32 GetCoordActiveMask(
+ const ADDR_CHANNEL_SETTING *pChanSet, ///< [in] channel setting to be initialized
+ UINT_32 searchCount,///< [in] number of channel setting to be searched
+ UINT_32 channel, ///< [in] channel to be searched
+ UINT_32 index) ///< [in] index to be searched
+{
+ UINT_32 mask = 0;
+
+ for (UINT_32 i = 0; i < searchCount; i++)
+ {
+ if ((pChanSet[i].valid == TRUE) &&
+ (pChanSet[i].channel == channel) &&
+ (pChanSet[i].index == index))
+ {
+ mask |= (1 << i);
+ }
+ }
+
+ return mask;
+}
+
} // Addr
#endif // __ADDR_COMMON_H__
break;
case ADDR_PACKED_GBGR:
case ADDR_PACKED_BGRG:
- originalBits = bpp; // 32-bit packed ==> 2 32-bit result
+ if (m_pAddrLib->GetChipFamily() >= ADDR_CHIP_FAMILY_AI)
+ {
+ originalBits = bpp / expandX;
+ }
+ else
+ {
+ originalBits = bpp; // 32-bit packed ==> 2 32-bit result
+ }
break;
case ADDR_PACKED_BC1: // Fall through
case ADDR_PACKED_BC4:
break;
case ADDR_FMT_GB_GR: // treat as FMT_8_8
elemMode = ADDR_PACKED_GBGR;
- bpp = 16;
+ if (m_pAddrLib->GetChipFamily() >= ADDR_CHIP_FAMILY_AI)
+ {
+ bpp = 32;
+ expandX = 2;
+ }
+ else
+ {
+ bpp = 16;
+ }
break;
case ADDR_FMT_BG_RG: // treat as FMT_8_8
elemMode = ADDR_PACKED_BGRG;
- bpp = 16;
+ if (m_pAddrLib->GetChipFamily() >= ADDR_CHIP_FAMILY_AI)
+ {
+ bpp = 32;
+ expandX = 2;
+ }
+ else
+ {
+ bpp = 16;
+ }
break;
case ADDR_FMT_8_8_8_8:
case ADDR_FMT_2_10_10_10:
return is3x;
}
+/**
+****************************************************************************************************
+* ElemLib::IsMacroPixelPacked
+*
+* @brief
+* TRUE if this is a macro-pixel-packed format.
+*
+* @note
+*
+* @return
+* BOOL_32
+****************************************************************************************************
+*/
+BOOL_32 ElemLib::IsMacroPixelPacked(
+ AddrFormat format) ///< [in] Format
+{
+ BOOL_32 isMacroPixelPacked = FALSE;
+
+ switch (format)
+ {
+ case ADDR_FMT_BG_RG:
+ case ADDR_FMT_GB_GR:
+ isMacroPixelPacked = TRUE;
+ break;
+ default:
+ break;
+ }
+
+ return isMacroPixelPacked;
+}
+
}
AddrDepthFormat format, PixelFormatInfo* pInfo) const;
UINT_32 GetBitsPerPixel(
- AddrFormat format, ElemMode* pElemMode,
+ AddrFormat format, ElemMode* pElemMode = NULL,
UINT_32* pExpandX = NULL, UINT_32* pExpandY = NULL, UINT_32* pBitsUnused = NULL);
static VOID SetClearComps(
static BOOL_32 IsCompressed(AddrFormat format);
static BOOL_32 IsBlockCompressed(AddrFormat format);
static BOOL_32 IsExpand3x(AddrFormat format);
+ static BOOL_32 IsMacroPixelPacked(AddrFormat format);
protected:
ElemLib* m_pElemLib; ///< Element Lib pointer
};
-Lib* SiHwlInit (const Client* pClient);
-Lib* CiHwlInit (const Client* pClient);
-Lib* Gfx9HwlInit(const Client* pClient);
+Lib* SiHwlInit (const Client* pClient);
+Lib* CiHwlInit (const Client* pClient);
+Lib* Gfx9HwlInit (const Client* pClient);
} // Addr
// Also Mip 1+ needs an element pitch of 32 bits so we do not need this workaround
// but we use this flag to skip RestoreSurfaceInfo below
- if ((elemMode == ADDR_EXPANDED) &&
- (expandX > 1))
+ if ((elemMode == ADDR_EXPANDED) && (expandX > 1))
{
- ADDR_ASSERT(localIn.tileMode == ADDR_TM_LINEAR_ALIGNED || localIn.height == 1);
+ ADDR_ASSERT(IsLinear(localIn.tileMode));
}
GetElemLib()->AdjustSurfaceInfo(elemMode,
{
tileMode = ADDR_TM_LINEAR_ALIGNED;
}
- else if (IsMacroTiled(tileMode))
+ else if (IsMacroTiled(tileMode) && (pInOut->flags.tcCompatible == FALSE))
{
if (DegradeTo1D(width, height, macroWidthAlign, macroHeightAlign))
{
* @brief
* Get quad buffer stereo information
* @return
-* TRUE if no error
+* N/A
****************************************************************************************************
*/
-BOOL_32 Lib::ComputeQbStereoInfo(
+VOID Lib::ComputeQbStereoInfo(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in,out] updated pOut+pStereoInfo
) const
{
- BOOL_32 success = FALSE;
-
- if (pOut->pStereoInfo)
- {
- ADDR_ASSERT(pOut->bpp >= 8);
- ADDR_ASSERT((pOut->surfSize % pOut->baseAlign) == 0);
+ ADDR_ASSERT(pOut->bpp >= 8);
+ ADDR_ASSERT((pOut->surfSize % pOut->baseAlign) == 0);
- // Save original height
- pOut->pStereoInfo->eyeHeight = pOut->height;
+ // Save original height
+ pOut->pStereoInfo->eyeHeight = pOut->height;
- // Right offset
- pOut->pStereoInfo->rightOffset = static_cast<UINT_32>(pOut->surfSize);
+ // Right offset
+ pOut->pStereoInfo->rightOffset = static_cast<UINT_32>(pOut->surfSize);
- pOut->pStereoInfo->rightSwizzle = HwlComputeQbStereoRightSwizzle(pOut);
- // Double height
- pOut->height <<= 1;
- pOut->pixelHeight <<= 1;
+ pOut->pStereoInfo->rightSwizzle = HwlComputeQbStereoRightSwizzle(pOut);
+ // Double height
+ pOut->height <<= 1;
+ pOut->pixelHeight <<= 1;
- // Double size
- pOut->surfSize <<= 1;
+ // Double size
+ pOut->surfSize <<= 1;
- // Right start address meets the base align since it is guaranteed by AddrLib1
-
- // 1D surface on SI may break this rule, but we can force it to meet by checking .qbStereo.
- success = TRUE;
- }
+ // Right start address meets the base align since it is guaranteed by AddrLib1
- return success;
+ // 1D surface on SI may break this rule, but we can force it to meet by checking .qbStereo.
}
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
/// Quad buffer stereo support, has its implementation in ind. layer
- virtual BOOL_32 ComputeQbStereoInfo(
+ VOID ComputeQbStereoInfo(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
/// Pure virutual function to compute stereo bank swizzle for right eye
*/
/**
-****************************************************************************************************
+************************************************************************************************************************
* @file addrlib2.cpp
* @brief Contains the implementation for the AddrLib2 base class.
-****************************************************************************************************
+************************************************************************************************************************
*/
#include "addrinterface.h"
// Static Const Member
////////////////////////////////////////////////////////////////////////////////////////////////////
-const SwizzleModeFlags Lib::SwizzleModeTable[ADDR_SW_MAX_TYPE] =
-{//Linear 256B 4KB 64KB Var Z Std Disp Rot XOR T
- {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},//ADDR_SW_LINEAR
- {0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0},//ADDR_SW_256B_S
- {0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0},//ADDR_SW_256B_D
- {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0},//ADDR_SW_256B_R
+const Dim2d Lib::Block256_2d[] = {{16, 16}, {16, 8}, {8, 8}, {8, 4}, {4, 4}};
- {0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0},//ADDR_SW_4KB_Z
- {0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0},//ADDR_SW_4KB_S
- {0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0},//ADDR_SW_4KB_D
- {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0},//ADDR_SW_4KB_R
-
- {0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},//ADDR_SW_64KB_Z
- {0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0},//ADDR_SW_64KB_S
- {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0},//ADDR_SW_64KB_D
- {0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0},//ADDR_SW_64KB_R
-
- {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0},//ADDR_SW_VAR_Z
- {0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0},//ADDR_SW_VAR_S
- {0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0},//ADDR_SW_VAR_D
- {0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0},//ADDR_SW_VAR_R
-
- {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1},//ADDR_SW_64KB_Z_T
- {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1},//ADDR_SW_64KB_S_T
- {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1},//ADDR_SW_64KB_D_T
- {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1},//ADDR_SW_64KB_R_T
-
- {0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0},//ADDR_SW_4KB_Z_x
- {0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0},//ADDR_SW_4KB_S_x
- {0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0},//ADDR_SW_4KB_D_x
- {0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0},//ADDR_SW_4KB_R_x
-
- {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0},//ADDR_SW_64KB_Z_X
- {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0},//ADDR_SW_64KB_S_X
- {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0},//ADDR_SW_64KB_D_X
- {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0},//ADDR_SW_64KB_R_X
-
- {0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0},//ADDR_SW_VAR_Z_X
- {0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0},//ADDR_SW_VAR_S_X
- {0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0},//ADDR_SW_VAR_D_X
- {0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0},//ADDR_SW_VAR_R_X
- {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},//ADDR_SW_LINEAR_GENERAL
-};
-
-const Dim2d Lib::Block256b[] = {{16, 16}, {16, 8}, {8, 8}, {8, 4}, {4, 4}};
-
-const Dim3d Lib::Block1kb[] = {{16, 8, 8}, {8, 8, 8}, {8, 8, 4}, {8, 4, 4}, {4, 4, 4}};
-
-const Dim2d Lib::CompressBlock2d[] = {{16, 16}, {16, 8}, {8, 8}, {8, 4}, {4, 4}};
-
-const Dim3d Lib::CompressBlock3dS[] = {{16, 4, 4}, {8, 4, 4}, {4, 4, 4}, {2, 4, 4}, {1, 4, 4}};
-
-const Dim3d Lib::CompressBlock3dZ[] = {{8, 4, 8}, {4, 4, 8}, {4, 4, 4}, {4, 2, 4}, {2, 2, 4}};
-
-const UINT_32 Lib::MaxMacroBits = 20;
-
-const UINT_32 Lib::MipTailOffset[] = {2048, 1024, 512, 256, 128, 64, 32, 16,
- 8, 6, 5, 4, 3, 2, 1, 0};
+const Dim3d Lib::Block1K_3d[] = {{16, 8, 8}, {8, 8, 8}, {8, 8, 4}, {8, 4, 4}, {4, 4, 4}};
////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor/Destructor
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::Lib
*
* @brief
* Constructor for the Addr::V2::Lib class
*
-****************************************************************************************************
+************************************************************************************************************************
*/
Lib::Lib()
:
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::Lib
*
* @brief
* Constructor for the AddrLib2 class with hClient as parameter
*
-****************************************************************************************************
+************************************************************************************************************************
*/
Lib::Lib(const Client* pClient)
:
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::~Lib
*
* @brief
* Destructor for the AddrLib2 class
*
-****************************************************************************************************
+************************************************************************************************************************
*/
Lib::~Lib()
{
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::GetLib
*
* @brief
*
* @return
* An Addr::V2::Lib class pointer
-****************************************************************************************************
+************************************************************************************************************************
*/
Lib* Lib::GetLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfo(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
// Adjust coming parameters.
ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = *pIn;
- localIn.width = Max(pIn->width, 1u);
- localIn.height = Max(pIn->height, 1u);
+ localIn.width = Max(pIn->width, 1u);
+ localIn.height = Max(pIn->height, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
- localIn.numSlices = Max(pIn->numSlices, 1u);
- localIn.numSamples = Max(pIn->numSamples, 1u);
- localIn.numFrags = (localIn.numFrags == 0) ? localIn.numSamples : pIn->numFrags;
+ localIn.numSlices = Max(pIn->numSlices, 1u);
+ localIn.numSamples = Max(pIn->numSamples, 1u);
+ localIn.numFrags = (localIn.numFrags == 0) ? localIn.numSamples : pIn->numFrags;
UINT_32 expandX = 1;
UINT_32 expandY = 1;
if ((elemMode == ADDR_EXPANDED) && (expandX > 1))
{
- ADDR_ASSERT((localIn.swizzleMode == ADDR_SW_LINEAR) || (localIn.height == 1));
+ ADDR_ASSERT(IsLinear(localIn.swizzleMode));
}
UINT_32 basePitch = 0;
&pixelBits,
&pOut->pixelMipChainPitch,
&pOut->pixelMipChainHeight);
+
+ if ((localIn.numMipLevels > 1) && (pOut->pMipInfo != NULL))
+ {
+ for (UINT_32 i = 0; i < localIn.numMipLevels; i++)
+ {
+ pOut->pMipInfo[i].pixelPitch = pOut->pMipInfo[i].pitch;
+ pOut->pMipInfo[i].pixelHeight = pOut->pMipInfo[i].height;
+
+ GetElemLib()->RestoreSurfaceInfo(elemMode,
+ expandX,
+ expandY,
+ &pixelBits,
+ &pOut->pMipInfo[i].pixelPitch,
+ &pOut->pMipInfo[i].pixelHeight);
+ }
+ }
}
if (localIn.flags.needEquation && (Log2(localIn.numFrags) == 0))
{
pOut->equationIndex = GetEquationIndex(&localIn, pOut);
}
+
+ if (localIn.flags.qbStereo)
+ {
+ if (pOut->pStereoInfo != NULL)
+ {
+ ComputeQbStereoInfo(pOut);
+ }
+ }
}
}
+ ADDR_ASSERT(pOut->surfSize != 0);
+
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoord(
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT localIn = *pIn;
- localIn.unalignedWidth = Max(pIn->unalignedWidth, 1u);
+ localIn.unalignedWidth = Max(pIn->unalignedWidth, 1u);
localIn.unalignedHeight = Max(pIn->unalignedHeight, 1u);
- localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
- localIn.numSlices = Max(pIn->numSlices, 1u);
- localIn.numSamples = Max(pIn->numSamples, 1u);
- localIn.numFrags = Max(pIn->numFrags, 1u);
+ localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
+ localIn.numSlices = Max(pIn->numSlices, 1u);
+ localIn.numSamples = Max(pIn->numSamples, 1u);
+ localIn.numFrags = Max(pIn->numFrags, 1u);
if ((localIn.bpp < 8) ||
(localIn.bpp > 128) ||
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddr(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeHtileInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileInfo(
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeHtileAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileAddrFromCoord(
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeHtileCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileCoordFromAddr(
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeCmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeCmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskAddrFromCoord(
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeCmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskCoordFromAddr(
const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeFmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskInfo(
const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
pOut->baseAlign = localOut.baseAlign;
pOut->numSlices = localOut.numSlices;
pOut->fmaskBytes = static_cast<UINT_32>(localOut.surfSize);
- pOut->sliceSize = localOut.sliceSize;
+ pOut->sliceSize = static_cast<UINT_32>(localOut.sliceSize);
pOut->bpp = localIn.bpp;
pOut->numSamples = 1;
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeFmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskAddrFromCoord(
const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeFmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskCoordFromAddr(
const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
-* Lib::GetMetaMiptailInfo
+************************************************************************************************************************
+* Lib::ComputeDccInfo
*
* @brief
-* Get mip tail coordinate information.
+* Interface function to compute DCC key info
*
* @return
-* N/A
-****************************************************************************************************
+* return code of HwlComputeDccInfo
+************************************************************************************************************************
*/
-VOID Lib::GetMetaMiptailInfo(
- ADDR2_META_MIP_INFO* pInfo, ///< [out] output structure to store per mip coord
- Dim3d mipCoord, ///< [in] mip tail base coord
- UINT_32 numMipInTail, ///< [in] number of mips in tail
- Dim3d* pMetaBlkDim ///< [in] meta block width/height/depth
+ADDR_E_RETURNCODE Lib::ComputeDccInfo(
+ const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
+ ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
) const
{
- BOOL_32 isThick = (pMetaBlkDim->d > 1);
- UINT_32 mipWidth = pMetaBlkDim->w;
- UINT_32 mipHeight = pMetaBlkDim->h >> 1;
- UINT_32 mipDepth = pMetaBlkDim->d;
- UINT_32 minInc;
+ ADDR_E_RETURNCODE returnCode;
- if (isThick)
- {
- minInc = (pMetaBlkDim->h >= 512) ? 128 : ((pMetaBlkDim->h == 256) ? 64 : 32);
- }
- else if (pMetaBlkDim->h >= 1024)
- {
- minInc = 256;
- }
- else if (pMetaBlkDim->h == 512)
+ if ((GetFillSizeFieldsFlags() == TRUE) &&
+ ((pIn->size != sizeof(ADDR2_COMPUTE_DCCINFO_INPUT)) ||
+ (pOut->size != sizeof(ADDR2_COMPUTE_DCCINFO_OUTPUT))))
{
- minInc = 128;
+ returnCode = ADDR_INVALIDPARAMS;
}
else
{
- minInc = 64;
+ returnCode = HwlComputeDccInfo(pIn, pOut);
}
- UINT_32 blk32MipId = 0xFFFFFFFF;
-
- for (UINT_32 mip = 0; mip < numMipInTail; mip++)
- {
- pInfo[mip].inMiptail = TRUE;
- pInfo[mip].startX = mipCoord.w;
- pInfo[mip].startY = mipCoord.h;
- pInfo[mip].startZ = mipCoord.d;
- pInfo[mip].width = mipWidth;
- pInfo[mip].height = mipHeight;
- pInfo[mip].depth = mipDepth;
-
- if (mipWidth <= 32)
- {
- if (blk32MipId == 0xFFFFFFFF)
- {
- blk32MipId = mip;
- }
-
- mipCoord.w = pInfo[blk32MipId].startX;
- mipCoord.h = pInfo[blk32MipId].startY;
- mipCoord.d = pInfo[blk32MipId].startZ;
-
- switch (mip - blk32MipId)
- {
- case 0:
- mipCoord.w += 32; // 16x16
- break;
- case 1:
- mipCoord.h += 32; // 8x8
- break;
- case 2:
- mipCoord.h += 32; // 4x4
- mipCoord.w += 16;
- break;
- case 3:
- mipCoord.h += 32; // 2x2
- mipCoord.w += 32;
- break;
- case 4:
- mipCoord.h += 32; // 1x1
- mipCoord.w += 48;
- break;
- // The following are for BC/ASTC formats
- case 5:
- mipCoord.h += 48; // 1/2 x 1/2
- break;
- case 6:
- mipCoord.h += 48; // 1/4 x 1/4
- mipCoord.w += 16;
- break;
- case 7:
- mipCoord.h += 48; // 1/8 x 1/8
- mipCoord.w += 32;
- break;
- case 8:
- mipCoord.h += 48; // 1/16 x 1/16
- mipCoord.w += 48;
- break;
- default:
- ADDR_ASSERT_ALWAYS();
- break;
- }
-
- mipWidth = ((mip - blk32MipId) == 0) ? 16 : 8;
- mipHeight = mipWidth;
-
- if (isThick)
- {
- mipDepth = mipWidth;
- }
- }
- else
- {
- if (mipWidth <= minInc)
- {
- // if we're below the minimal increment...
- if (isThick)
- {
- // For 3d, just go in z direction
- mipCoord.d += mipDepth;
- }
- else
- {
- // For 2d, first go across, then down
- if ((mipWidth * 2) == minInc)
- {
- // if we're 2 mips below, that's when we go back in x, and down in y
- mipCoord.w -= minInc;
- mipCoord.h += minInc;
- }
- else
- {
- // otherwise, just go across in x
- mipCoord.w += minInc;
- }
- }
- }
- else
- {
- // On even mip, go down, otherwise, go across
- if (mip & 1)
- {
- mipCoord.w += mipWidth;
- }
- else
- {
- mipCoord.h += mipHeight;
- }
- }
- // Divide the width by 2
- mipWidth >>= 1;
- // After the first mip in tail, the mip is always a square
- mipHeight = mipWidth;
- // ...or for 3d, a cube
- if (isThick)
- {
- mipDepth = mipWidth;
- }
- }
- }
+ return returnCode;
}
/**
-****************************************************************************************************
-* Lib::ComputeDccInfo
+************************************************************************************************************************
+* Lib::ComputeDccAddrFromCoord
*
* @brief
-* Interface function to compute DCC key info
+* Interface function stub of ComputeDccAddrFromCoord
*
* @return
-* return code of HwlComputeDccInfo
-****************************************************************************************************
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
*/
-ADDR_E_RETURNCODE Lib::ComputeDccInfo(
- const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
- ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
+ADDR_E_RETURNCODE Lib::ComputeDccAddrFromCoord(
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
- ((pIn->size != sizeof(ADDR2_COMPUTE_DCCINFO_INPUT)) ||
- (pOut->size != sizeof(ADDR2_COMPUTE_DCCINFO_OUTPUT))))
+ ((pIn->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT)) ||
+ (pOut->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
- returnCode = HwlComputeDccInfo(pIn, pOut);
+ returnCode = HwlComputeDccAddrFromCoord(pIn, pOut);
}
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputePipeBankXor
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputePipeBankXor(
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
- ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut)
+ ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut)
{
ADDR_E_RETURNCODE returnCode;
{
returnCode = ADDR_INVALIDPARAMS;
}
+ else if (IsXor(pIn->swizzleMode) == FALSE)
+ {
+ returnCode = ADDR_NOTSUPPORTED;
+ }
else
{
- UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
- UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
- UINT_32 bankBits = GetBankXorBits(macroBlockBits);
- UINT_32 pipeXor = 0;
- UINT_32 bankXor = 0;
+ returnCode = HwlComputePipeBankXor(pIn, pOut);
+ }
- if (bankBits > 0)
- {
- UINT_32 bankMask = (1 << bankBits) - 1;
- UINT_32 bankIncrease = (1 << (bankBits - 1)) - 1;
- bankIncrease = (bankIncrease == 0) ? 1 : bankIncrease;
- bankXor = ((pIn->surfIndex & bankMask) * bankIncrease) & bankMask;
- }
+ return returnCode;
+}
- if (pipeBits > 0)
- {
- UINT_32 pipeMask = (1 << pipeBits) - 1;
- UINT_32 pipeIncrease = ((1 << (pipeBits - 1)) + 1) & pipeMask;
- pipeIncrease = (pipeIncrease == 0) ? 1 : pipeIncrease;
- pipeXor = ((pIn->surfIndex & pipeMask) * pipeIncrease) & pipeMask;
- }
+/**
+************************************************************************************************************************
+* Lib::ComputeSlicePipeBankXor
+*
+* @brief
+* Interface function stub of Addr2ComputeSlicePipeBankXor.
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Lib::ComputeSlicePipeBankXor(
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut)
+{
+ ADDR_E_RETURNCODE returnCode;
+
+ if ((GetFillSizeFieldsFlags() == TRUE) &&
+ ((pIn->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT)) ||
+ (pOut->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT))))
+ {
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+ else if ((IsThin(pIn->resourceType, pIn->swizzleMode) == FALSE) ||
+ (IsNonPrtXor(pIn->swizzleMode) == FALSE) ||
+ (pIn->numSamples > 1))
+ {
+ returnCode = ADDR_NOTSUPPORTED;
+ }
+ else
+ {
+ returnCode = HwlComputeSlicePipeBankXor(pIn, pOut);
+ }
- // Todo - pOut->pipeBankXor = pOut->pipeBankXor << (PipeInterleaveLog2 - 8)
- pOut->pipeBankXor = (bankXor << pipeBits) | pipeXor;
+ return returnCode;
+}
- returnCode = ADDR_OK;
+/**
+************************************************************************************************************************
+* Lib::ComputeSubResourceOffsetForSwizzlePattern
+*
+* @brief
+* Interface function stub of Addr2ComputeSubResourceOffsetForSwizzlePattern.
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Lib::ComputeSubResourceOffsetForSwizzlePattern(
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut)
+{
+ ADDR_E_RETURNCODE returnCode;
+
+ if ((GetFillSizeFieldsFlags() == TRUE) &&
+ ((pIn->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT)) ||
+ (pOut->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT))))
+ {
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+ else
+ {
+ returnCode = HwlComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
}
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ExtractPipeBankXor
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ExtractPipeBankXor(
UINT_32 pipeBankXor,
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfoSanityCheck
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoSanityCheck(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in] input structure
) const
{
- ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
- BOOL_32 invalid = FALSE;
-
- if ((pIn->bpp > 128) || (pIn->width == 0) || (pIn->numFrags > 8) || (pIn->numSamples > 16))
- {
- invalid = TRUE;
- }
- else if ((pIn->swizzleMode >= ADDR_SW_MAX_TYPE) ||
- (pIn->resourceType >= ADDR_RSRC_MAX_TYPE))
- {
- invalid = TRUE;
- }
-
- BOOL_32 mipmap = (pIn->numMipLevels > 1);
- BOOL_32 msaa = (pIn->numFrags > 1);
-
- ADDR2_SURFACE_FLAGS flags = pIn->flags;
- BOOL_32 zbuffer = (flags.depth || flags.stencil);
- BOOL_32 color = flags.color;
- BOOL_32 display = flags.display || flags.rotated;
-
- AddrResourceType rsrcType = pIn->resourceType;
- BOOL_32 tex3d = IsTex3d(rsrcType);
-
- AddrSwizzleMode swizzle = pIn->swizzleMode;
- BOOL_32 linear = IsLinear(swizzle);
- BOOL_32 blk256B = IsBlock256b(swizzle);
- BOOL_32 blkVar = IsBlockVariable(swizzle);
- BOOL_32 isNonPrtXor = IsNonPrtXor(swizzle);
- BOOL_32 prt = pIn->flags.prt;
-
- if (invalid == FALSE)
- {
- if ((pIn->numFrags > 1) &&
- (GetBlockSize(swizzle) < (m_pipeInterleaveBytes * pIn->numFrags)))
- {
- // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
- invalid = TRUE;
- }
- }
-
- if (invalid == FALSE)
- {
- switch (rsrcType)
- {
- case ADDR_RSRC_TEX_1D:
- invalid = msaa || zbuffer || display || (linear == FALSE);
- break;
- case ADDR_RSRC_TEX_2D:
- invalid = msaa && mipmap;
- break;
- case ADDR_RSRC_TEX_3D:
- invalid = msaa || zbuffer || display;
- break;
- default:
- invalid = TRUE;
- break;
- }
- }
-
- if (invalid == FALSE)
- {
- if (display)
- {
- invalid = (IsValidDisplaySwizzleMode(pIn) == FALSE);
- }
- }
+ ADDR_E_RETURNCODE returnCode;
- if (invalid == FALSE)
+ if ((GetFillSizeFieldsFlags() == TRUE) &&
+ (pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT)))
{
- if (linear)
- {
- invalid = prt || zbuffer || msaa || (pIn->bpp == 0) || ((pIn->bpp % 8) != 0);
- }
- else
- {
- if (blk256B || blkVar || isNonPrtXor)
- {
- invalid = prt;
- if (blk256B)
- {
- invalid = invalid || zbuffer || tex3d || mipmap || msaa;
- }
- }
-
- if (invalid == FALSE)
- {
- if (IsZOrderSwizzle(swizzle))
- {
- invalid = color && msaa;
- }
- else if (IsStandardSwizzle(rsrcType, swizzle))
- {
- invalid = zbuffer;
- }
- else if (IsDisplaySwizzle(rsrcType, swizzle))
- {
- invalid = zbuffer;
- }
- else if (IsRotateSwizzle(swizzle))
- {
- invalid = zbuffer || (pIn->bpp > 64);
- }
- else
- {
- ADDR_ASSERT(!"invalid swizzle mode");
- invalid = TRUE;
- }
- }
- }
+ returnCode = ADDR_INVALIDPARAMS;
}
-
- if (invalid)
+ else
{
- returnCode = ADDR_INVALIDPARAMS;
+ returnCode = HwlComputeSurfaceInfoSanityCheck(pIn);
}
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ApplyCustomizedPitchHeight
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ApplyCustomizedPitchHeight(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
UINT_32 elementBytes, ///< [in] element bytes per element
- UINT_32 widthAlignInElement, ///< [in] pitch alignment in element
+ UINT_32 pitchAlignInElement, ///< [in] pitch alignment in element
UINT_32* pPitch, ///< [in/out] pitch
UINT_32* pHeight ///< [in/out] height
) const
{
if (pIn->pitchInElement > 0)
{
- if ((pIn->pitchInElement % widthAlignInElement) != 0)
+ if ((pIn->pitchInElement % pitchAlignInElement) != 0)
{
returnCode = ADDR_INVALIDPARAMS;
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfoLinear
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoLinear(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
UINT_32 pitch = 0;
UINT_32 actualHeight = 0;
UINT_32 elementBytes = pIn->bpp >> 3;
+ const UINT_32 alignment = pIn->flags.prt ? PrtAlignment : 256;
if (IsTex1d(pIn->resourceType))
{
}
else
{
- const UINT_32 widthAlignInElement = 256 / elementBytes;
- pitch = PowTwoAlign(pIn->width, widthAlignInElement);
+ const UINT_32 pitchAlignInElement = alignment / elementBytes;
+ pitch = PowTwoAlign(pIn->width, pitchAlignInElement);
actualHeight = pIn->numMipLevels;
- returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, widthAlignInElement,
- &pitch, &actualHeight);
+
+ if (pIn->flags.prt == FALSE)
+ {
+ returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, pitchAlignInElement,
+ &pitch, &actualHeight);
+ }
if (returnCode == ADDR_OK)
{
pOut->mipChainHeight = actualHeight;
pOut->mipChainSlice = pOut->numSlices;
pOut->epitchIsHeight = (pIn->numMipLevels > 1) ? TRUE : FALSE;
- pOut->sliceSize = pOut->pitch * actualHeight * elementBytes;
+ pOut->sliceSize = static_cast<UINT_64>(pOut->pitch) * actualHeight * elementBytes;
pOut->surfSize = pOut->sliceSize * pOut->numSlices;
- pOut->baseAlign = (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL) ? (pIn->bpp / 8) : 256;
+ pOut->baseAlign = (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL) ? (pIn->bpp / 8) : alignment;
pOut->blockWidth = (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL) ? 1 : (256 * 8 / pIn->bpp);
pOut->blockHeight = 1;
pOut->blockSlices = 1;
}
// Post calculation validate
- ADDR_ASSERT((pOut->sliceSize > 0));
+ ADDR_ASSERT(pOut->sliceSize > 0);
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfoTiled
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoTiled(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
- ADDR_E_RETURNCODE returnCode = ComputeBlockDimensionForSurf(&pOut->blockWidth,
- &pOut->blockHeight,
- &pOut->blockSlices,
- pIn->bpp,
- pIn->numFrags,
- pIn->resourceType,
- pIn->swizzleMode);
+ return HwlComputeSurfaceInfoTiled(pIn, pOut);
+}
- if (returnCode == ADDR_OK)
- {
- const UINT_32 widthAlignInElement = pOut->blockWidth;
+/**
+************************************************************************************************************************
+* Lib::ComputeSurfaceAddrFromCoordLinear
+*
+* @brief
+* Internal function to calculate address from coord for linear swizzle surface
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordLinear(
+ const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
+ ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
+ ) const
+{
+ ADDR_E_RETURNCODE returnCode = ADDR_OK;
+ BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1) && (pIn->pipeBankXor == 0);
- pOut->pitch = PowTwoAlign(pIn->width, widthAlignInElement);
+ if (valid)
+ {
+ if (IsTex1d(pIn->resourceType))
+ {
+ valid = (pIn->y == 0);
+ }
+ }
- if ((pIn->numMipLevels <= 1) && (pIn->pitchInElement > 0))
+ if (valid)
+ {
+ ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
+ localIn.bpp = pIn->bpp;
+ localIn.flags = pIn->flags;
+ localIn.width = Max(pIn->unalignedWidth, 1u);
+ localIn.height = Max(pIn->unalignedHeight, 1u);
+ localIn.numSlices = Max(pIn->numSlices, 1u);
+ localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
+ localIn.resourceType = pIn->resourceType;
+ if (localIn.numMipLevels <= 1)
{
- if ((pIn->pitchInElement % widthAlignInElement) != 0)
- {
- returnCode = ADDR_INVALIDPARAMS;
- }
- else if (pIn->pitchInElement < pOut->pitch)
- {
- returnCode = ADDR_INVALIDPARAMS;
- }
- else
- {
- pOut->pitch = pIn->pitchInElement;
- }
+ localIn.pitchInElement = pIn->pitchInElement;
}
-
- if (returnCode == ADDR_OK)
- {
- pOut->height = PowTwoAlign(pIn->height, pOut->blockHeight);
- pOut->numSlices = PowTwoAlign(pIn->numSlices, pOut->blockSlices);
-
- pOut->epitchIsHeight = FALSE;
- pOut->firstMipInTail = FALSE;
-
- pOut->mipChainPitch = pOut->pitch;
- pOut->mipChainHeight = pOut->height;
- pOut->mipChainSlice = pOut->numSlices;
-
- if (pIn->numMipLevels > 1)
- {
- UINT_32 numMipLevel;
- ADDR2_MIP_INFO *pMipInfo;
- ADDR2_MIP_INFO mipInfo[4];
-
- if (pOut->pMipInfo != NULL)
- {
- pMipInfo = pOut->pMipInfo;
- numMipLevel = pIn->numMipLevels;
- }
- else
- {
- pMipInfo = mipInfo;
- numMipLevel = Min(pIn->numMipLevels, 4u);
- }
-
- UINT_32 endingMip = GetMipChainInfo(pIn->resourceType,
- pIn->swizzleMode,
- pIn->bpp,
- pIn->width,
- pIn->height,
- pIn->numSlices,
- pOut->blockWidth,
- pOut->blockHeight,
- pOut->blockSlices,
- numMipLevel,
- pMipInfo);
-
- if (endingMip == 0)
- {
- pOut->epitchIsHeight = TRUE;
- pOut->pitch = pMipInfo[0].pitch;
- pOut->height = pMipInfo[0].height;
- pOut->numSlices = pMipInfo[0].depth;
- pOut->firstMipInTail = TRUE;
- }
- else
- {
- UINT_32 mip0WidthInBlk = pOut->pitch / pOut->blockWidth;
- UINT_32 mip0HeightInBlk = pOut->height / pOut->blockHeight;
-
- AddrMajorMode majorMode = GetMajorMode(pIn->resourceType,
- pIn->swizzleMode,
- mip0WidthInBlk,
- mip0HeightInBlk,
- pOut->numSlices / pOut->blockSlices);
- if (majorMode == ADDR_MAJOR_Y)
- {
- UINT_32 mip1WidthInBlk = RoundHalf(mip0WidthInBlk);
-
- if ((mip1WidthInBlk == 1) && (endingMip > 2))
- {
- mip1WidthInBlk++;
- }
-
- pOut->mipChainPitch += (mip1WidthInBlk * pOut->blockWidth);
-
- pOut->epitchIsHeight = FALSE;
- }
- else
- {
- UINT_32 mip1HeightInBlk = RoundHalf(mip0HeightInBlk);
-
- if ((mip1HeightInBlk == 1) && (endingMip > 2))
- {
- mip1HeightInBlk++;
- }
-
- pOut->mipChainHeight += (mip1HeightInBlk * pOut->blockHeight);
-
- pOut->epitchIsHeight = TRUE;
- }
- }
- }
- else if (pOut->pMipInfo != NULL)
- {
- pOut->pMipInfo[0].pitch = pOut->pitch;
- pOut->pMipInfo[0].height = pOut->height;
- pOut->pMipInfo[0].depth = IsTex3d(pIn->resourceType)? pOut->numSlices : 1;
- pOut->pMipInfo[0].offset = 0;
- }
-
- pOut->sliceSize = pOut->mipChainPitch *pOut->mipChainHeight *
- (pIn->bpp >> 3) * pIn->numFrags;
- pOut->surfSize = pOut->sliceSize * pOut->mipChainSlice;
- pOut->baseAlign = ComputeSurfaceBaseAlign(pIn->swizzleMode);
- }
- }
-
- return returnCode;
-}
-
-/**
-****************************************************************************************************
-* Lib::ComputeSurfaceAddrFromCoordLinear
-*
-* @brief
-* Internal function to calculate address from coord for linear swizzle surface
-*
-* @return
-* ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordLinear(
- const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
- ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
- ) const
-{
- ADDR_E_RETURNCODE returnCode = ADDR_OK;
- BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1) && (pIn->pipeBankXor == 0);
-
- if (valid)
- {
- if (IsTex1d(pIn->resourceType))
- {
- valid = (pIn->y == 0);
- }
- }
-
- if (valid)
- {
- ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
- ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
- localIn.bpp = pIn->bpp;
- localIn.width = Max(pIn->unalignedWidth, 1u);
- localIn.height = Max(pIn->unalignedHeight, 1u);
- localIn.numSlices = Max(pIn->numSlices, 1u);
- localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
- localIn.resourceType = pIn->resourceType;
- if (localIn.numMipLevels <= 1)
- {
- localIn.pitchInElement = pIn->pitchInElement;
- }
- returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
+ returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
if (returnCode == ADDR_OK)
{
UINT_32 elementBytes = pIn->bpp >> 3;
- UINT_64 sliceOffsetInSurf = static_cast<UINT_64>(pIn->slice) * localOut.sliceSize;
+ UINT_64 sliceOffsetInSurf = localOut.sliceSize * pIn->slice;
UINT_64 mipOffsetInSlice = 0;
UINT_64 offsetInMip = 0;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceAddrFromCoordTiled
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordTiled(
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
- ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
- localIn.swizzleMode = pIn->swizzleMode;
- localIn.flags = pIn->flags;
- localIn.resourceType = pIn->resourceType;
- localIn.bpp = pIn->bpp;
- localIn.width = Max(pIn->unalignedWidth, 1u);
- localIn.height = Max(pIn->unalignedHeight, 1u);
- localIn.numSlices = Max(pIn->numSlices, 1u);
- localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
- if (localIn.numMipLevels <= 1)
- {
- localIn.pitchInElement = pIn->pitchInElement;
- }
-
- ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
- ADDR_E_RETURNCODE returnCode = ComputeSurfaceInfoTiled(&localIn, &localOut);
-
- BOOL_32 valid = (returnCode == ADDR_OK) &&
- (IsThin(pIn->resourceType, pIn->swizzleMode) ||
- IsThick(pIn->resourceType, pIn->swizzleMode)) &&
- ((pIn->pipeBankXor == 0) || (IsXor(pIn->swizzleMode)));
-
- if (valid)
- {
- Dim3d mipStartPos = {0};
- UINT_32 mipTailOffset = 0;
-
- if (pIn->numMipLevels > 1)
- {
- // Mip-map chain cannot be MSAA surface
- ADDR_ASSERT((pIn->numSamples <= 1) && (pIn->numFrags<= 1));
-
- mipStartPos = GetMipStartPos(pIn->resourceType,
- pIn->swizzleMode,
- localOut.pitch,
- localOut.height,
- localOut.numSlices,
- localOut.blockWidth,
- localOut.blockHeight,
- localOut.blockSlices,
- pIn->mipId,
- &mipTailOffset);
- }
-
- UINT_32 interleaveOffset = 0;
- UINT_32 pipeBits = 0;
- UINT_32 pipeXor = 0;
- UINT_32 bankBits = 0;
- UINT_32 bankXor = 0;
-
- if (IsThin(pIn->resourceType, pIn->swizzleMode))
- {
- UINT_32 blockOffset = 0;
- UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
- UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
-
- if (IsZOrderSwizzle(pIn->swizzleMode))
- {
- // Morton generation
- if ((log2ElementBytes == 0) || (log2ElementBytes == 2))
- {
- UINT_32 totalLowBits = 6 - log2ElementBytes;
- UINT_32 mortBits = totalLowBits / 2;
- UINT_32 lowBitsValue = MortonGen2d(pIn->y, pIn->x, mortBits);
- // Are 9 bits enough?
- UINT_32 highBitsValue =
- MortonGen2d(pIn->x >> mortBits, pIn->y >> mortBits, 9) << totalLowBits;
- blockOffset = lowBitsValue | highBitsValue;
- ADDR_ASSERT(blockOffset == lowBitsValue + highBitsValue);
- }
- else
- {
- blockOffset = MortonGen2d(pIn->y, pIn->x, 13);
- }
-
- // Fill LSBs with sample bits
- if (pIn->numSamples > 1)
- {
- blockOffset *= pIn->numSamples;
- blockOffset |= pIn->sample;
- }
-
- // Shift according to BytesPP
- blockOffset <<= log2ElementBytes;
- }
- else
- {
- // Micro block offset
- UINT_32 microBlockOffset = ComputeSurface2DMicroBlockOffset(pIn);
- blockOffset = microBlockOffset;
-
- // Micro block dimension
- ADDR_ASSERT(log2ElementBytes < sizeof(Block256b) / sizeof(Block256b[0]));
- Dim2d microBlockDim = Block256b[log2ElementBytes];
- // Morton generation, does 12 bit enough?
- blockOffset |=
- MortonGen2d((pIn->x / microBlockDim.w), (pIn->y / microBlockDim.h), 12) << 8;
-
- // Sample bits start location
- UINT_32 sampleStart = log2blkSize - Log2(pIn->numSamples);
- // Join sample bits information to the highest Macro block bits
- if (IsNonPrtXor(pIn->swizzleMode))
- {
- // Non-prt-Xor : xor highest Macro block bits with sample bits
- blockOffset = blockOffset ^ (pIn->sample << sampleStart);
- }
- else
- {
- // Non-Xor or prt-Xor: replace highest Macro block bits with sample bits
- // after this op, the blockOffset only contains log2 Macro block size bits
- blockOffset %= (1 << sampleStart);
- blockOffset |= (pIn->sample << sampleStart);
- ADDR_ASSERT((blockOffset >> log2blkSize) == 0);
- }
- }
-
- if (IsXor(pIn->swizzleMode))
- {
- // Mask off bits above Macro block bits to keep page synonyms working for prt
- if (IsPrt(pIn->swizzleMode))
- {
- blockOffset &= ((1 << log2blkSize) - 1);
- }
-
- // Preserve offset inside pipe interleave
- interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
- blockOffset >>= m_pipeInterleaveLog2;
-
- // Pipe/Se xor bits
- pipeBits = GetPipeXorBits(log2blkSize);
- // Pipe xor
- pipeXor = FoldXor2d(blockOffset, pipeBits);
- blockOffset >>= pipeBits;
-
- // Bank xor bits
- bankBits = GetBankXorBits(log2blkSize);
- // Bank Xor
- bankXor = FoldXor2d(blockOffset, bankBits);
- blockOffset >>= bankBits;
-
- // Put all the part back together
- blockOffset <<= bankBits;
- blockOffset |= bankXor;
- blockOffset <<= pipeBits;
- blockOffset |= pipeXor;
- blockOffset <<= m_pipeInterleaveLog2;
- blockOffset |= interleaveOffset;
- }
-
- ADDR_ASSERT((blockOffset | mipTailOffset) == (blockOffset + mipTailOffset));
- blockOffset |= mipTailOffset;
-
- if (IsNonPrtXor(pIn->swizzleMode) && (pIn->numSamples <= 1))
- {
- // Apply slice xor if not MSAA/PRT
- blockOffset ^= (ReverseBitVector(pIn->slice, pipeBits) << m_pipeInterleaveLog2);
- blockOffset ^= (ReverseBitVector(pIn->slice >> pipeBits, bankBits) <<
- (m_pipeInterleaveLog2 + pipeBits));
- }
-
- returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
- bankBits, pipeBits, &blockOffset);
-
- blockOffset %= (1 << log2blkSize);
-
- UINT_32 pitchInMacroBlock = localOut.mipChainPitch / localOut.blockWidth;
- UINT_32 paddedHeightInMacroBlock = localOut.mipChainHeight / localOut.blockHeight;
- UINT_32 sliceSizeInMacroBlock = pitchInMacroBlock * paddedHeightInMacroBlock;
- UINT_32 macroBlockIndex =
- (pIn->slice + mipStartPos.d) * sliceSizeInMacroBlock +
- ((pIn->y / localOut.blockHeight) + mipStartPos.h) * pitchInMacroBlock +
- ((pIn->x / localOut.blockWidth) + mipStartPos.w);
-
- UINT_64 macroBlockOffset = (static_cast<UINT_64>(macroBlockIndex) <<
- GetBlockSizeLog2(pIn->swizzleMode));
-
- pOut->addr = blockOffset | macroBlockOffset;
- }
- else
- {
- UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
- UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
-
- Dim3d microBlockDim = Block1kb[log2ElementBytes];
-
- UINT_32 blockOffset = MortonGen3d((pIn->x / microBlockDim.w),
- (pIn->y / microBlockDim.h),
- (pIn->slice / microBlockDim.d),
- 8);
-
- blockOffset <<= 10;
- blockOffset |= ComputeSurface3DMicroBlockOffset(pIn);
-
- if (IsXor(pIn->swizzleMode))
- {
- // Mask off bits above Macro block bits to keep page synonyms working for prt
- if (IsPrt(pIn->swizzleMode))
- {
- blockOffset &= ((1 << log2blkSize) - 1);
- }
-
- // Preserve offset inside pipe interleave
- interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
- blockOffset >>= m_pipeInterleaveLog2;
-
- // Pipe/Se xor bits
- pipeBits = GetPipeXorBits(log2blkSize);
- // Pipe xor
- pipeXor = FoldXor3d(blockOffset, pipeBits);
- blockOffset >>= pipeBits;
-
- // Bank xor bits
- bankBits = GetBankXorBits(log2blkSize);
- // Bank Xor
- bankXor = FoldXor3d(blockOffset, bankBits);
- blockOffset >>= bankBits;
-
- // Put all the part back together
- blockOffset <<= bankBits;
- blockOffset |= bankXor;
- blockOffset <<= pipeBits;
- blockOffset |= pipeXor;
- blockOffset <<= m_pipeInterleaveLog2;
- blockOffset |= interleaveOffset;
- }
-
- ADDR_ASSERT((blockOffset | mipTailOffset) == (blockOffset + mipTailOffset));
- blockOffset |= mipTailOffset;
-
- returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
- bankBits, pipeBits, &blockOffset);
-
- blockOffset %= (1 << log2blkSize);
-
- UINT_32 xb = (pIn->x + mipStartPos.w) / localOut.blockWidth;
- UINT_32 yb = (pIn->y + mipStartPos.h) / localOut.blockHeight;
- UINT_32 zb = (pIn->slice + mipStartPos.d) / localOut.blockSlices;
-
- UINT_32 pitchInBlock = localOut.mipChainPitch / localOut.blockWidth;
- UINT_32 sliceSizeInBlock =
- (localOut.mipChainHeight / localOut.blockHeight) * pitchInBlock;
- UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
-
- pOut->addr = blockOffset | (blockIndex << log2blkSize);
- }
- }
- else
- {
- returnCode = ADDR_INVALIDPARAMS;
- }
-
- return returnCode;
+ return HwlComputeSurfaceAddrFromCoordTiled(pIn, pOut);
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddrLinear
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrLinear(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
if (valid)
{
- ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
+ ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
- localIn.bpp = pIn->bpp;
- localIn.width = Max(pIn->unalignedWidth, 1u);
- localIn.height = Max(pIn->unalignedHeight, 1u);
- localIn.numSlices = Max(pIn->numSlices, 1u);
+ localIn.bpp = pIn->bpp;
+ localIn.flags = pIn->flags;
+ localIn.width = Max(pIn->unalignedWidth, 1u);
+ localIn.height = Max(pIn->unalignedHeight, 1u);
+ localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
localIn.resourceType = pIn->resourceType;
if (localIn.numMipLevels <= 1)
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddrTiled
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrTiled(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurfaceInfoLinear
*
* @brief
*
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceLinearPadding(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input srtucture
ADDR_E_RETURNCODE returnCode = ADDR_OK;
UINT_32 elementBytes = pIn->bpp >> 3;
- UINT_32 widthAlignInElement = 0;
+ UINT_32 pitchAlignInElement = 0;
if (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL)
{
ADDR_ASSERT(pIn->numMipLevels <= 1);
ADDR_ASSERT(pIn->numSlices <= 1);
- widthAlignInElement = 1;
+ pitchAlignInElement = 1;
}
else
{
- widthAlignInElement = (256 / elementBytes);
+ pitchAlignInElement = (256 / elementBytes);
}
- UINT_32 mipChainWidth = PowTwoAlign(pIn->width, widthAlignInElement);
+ UINT_32 mipChainWidth = PowTwoAlign(pIn->width, pitchAlignInElement);
UINT_32 slice0PaddedHeight = pIn->height;
- returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, widthAlignInElement,
+ returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, pitchAlignInElement,
&mipChainWidth, &slice0PaddedHeight);
if (returnCode == ADDR_OK)
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeBlockDimensionForSurf
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE Lib::ComputeBlockDimensionForSurf(
- Dim3d* pDim,
- UINT_32 bpp,
- UINT_32 numSamples,
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode) const
-{
- return ComputeBlockDimensionForSurf(&pDim->w, &pDim->h, &pDim->d, bpp,
- numSamples, resourceType, swizzleMode);
-}
-
-/**
-****************************************************************************************************
-* Lib::ComputeBlockDimensionForSurf
-*
-* @brief
-* Internal function to get block width/height/depth in element from surface input params.
-*
-* @return
-* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlockDimensionForSurf(
UINT_32* pWidth,
if ((returnCode == ADDR_OK) && (numSamples > 1) && IsThin(resourceType, swizzleMode))
{
- UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
- UINT_32 sample = numSamples;
- UINT_32 log2sample = Log2(sample);
+ const UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
+ const UINT_32 log2sample = Log2(numSamples);
+ const UINT_32 q = log2sample >> 1;
+ const UINT_32 r = log2sample & 1;
- *pWidth >>= (log2sample / 2);
- *pHeight >>= (log2sample / 2);
-
- if ((log2blkSize % 2) == 0)
+ if (log2blkSize & 1)
{
- *pWidth >>= (sample % 2);
+ *pWidth >>= q;
+ *pHeight >>= (q + r);
}
else
{
- *pHeight >>= (sample % 2);
+ *pWidth >>= (q + r);
+ *pHeight >>= q;
}
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeBlockDimension
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlockDimension(
UINT_32* pWidth,
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- UINT_32 eleBytes = bpp >> 3;
+ UINT_32 eleBytes = bpp >> 3;
UINT_32 microBlockSizeTableIndex = Log2(eleBytes);
- UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
+ UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
if (IsThin(resourceType, swizzleMode))
{
- if (pDepth != NULL)
- {
- *pDepth = 1;
- }
-
UINT_32 log2blkSizeIn256B = log2blkSize - 8;
- UINT_32 widthAmp = log2blkSizeIn256B / 2;
- UINT_32 heightAmp = log2blkSizeIn256B - widthAmp;
+ UINT_32 widthAmp = log2blkSizeIn256B / 2;
+ UINT_32 heightAmp = log2blkSizeIn256B - widthAmp;
- ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block256b) / sizeof(Block256b[0]));
+ ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block256_2d) / sizeof(Block256_2d[0]));
- *pWidth = (Block256b[microBlockSizeTableIndex].w << widthAmp);
- *pHeight = (Block256b[microBlockSizeTableIndex].h << heightAmp);
+ *pWidth = (Block256_2d[microBlockSizeTableIndex].w << widthAmp);
+ *pHeight = (Block256_2d[microBlockSizeTableIndex].h << heightAmp);
+ *pDepth = 1;
}
else if (IsThick(resourceType, swizzleMode))
{
UINT_32 log2blkSizeIn1KB = log2blkSize - 10;
- UINT_32 averageAmp = log2blkSizeIn1KB / 3;
- UINT_32 restAmp = log2blkSizeIn1KB % 3;
+ UINT_32 averageAmp = log2blkSizeIn1KB / 3;
+ UINT_32 restAmp = log2blkSizeIn1KB % 3;
- ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block1kb) / sizeof(Block1kb[0]));
+ ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block1K_3d) / sizeof(Block1K_3d[0]));
- *pWidth = Block1kb[microBlockSizeTableIndex].w << averageAmp;
- *pHeight = Block1kb[microBlockSizeTableIndex].h << (averageAmp + (restAmp / 2));
- *pDepth = Block1kb[microBlockSizeTableIndex].d << (averageAmp + ((restAmp != 0) ? 1 : 0));
+ *pWidth = Block1K_3d[microBlockSizeTableIndex].w << averageAmp;
+ *pHeight = Block1K_3d[microBlockSizeTableIndex].h << (averageAmp + (restAmp / 2));
+ *pDepth = Block1K_3d[microBlockSizeTableIndex].d << (averageAmp + ((restAmp != 0) ? 1 : 0));
}
else
{
}
/**
-****************************************************************************************************
-* Lib::GetMipChainInfo
-*
-* @brief
-* Internal function to get out information about mip chain
-*
-* @return
-* Smaller value between Id of first mip fitted in mip tail and max Id of mip being created
-****************************************************************************************************
-*/
-UINT_32 Lib::GetMipChainInfo(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 bpp,
- UINT_32 mip0Width,
- UINT_32 mip0Height,
- UINT_32 mip0Depth,
- UINT_32 blockWidth,
- UINT_32 blockHeight,
- UINT_32 blockDepth,
- UINT_32 numMipLevel,
- ADDR2_MIP_INFO* pMipInfo) const
-{
- const Dim3d tailMaxDim =
- GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
-
- UINT_32 mipPitch = mip0Width;
- UINT_32 mipHeight = mip0Height;
- UINT_32 mipDepth = IsTex3d(resourceType) ? mip0Depth : 1;
- UINT_32 offset = 0;
- UINT_32 endingMip = numMipLevel - 1;
- BOOL_32 inTail = FALSE;
- BOOL_32 finalDim = FALSE;
-
- BOOL_32 is3dThick = IsThick(resourceType, swizzleMode);
- BOOL_32 is3dThin = IsTex3d(resourceType) && SwizzleModeTable[swizzleMode].isDisp;
-
- for (UINT_32 mipId = 0; mipId < numMipLevel; mipId++)
- {
- if (inTail)
- {
- if (finalDim == FALSE)
- {
- UINT_32 mipSize;
-
- if (is3dThick)
- {
- mipSize = mipPitch * mipHeight * mipDepth * (bpp >> 3);
- }
- else
- {
- mipSize = mipPitch * mipHeight * (bpp >> 3);
- }
-
- if (mipSize <= 256)
- {
- UINT_32 index = Log2(bpp >> 3);
-
- if (is3dThick)
- {
- mipPitch = CompressBlock3dZ[index].w;
- mipHeight = CompressBlock3dZ[index].h;
- mipDepth = CompressBlock3dZ[index].d;
- }
- else
- {
- mipPitch = CompressBlock2d[index].w;
- mipHeight = CompressBlock2d[index].h;
- }
-
- finalDim = TRUE;
- }
- }
- }
- else
- {
- inTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim,
- mipPitch, mipHeight, mipDepth);
-
- if (inTail)
- {
- endingMip = mipId;
-
- mipPitch = tailMaxDim.w;
- mipHeight = tailMaxDim.h;
-
- if (is3dThick)
- {
- mipDepth = tailMaxDim.d;
- }
- }
- else
- {
- mipPitch = PowTwoAlign(mipPitch, blockWidth);
- mipHeight = PowTwoAlign(mipHeight, blockHeight);
-
- if (is3dThick)
- {
- mipDepth = PowTwoAlign(mipDepth, blockDepth);
- }
- }
- }
-
- pMipInfo[mipId].pitch = mipPitch;
- pMipInfo[mipId].height = mipHeight;
- pMipInfo[mipId].depth = mipDepth;
- pMipInfo[mipId].offset = offset;
- offset += (mipPitch * mipHeight * mipDepth * (bpp >> 3));
-
- if (finalDim)
- {
- if (is3dThin)
- {
- mipDepth = Max(mipDepth >> 1, 1u);
- }
- }
- else
- {
- mipPitch = Max(mipPitch >> 1, 1u);
- mipHeight = Max(mipHeight >> 1, 1u);
-
- if (is3dThick || is3dThin)
- {
- mipDepth = Max(mipDepth >> 1, 1u);
- }
- }
- }
-
- return endingMip;
-}
-
-/**
-****************************************************************************************************
-* Lib::GetMipStartPos
-*
-* @brief
-* Internal function to get out information about mip logical start position
-*
-* @return
-* logical start position in macro block width/heith/depth of one mip level within one slice
-****************************************************************************************************
-*/
-Dim3d Lib::GetMipStartPos(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 width,
- UINT_32 height,
- UINT_32 depth,
- UINT_32 blockWidth,
- UINT_32 blockHeight,
- UINT_32 blockDepth,
- UINT_32 mipId,
- UINT_32* pMipTailOffset) const
-{
- Dim3d mipStartPos = {0};
-
- const Dim3d tailMaxDim =
- GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
-
- // Report mip in tail if Mip0 is already in mip tail
- BOOL_32 inMipTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim, width, height, depth);
-
- UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
-
- if (inMipTail == FALSE)
- {
- // Mip 0 dimension, unit in block
- UINT_32 mipWidthInBlk = width / blockWidth;
- UINT_32 mipHeightInBlk = height / blockHeight;
- UINT_32 mipDepthInBlk = depth / blockDepth;
- AddrMajorMode majorMode = GetMajorMode(resourceType,
- swizzleMode,
- mipWidthInBlk,
- mipHeightInBlk,
- mipDepthInBlk);
-
- UINT_32 endingMip = mipId + 1;
-
- for (UINT_32 i = 1; i <= mipId; i++)
- {
- if ((i == 1) || (i == 3))
- {
- if (majorMode == ADDR_MAJOR_Y)
- {
- mipStartPos.w += mipWidthInBlk;
- }
- else
- {
- mipStartPos.h += mipHeightInBlk;
- }
- }
- else
- {
- if (majorMode == ADDR_MAJOR_X)
- {
- mipStartPos.w += mipWidthInBlk;
- }
- else if (majorMode == ADDR_MAJOR_Y)
- {
- mipStartPos.h += mipHeightInBlk;
- }
- else
- {
- mipStartPos.d += mipDepthInBlk;
- }
- }
-
- BOOL_32 inTail = FALSE;
-
- if (IsThick(resourceType, swizzleMode))
- {
- UINT_32 dim = log2blkSize % 3;
-
- if (dim == 0)
- {
- inTail =
- (mipWidthInBlk <= 2) && (mipHeightInBlk == 1) && (mipDepthInBlk <= 2);
- }
- else if (dim == 1)
- {
- inTail =
- (mipWidthInBlk == 1) && (mipHeightInBlk <= 2) && (mipDepthInBlk <= 2);
- }
- else
- {
- inTail =
- (mipWidthInBlk <= 2) && (mipHeightInBlk <= 2) && (mipDepthInBlk == 1);
- }
- }
- else
- {
- if (log2blkSize & 1)
- {
- inTail = (mipWidthInBlk <= 2) && (mipHeightInBlk == 1);
- }
- else
- {
- inTail = (mipWidthInBlk == 1) && (mipHeightInBlk <= 2);
- }
- }
-
- if (inTail)
- {
- endingMip = i;
- break;
- }
-
- mipWidthInBlk = RoundHalf(mipWidthInBlk);
- mipHeightInBlk = RoundHalf(mipHeightInBlk);
- mipDepthInBlk = RoundHalf(mipDepthInBlk);
- }
-
- if (mipId >= endingMip)
- {
- inMipTail = TRUE;
- UINT_32 index = mipId - endingMip + MaxMacroBits - log2blkSize;
- ADDR_ASSERT(index < sizeof(MipTailOffset) / sizeof(UINT_32));
- *pMipTailOffset = MipTailOffset[index] << 8;
- }
- }
- else
- {
- UINT_32 index = mipId + MaxMacroBits - log2blkSize;
- ADDR_ASSERT(index < sizeof(MipTailOffset) / sizeof(UINT_32));
- *pMipTailOffset = MipTailOffset[index] << 8;
- }
-
- return mipStartPos;
-}
-
-/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::GetMipTailDim
*
* @brief
*
* @return
* Max Width/Height/Depth value of the first mip fitted in mip tail
-****************************************************************************************************
+************************************************************************************************************************
*/
Dim3d Lib::GetMipTailDim(
AddrResourceType resourceType,
UINT_32 blockHeight,
UINT_32 blockDepth) const
{
- Dim3d out = {blockWidth, blockHeight, blockDepth};
+ Dim3d out = {blockWidth, blockHeight, blockDepth};
UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
if (IsThick(resourceType, swizzleMode))
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurface2DMicroBlockOffset
*
* @brief
*
* @return
* micro block (256B) offset for 2D resource
-****************************************************************************************************
+************************************************************************************************************************
*/
UINT_32 Lib::ComputeSurface2DMicroBlockOffset(
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeSurface3DMicroBlockOffset
*
* @brief
*
* @return
* micro block (1KB) offset for 3D resource
-****************************************************************************************************
+************************************************************************************************************************
*/
UINT_32 Lib::ComputeSurface3DMicroBlockOffset(
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::GetPipeXorBits
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
UINT_32 Lib::GetPipeXorBits(
UINT_32 macroBlockBits) const
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::GetBankXorBits
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
UINT_32 Lib::GetBankXorBits(
UINT_32 macroBlockBits) const
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::Addr2GetPreferredSurfaceSetting
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::Addr2GetPreferredSurfaceSetting(
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
{
- // Macro define resource block type
- enum AddrBlockType
- {
- AddrBlockMicro = 0, // Resource uses 256B block
- AddrBlock4KB = 1, // Resource uses 4KB block
- AddrBlock64KB = 2, // Resource uses 64KB block
- AddrBlockVar = 3, // Resource uses var blcok
- AddrBlockLinear = 4, // Resource uses linear swizzle mode
-
- AddrBlockMaxTiledType = AddrBlock64KB + 1,
- };
-
- enum AddrBlockSet
- {
- AddrBlockSetMicro = 1 << AddrBlockMicro,
- AddrBlockSetMacro4KB = 1 << AddrBlock4KB,
- AddrBlockSetMacro64KB = 1 << AddrBlock64KB,
- AddrBlockSetVar = 1 << AddrBlockVar,
- AddrBlockSetLinear = 1 << AddrBlockLinear,
-
- AddrBlockSetMacro = AddrBlockSetMacro4KB | AddrBlockSetMacro64KB,
- };
-
- ADDR_E_RETURNCODE returnCode = ADDR_OK;
- ElemLib* pElemLib = GetElemLib();
-
- // Set format to INVALID will skip this conversion
- UINT_32 expandX = 1;
- UINT_32 expandY = 1;
- UINT_32 bpp = pIn->bpp;
- if (pIn->format != ADDR_FMT_INVALID)
- {
- // Don't care for this case
- ElemMode elemMode = ADDR_UNCOMPRESSED;
-
- // Get compression/expansion factors and element mode which indicates compression/expansion
- bpp = pElemLib->GetBitsPerPixel(pIn->format,
- &elemMode,
- &expandX,
- &expandY);
- }
-
- UINT_32 numSamples = Max(pIn->numSamples, 1u);
- UINT_32 numFrags = (pIn->numFrags == 0) ? numSamples : pIn->numFrags;
- UINT_32 width = Max(pIn->width / expandX, 1u);
- UINT_32 height = Max(pIn->height / expandY, 1u);
- UINT_32 slice = Max(pIn->numSlices, 1u);
- UINT_32 numMipLevels = Max(pIn->numMipLevels, 1u);
+ ADDR_E_RETURNCODE returnCode;
- if (pIn->flags.fmask)
+ if ((GetFillSizeFieldsFlags() == TRUE) &&
+ ((pIn->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_INPUT)) ||
+ (pOut->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT))))
{
- bpp = GetFmaskBpp(numSamples, numFrags);
- numFrags = 1;
- numSamples = 1;
- pOut->resourceType = ADDR_RSRC_TEX_2D;
+ returnCode = ADDR_INVALIDPARAMS;
}
else
{
- // The output may get changed for volume(3D) texture resource in future
- pOut->resourceType = pIn->resourceType;
- }
-
- if (IsTex1d(pOut->resourceType))
- {
- pOut->swizzleMode = ADDR_SW_LINEAR;
- pOut->validBlockSet.value = AddrBlockSetLinear;
- pOut->canXor = FALSE;
- }
- else
- {
- ADDR2_BLOCK_SET blockSet;
- AddrSwType swType;
-
- blockSet.value = 0;
-
- BOOL_32 tryPrtXor = pIn->flags.prt;
-
- // Filter out improper swType and blockSet by HW restriction
- if (pIn->flags.fmask || pIn->flags.depth || pIn->flags.stencil)
- {
- ADDR_ASSERT(IsTex2d(pOut->resourceType));
- blockSet.value = AddrBlockSetMacro;
- swType = ADDR_SW_Z;
- }
- else if (pElemLib->IsBlockCompressed(pIn->format))
- {
- // block compressed formats (BCx, ASTC, ETC2) must be either S or D modes. Not sure
- // under what circumstances "_D" would be appropriate as these formats are not
- // displayable.
- blockSet.value = AddrBlockSetMacro;
- swType = ADDR_SW_S;
- }
- else if (IsTex3d(pOut->resourceType))
- {
- blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
- swType = (slice >= 8) ? ADDR_SW_Z : ADDR_SW_S;
- }
- else if (numMipLevels > 1)
- {
- ADDR_ASSERT(numFrags == 1);
- blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
- swType = pIn->flags.display ? ADDR_SW_D : ADDR_SW_S;
- }
- else if ((numFrags > 1) || (numSamples > 1))
- {
- ADDR_ASSERT(IsTex2d(pOut->resourceType));
- blockSet.value = AddrBlockSetMacro;
- swType = pIn->flags.display ? ADDR_SW_D : ADDR_SW_S;
- }
- else
- {
- ADDR_ASSERT(IsTex2d(pOut->resourceType));
- blockSet.value = AddrBlockSetLinear | AddrBlockSetMicro | AddrBlockSetMacro;
- if (pIn->flags.rotated || pIn->flags.display)
- {
- swType = pIn->flags.rotated ? ADDR_SW_R : ADDR_SW_D;
-
- if (IsDce12())
- {
- if (pIn->bpp != 32)
- {
- blockSet.micro = FALSE;
- }
-
- // DCE12 does not support display surface to be _T swizzle mode
- tryPrtXor = FALSE;
- }
- else
- {
- ADDR_NOT_IMPLEMENTED();
- }
- }
- else if (pIn->flags.overlay)
- {
- swType = ADDR_SW_D;
- }
- else
- {
- swType = ADDR_SW_S;
- }
- }
-
- if ((numFrags > 1) &&
- (GetBlockSize(ADDR_SW_4KB) < (m_pipeInterleaveBytes * numFrags)))
- {
- // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
- blockSet.macro4KB = FALSE;
- }
-
- if (pIn->flags.prt)
- {
- blockSet.value &= AddrBlock64KB;
- }
-
- // Apply customized forbidden setting
- blockSet.value &= ~pIn->forbiddenBlock.value;
-
- if (pIn->maxAlign > 0)
- {
- if (pIn->maxAlign < GetBlockSize(ADDR_SW_64KB))
- {
- blockSet.macro64KB = FALSE;
- }
-
- if (pIn->maxAlign < GetBlockSize(ADDR_SW_4KB))
- {
- blockSet.macro4KB = FALSE;
- }
-
- if (pIn->maxAlign < GetBlockSize(ADDR_SW_256B))
- {
- blockSet.micro = FALSE;
- }
- }
-
- Dim3d blkDim[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
- Dim3d padDim[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
- UINT_64 padSize[AddrBlockMaxTiledType] = {0};
-
- if (blockSet.micro)
- {
- returnCode = ComputeBlockDimensionForSurf(&blkDim[AddrBlockMicro],
- bpp,
- numFrags,
- pOut->resourceType,
- ADDR_SW_256B);
-
- if (returnCode == ADDR_OK)
- {
- if ((blkDim[AddrBlockMicro].w >= width) && (blkDim[AddrBlockMicro].h >= height))
- {
- // If one 256B block can contain the surface, don't bother bigger block type
- blockSet.macro4KB = FALSE;
- blockSet.macro64KB = FALSE;
- blockSet.var = FALSE;
- }
-
- padSize[AddrBlockMicro] = ComputePadSize(&blkDim[AddrBlockMicro], width, height,
- slice, &padDim[AddrBlockMicro]);
- }
- }
-
- if ((returnCode == ADDR_OK) && (blockSet.macro4KB))
- {
- returnCode = ComputeBlockDimensionForSurf(&blkDim[AddrBlock4KB],
- bpp,
- numFrags,
- pOut->resourceType,
- ADDR_SW_4KB);
-
- if (returnCode == ADDR_OK)
- {
- padSize[AddrBlock4KB] = ComputePadSize(&blkDim[AddrBlock4KB], width, height,
- slice, &padDim[AddrBlock4KB]);
-
- ADDR_ASSERT(padSize[AddrBlock4KB] >= padSize[AddrBlockMicro]);
- }
- }
-
- if ((returnCode == ADDR_OK) && (blockSet.macro64KB))
- {
- returnCode = ComputeBlockDimensionForSurf(&blkDim[AddrBlock64KB],
- bpp,
- numFrags,
- pOut->resourceType,
- ADDR_SW_64KB);
-
- if (returnCode == ADDR_OK)
- {
- padSize[AddrBlock64KB] = ComputePadSize(&blkDim[AddrBlock64KB], width, height,
- slice, &padDim[AddrBlock64KB]);
-
- ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlock4KB]);
- ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlockMicro]);
-
- if ((padSize[AddrBlock64KB] >= static_cast<UINT_64>(width) * height * slice * 2) &&
- ((blockSet.value & ~AddrBlockSetMacro64KB) != 0))
- {
- // If 64KB block waste more than half memory on padding, filter it out from
- // candidate list when it is not the only choice left
- blockSet.macro64KB = FALSE;
- }
- }
- }
-
- if (returnCode == ADDR_OK)
- {
- // Use minimum block type which meets all conditions above if flag minimizeAlign was set
- if (pIn->flags.minimizeAlign)
- {
- // If padded size of 64KB block is larger than padded size of 256B block or 4KB
- // block, filter out 64KB block from candidate list
- if (blockSet.macro64KB &&
- ((blockSet.micro && (padSize[AddrBlockMicro] < padSize[AddrBlock64KB])) ||
- (blockSet.macro4KB && (padSize[AddrBlock4KB] < padSize[AddrBlock64KB]))))
- {
- blockSet.macro64KB = FALSE;
- }
-
- // If padded size of 4KB block is larger than padded size of 256B block,
- // filter out 4KB block from candidate list
- if (blockSet.macro4KB &&
- blockSet.micro &&
- (padSize[AddrBlockMicro] < padSize[AddrBlock4KB]))
- {
- blockSet.macro4KB = FALSE;
- }
- }
- // Filter out 64KB/4KB block if a smaller block type has 2/3 or less memory footprint
- else if (pIn->flags.opt4space)
- {
- UINT_64 threshold =
- blockSet.micro ?
- padSize[AddrBlockMicro] :
- (blockSet.macro4KB ? padSize[AddrBlock4KB] : padSize[AddrBlock64KB]);
-
- threshold += threshold >> 1;
-
- if (blockSet.macro64KB && (padSize[AddrBlock64KB] > threshold))
- {
- blockSet.macro64KB = FALSE;
- }
-
- if (blockSet.macro4KB && (padSize[AddrBlock4KB] > threshold))
- {
- blockSet.macro4KB = FALSE;
- }
- }
-
- if (blockSet.value == 0)
- {
- // Bad things happen, client will not get any useful information from AddrLib.
- // Maybe we should fill in some output earlier instead of outputing nothing?
- ADDR_ASSERT_ALWAYS();
- returnCode = ADDR_INVALIDPARAMS;
- }
- else
- {
- pOut->validBlockSet = blockSet;
- pOut->canXor = (pIn->flags.prt == FALSE) &&
- (blockSet.macro4KB || blockSet.macro64KB || blockSet.var);
-
- if (blockSet.macro64KB || blockSet.macro4KB)
- {
- if (swType == ADDR_SW_Z)
- {
- pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_Z : ADDR_SW_4KB_Z;
- }
- else if (swType == ADDR_SW_S)
- {
- pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_S : ADDR_SW_4KB_S;
- }
- else if (swType == ADDR_SW_D)
- {
- pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_D : ADDR_SW_4KB_D;
- }
- else
- {
- ADDR_ASSERT(swType == ADDR_SW_R);
- pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_R : ADDR_SW_4KB_R;
- }
-
- if (pIn->noXor == FALSE)
- {
- if (tryPrtXor && blockSet.macro64KB)
- {
- // Client wants PRTXOR, give back _T swizzle mode if 64KB is available
- static const UINT_32 PrtGap = ADDR_SW_64KB_Z_T - ADDR_SW_64KB_Z;
- pOut->swizzleMode =
- static_cast<AddrSwizzleMode>(pOut->swizzleMode + PrtGap);
- }
- else if (pOut->canXor)
- {
- // Client wants XOR and this is allowed, return XOR version swizzle mode
- static const UINT_32 XorGap = ADDR_SW_4KB_Z_X - ADDR_SW_4KB_Z;
- pOut->swizzleMode =
- static_cast<AddrSwizzleMode>(pOut->swizzleMode + XorGap);
- }
- }
- }
- else if (blockSet.var)
- {
- // Designer consider this swizzle is usless for most cases
- ADDR_UNHANDLED_CASE();
- }
- else if (blockSet.micro)
- {
- if (swType == ADDR_SW_S)
- {
- pOut->swizzleMode = ADDR_SW_256B_S;
- }
- else if (swType == ADDR_SW_D)
- {
- pOut->swizzleMode = ADDR_SW_256B_D;
- }
- else
- {
- ADDR_ASSERT(swType == ADDR_SW_R);
- pOut->swizzleMode = ADDR_SW_256B_R;
- }
- }
- else
- {
- ADDR_ASSERT(blockSet.linear);
- // Fall into this branch doesn't mean linear is suitable, only no other choices!
- pOut->swizzleMode = ADDR_SW_LINEAR;
- }
-
-#if DEBUG
- // Post sanity check, at least AddrLib should accept the output generated by its own
- if (pOut->swizzleMode != ADDR_SW_LINEAR)
- {
- ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
- localIn.flags = pIn->flags;
- localIn.swizzleMode = pOut->swizzleMode;
- localIn.resourceType = pOut->resourceType;
- localIn.format = pIn->format;
- localIn.bpp = bpp;
- localIn.width = width;
- localIn.height = height;
- localIn.numSlices = slice;
- localIn.numMipLevels = numMipLevels;
- localIn.numSamples = numSamples;
- localIn.numFrags = numFrags;
-
- ADDR_E_RETURNCODE coherentCheck = ComputeSurfaceInfoSanityCheck(&localIn);
- ADDR_ASSERT(coherentCheck == ADDR_OK);
-
- // TODO : check all valid block type available in validBlockSet?
- }
-#endif
- }
- }
+ returnCode = HwlGetPreferredSurfaceSetting(pIn, pOut);
}
return returnCode;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeBlock256Equation
*
* @brief
* @return
* If equation computed successfully
*
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlock256Equation(
AddrResourceType rsrcType,
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeThinEquation
*
* @brief
* @return
* If equation computed successfully
*
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeThinEquation(
AddrResourceType rsrcType,
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Lib::ComputeThickEquation
*
* @brief
* @return
* If equation computed successfully
*
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeThickEquation(
AddrResourceType rsrcType,
return ret;
}
+/**
+************************************************************************************************************************
+* Lib::ComputeQbStereoInfo
+*
+* @brief
+* Get quad buffer stereo information
+* @return
+* N/A
+************************************************************************************************************************
+*/
+VOID Lib::ComputeQbStereoInfo(
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in,out] updated pOut+pStereoInfo
+ ) const
+{
+ ADDR_ASSERT(pOut->bpp >= 8);
+ ADDR_ASSERT((pOut->surfSize % pOut->baseAlign) == 0);
+
+ // Save original height
+ pOut->pStereoInfo->eyeHeight = pOut->height;
+
+ // Right offset
+ pOut->pStereoInfo->rightOffset = static_cast<UINT_32>(pOut->surfSize);
+
+ // Double height
+ pOut->height <<= 1;
+
+ ADDR_ASSERT(pOut->height <= MaxSurfaceHeight);
+
+ pOut->pixelHeight <<= 1;
+
+ // Double size
+ pOut->surfSize <<= 1;
+}
+
+
} // V2
} // Addr
*/
/**
-****************************************************************************************************
+************************************************************************************************************************
* @file addrlib2.h
* @brief Contains the Addr::V2::Lib class definition.
-****************************************************************************************************
+************************************************************************************************************************
*/
#ifndef __ADDR2_LIB2_H__
{
/**
-****************************************************************************************************
+************************************************************************************************************************
* @brief Flags for SwizzleModeTable
-****************************************************************************************************
+************************************************************************************************************************
*/
struct SwizzleModeFlags
{
UINT_32 isXor : 1; // XOR after swizzle if set
UINT_32 isT : 1; // T mode
+
+ UINT_32 isRtOpt : 1; // mode opt for render target
};
struct Dim2d
};
/**
-****************************************************************************************************
+************************************************************************************************************************
* @brief This class contains asic independent address lib functionalities
-****************************************************************************************************
+************************************************************************************************************************
*/
class Lib : public Addr::Lib
{
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn,
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) const;
+ ADDR_E_RETURNCODE ComputeDccAddrFromCoord(
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) const;
+
// Misc
ADDR_E_RETURNCODE ComputePipeBankXor(
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
- ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut);
+ ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut);
+
+ ADDR_E_RETURNCODE ComputeSlicePipeBankXor(
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut);
+
+ ADDR_E_RETURNCODE ComputeSubResourceOffsetForSwizzlePattern(
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut);
ADDR_E_RETURNCODE Addr2GetPreferredSurfaceSetting(
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
Lib(); // Constructor is protected
Lib(const Client* pClient);
- static const SwizzleModeFlags SwizzleModeTable[ADDR_SW_MAX_TYPE];
-
- static const Dim2d Block256b[];
- static const Dim3d Block1kb[];
+ static const UINT_32 MaxNumOfBpp = 5;
- static const Dim2d CompressBlock2d[];
- static const Dim3d CompressBlock3dS[];
- static const Dim3d CompressBlock3dZ[];
+ static const Dim2d Block256_2d[MaxNumOfBpp];
+ static const Dim3d Block1K_3d[MaxNumOfBpp];
- static const UINT_32 MaxMacroBits;
- static const UINT_32 MipTailOffset[];
+ static const UINT_32 PrtAlignment = 64 * 1024;
+ static const UINT_32 MaxMacroBits = 20;
// Checking block size
- static BOOL_32 IsBlock256b(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsBlock256b(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].is256b;
+ return m_swizzleModeTable[swizzleMode].is256b;
}
- static BOOL_32 IsBlock4kb(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsBlock4kb(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].is4kb;
+ return m_swizzleModeTable[swizzleMode].is4kb;
}
- static BOOL_32 IsBlock64kb(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsBlock64kb(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].is64kb;
+ return m_swizzleModeTable[swizzleMode].is64kb;
}
- static BOOL_32 IsBlockVariable(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsBlockVariable(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isVar;
+ return m_swizzleModeTable[swizzleMode].isVar;
}
// Checking swizzle mode
- static BOOL_32 IsLinear(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsLinear(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isLinear;
+ return m_swizzleModeTable[swizzleMode].isLinear;
}
- static BOOL_32 IsZOrderSwizzle(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsRtOptSwizzle(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isZ;
+ return m_swizzleModeTable[swizzleMode].isRtOpt;
}
- static BOOL_32 IsStandardSwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
+ BOOL_32 IsZOrderSwizzle(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isStd ||
- (IsTex3d(resourceType) && SwizzleModeTable[swizzleMode].isDisp);
+ return m_swizzleModeTable[swizzleMode].isZ;
}
- static BOOL_32 IsDisplaySwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
+ BOOL_32 IsStandardSwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode) const
{
- return IsTex2d(resourceType) && SwizzleModeTable[swizzleMode].isDisp;
+ return HwlIsStandardSwizzle(resourceType, swizzleMode);
}
- static BOOL_32 IsRotateSwizzle(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsDisplaySwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isRot;
+ return HwlIsDisplaySwizzle(resourceType, swizzleMode);
}
- static BOOL_32 IsXor(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsRotateSwizzle(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isXor;
+ return m_swizzleModeTable[swizzleMode].isRot;
}
- static BOOL_32 IsPrt(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsXor(AddrSwizzleMode swizzleMode) const
{
- return SwizzleModeTable[swizzleMode].isT;
+ return m_swizzleModeTable[swizzleMode].isXor;
}
- static BOOL_32 IsNonPrtXor(AddrSwizzleMode swizzleMode)
+ BOOL_32 IsPrt(AddrSwizzleMode swizzleMode) const
+ {
+ return m_swizzleModeTable[swizzleMode].isT;
+ }
+
+ BOOL_32 IsNonPrtXor(AddrSwizzleMode swizzleMode) const
{
return (IsXor(swizzleMode) && (IsPrt(swizzleMode) == FALSE));
}
return (resourceType == ADDR_RSRC_TEX_3D);
}
- static BOOL_32 IsThick(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
+ BOOL_32 IsThick(AddrResourceType resourceType, AddrSwizzleMode swizzleMode) const
{
- return (IsTex3d(resourceType) &&
- (SwizzleModeTable[swizzleMode].isZ || SwizzleModeTable[swizzleMode].isStd));
+ return HwlIsThick(resourceType, swizzleMode);
}
- static BOOL_32 IsThin(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
+ BOOL_32 IsThin(AddrResourceType resourceType, AddrSwizzleMode swizzleMode) const
{
- return (IsTex2d(resourceType) ||
- (IsTex3d(resourceType) && SwizzleModeTable[swizzleMode].isDisp));
+ return HwlIsThin(resourceType, swizzleMode);
}
UINT_32 GetBlockSizeLog2(AddrSwizzleMode swizzleMode) const
{
UINT_32 blockSizeLog2 = 0;
- if (IsBlock256b(swizzleMode))
+ if (IsBlock256b(swizzleMode) || IsLinear(swizzleMode))
{
blockSizeLog2 = 8;
}
static UINT_32 GetFmaskBpp(UINT_32 sample, UINT_32 frag)
{
sample = (sample == 0) ? 1 : sample;
- frag = (frag == 0) ? sample : frag;
+ frag = (frag == 0) ? sample : frag;
UINT_32 fmaskBpp = QLog2(frag);
return fmaskBpp;
}
+ virtual BOOL_32 HwlIsStandardSwizzle(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return FALSE;
+ }
+
+ virtual BOOL_32 HwlIsDisplaySwizzle(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return FALSE;
+ }
+
+ virtual BOOL_32 HwlIsThin(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return FALSE;
+ }
+
+ virtual BOOL_32 HwlIsThick(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return FALSE;
+ }
+
virtual ADDR_E_RETURNCODE HwlComputeHtileInfo(
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) const
return ADDR_NOTSUPPORTED;
}
+ virtual ADDR_E_RETURNCODE HwlComputeDccAddrFromCoord(
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
virtual ADDR_E_RETURNCODE HwlComputeCmaskAddrFromCoord(
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) const
return 0;
}
- UINT_32 ComputeSurfaceBaseAlign(AddrSwizzleMode swizzleMode) const
+ virtual ADDR_E_RETURNCODE HwlComputePipeBankXor(
+ const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
+ virtual ADDR_E_RETURNCODE HwlComputeSlicePipeBankXor(
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
+
+ virtual ADDR_E_RETURNCODE HwlComputeSubResourceOffsetForSwizzlePattern(
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
+ virtual ADDR_E_RETURNCODE HwlGetPreferredSurfaceSetting(
+ const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
+ ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfoSanityCheck(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTSUPPORTED;
+ }
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfoTiled(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const
+ {
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTIMPLEMENTED;
+ }
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordTiled(
+ const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const
{
- return HwlComputeSurfaceBaseAlign(swizzleMode);
+ ADDR_NOT_IMPLEMENTED();
+ return ADDR_NOTIMPLEMENTED;
}
ADDR_E_RETURNCODE ComputeBlock256Equation(
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const;
// Misc
- ADDR_E_RETURNCODE ComputeBlockDimensionForSurf(
- Dim3d* pDim,
- UINT_32 bpp,
- UINT_32 numSamples,
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode) const;
-
ADDR_E_RETURNCODE ComputeBlockDimensionForSurf(
UINT_32* pWidth,
UINT_32* pHeight,
return static_cast<UINT_64>(pPadDim->w) * pPadDim->h * pPadDim->d;
}
- UINT_32 GetMipChainInfo(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 bpp,
- UINT_32 mip0Width,
- UINT_32 mip0Height,
- UINT_32 mip0Depth,
- UINT_32 blockWidth,
- UINT_32 blockHeight,
- UINT_32 blockDepth,
- UINT_32 numMipLevel,
- ADDR2_MIP_INFO* pMipInfo) const;
-
- VOID GetMetaMiptailInfo(
- ADDR2_META_MIP_INFO* pInfo,
- Dim3d mipCoord,
- UINT_32 numMipInTail,
- Dim3d* pMetaBlkDim
- ) const;
-
static ADDR_E_RETURNCODE ExtractPipeBankXor(
UINT_32 pipeBankXor,
UINT_32 bankBits,
return (Max((numSlices >> mipId), 1u) > slice);
}
- static AddrMajorMode GetMajorMode(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 mip0WidthInBlk,
- UINT_32 mip0HeightInBlk,
- UINT_32 mip0DepthInBlk)
- {
- BOOL_32 yMajor = (mip0WidthInBlk < mip0HeightInBlk);
- BOOL_32 xMajor = (yMajor == FALSE);
-
- if (IsThick(resourceType, swizzleMode))
- {
- yMajor = yMajor && (mip0HeightInBlk >= mip0DepthInBlk);
- xMajor = xMajor && (mip0WidthInBlk >= mip0DepthInBlk);
- }
-
- AddrMajorMode majorMode;
- if (xMajor)
- {
- majorMode = ADDR_MAJOR_X;
- }
- else if (yMajor)
- {
- majorMode = ADDR_MAJOR_Y;
- }
- else
- {
- majorMode = ADDR_MAJOR_Z;
- }
-
- return majorMode;
- }
-
- static Dim3d GetDccCompressBlk(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 bpp)
- {
- UINT_32 index = Log2(bpp >> 3);
- Dim3d compressBlkDim;
- if (IsThin(resourceType, swizzleMode))
- {
- compressBlkDim.w = CompressBlock2d[index].w;
- compressBlkDim.h = CompressBlock2d[index].h;
- compressBlkDim.d = 1;
- }
- else if (IsStandardSwizzle(resourceType, swizzleMode))
- {
- compressBlkDim = CompressBlock3dS[index];
- }
- else
- {
- compressBlkDim = CompressBlock3dZ[index];
- }
-
- return compressBlkDim;
- }
-
- Dim3d GetMipStartPos(
- AddrResourceType resourceType,
- AddrSwizzleMode swizzleMode,
- UINT_32 width,
- UINT_32 height,
- UINT_32 depth,
- UINT_32 blockWidth,
- UINT_32 blockHeight,
- UINT_32 blockDepth,
- UINT_32 mipId,
- UINT_32* pMipTailOffset) const;
-
Dim3d GetMipTailDim(
AddrResourceType resourceType,
AddrSwizzleMode swizzleMode,
UINT_32 blockHeight,
UINT_32 blockDepth) const;
- static BOOL_32 IsInMipTail(
+ BOOL_32 IsInMipTail(
AddrResourceType resourceType,
AddrSwizzleMode swizzleMode,
Dim3d mipTailDim,
UINT_32 width,
UINT_32 height,
- UINT_32 depth)
+ UINT_32 depth) const
{
BOOL_32 inTail = ((width <= mipTailDim.w) &&
(height <= mipTailDim.h) &&
UINT_32 GetPipeXorBits(UINT_32 macroBlockBits) const;
UINT_32 GetBankXorBits(UINT_32 macroBlockBits) const;
- virtual BOOL_32 HwlIsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
- {
- ADDR_NOT_IMPLEMENTED();
- return FALSE;
- }
-
- BOOL_32 IsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
- {
- return HwlIsValidDisplaySwizzleMode(pIn);
- }
-
- virtual BOOL_32 HwlIsDce12() const
- {
- ADDR_NOT_IMPLEMENTED();
- return FALSE;
- }
-
- BOOL_32 IsDce12() const { return HwlIsDce12(); }
-
ADDR_E_RETURNCODE ApplyCustomizedPitchHeight(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
UINT_32 elementBytes,
- UINT_32 widthAlignInElement,
+ UINT_32 pitchAlignInElement,
UINT_32* pPitch,
UINT_32* pHeight) const;
+ VOID ComputeQbStereoInfo(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
+
UINT_32 m_se; ///< Number of shader engine
UINT_32 m_rbPerSe; ///< Number of render backend per shader engine
UINT_32 m_maxCompFrag; ///< Number of max compressed fragment
UINT_32 m_blockVarSizeLog2; ///< Log2 of block var size
+ SwizzleModeFlags m_swizzleModeTable[ADDR_SW_MAX_TYPE]; ///< Swizzle mode table
+
private:
// Disallow the copy constructor
Lib(const Lib& a);
*/
/**
-****************************************************************************************************
+************************************************************************************************************************
* @file gfx9addrlib.cpp
* @brief Contgfx9ns the implementation for the Gfx9Lib class.
-****************************************************************************************************
+************************************************************************************************************************
*/
#include "gfx9addrlib.h"
{
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9HwlInit
*
* @brief
*
* @return
* Returns an Gfx9Lib object pointer.
-****************************************************************************************************
+************************************************************************************************************************
*/
Addr::Lib* Gfx9HwlInit(const Client* pClient)
{
namespace V2
{
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Static Const Member
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const SwizzleModeFlags Gfx9Lib::SwizzleModeTable[ADDR_SW_MAX_TYPE] =
+{//Linear 256B 4KB 64KB Var Z Std Disp Rot XOR T RtOpt
+ {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // ADDR_SW_LINEAR
+ {0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_256B_S
+ {0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_256B_D
+ {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_256B_R
+
+ {0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_4KB_Z
+ {0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_4KB_S
+ {0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_4KB_D
+ {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_4KB_R
+
+ {0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_64KB_Z
+ {0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_64KB_S
+ {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_64KB_D
+ {0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_64KB_R
+
+ {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_VAR_Z
+ {0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_VAR_S
+ {0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_VAR_D
+ {0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_VAR_R
+
+ {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0}, // ADDR_SW_64KB_Z_T
+ {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0}, // ADDR_SW_64KB_S_T
+ {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0}, // ADDR_SW_64KB_D_T
+ {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0}, // ADDR_SW_64KB_R_T
+
+ {0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_4KB_Z_x
+ {0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_4KB_S_x
+ {0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_4KB_D_x
+ {0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_4KB_R_x
+
+ {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_64KB_Z_X
+ {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_64KB_S_X
+ {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_64KB_D_X
+ {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_64KB_R_X
+
+ {0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_VAR_Z_X
+ {0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_VAR_S_X
+ {0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_VAR_D_X
+ {0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_VAR_R_X
+ {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // ADDR_SW_LINEAR_GENERAL
+};
+
+const UINT_32 Gfx9Lib::MipTailOffset256B[] = {2048, 1024, 512, 256, 128, 64, 32, 16,
+ 8, 6, 5, 4, 3, 2, 1, 0};
+
+const Dim3d Gfx9Lib::Block256_3dS[] = {{16, 4, 4}, {8, 4, 4}, {4, 4, 4}, {2, 4, 4}, {1, 4, 4}};
+
+const Dim3d Gfx9Lib::Block256_3dZ[] = {{8, 4, 8}, {4, 4, 8}, {4, 4, 4}, {4, 2, 4}, {2, 2, 4}};
+
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::Gfx9Lib
*
* @brief
* Constructor
*
-****************************************************************************************************
+************************************************************************************************************************
*/
Gfx9Lib::Gfx9Lib(const Client* pClient)
:
{
m_class = AI_ADDRLIB;
memset(&m_settings, 0, sizeof(m_settings));
+ memcpy(m_swizzleModeTable, SwizzleModeTable, sizeof(SwizzleModeTable));
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::~Gfx9Lib
*
* @brief
* Destructor
-****************************************************************************************************
+************************************************************************************************************************
*/
Gfx9Lib::~Gfx9Lib()
{
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeHtileInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileInfo(
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
pOut->metaBlkHeight = metaBlkDim.h;
pOut->metaBlkNumPerSlice = numMetaBlkX * numMetaBlkY;
+ pOut->baseAlign = Max(numCompressBlkPerMetaBlk * 4, sizeAlign);
+
+ if (m_settings.metaBaseAlignFix)
+ {
+ pOut->baseAlign = Max(pOut->baseAlign, GetBlockSize(pIn->swizzleMode));
+ }
+
if ((IsXor(pIn->swizzleMode) == FALSE) && (numPipeTotal > 2))
{
UINT_32 additionalAlign = numPipeTotal * numCompressBlkPerMetaBlk * 2;
}
pOut->htileBytes = PowTwoAlign(pOut->sliceSize * numMetaBlkZ, sizeAlign);
- pOut->baseAlign = Max(numCompressBlkPerMetaBlk * 4, sizeAlign);
-
- if (m_settings.metaBaseAlignFix)
- {
- pOut->baseAlign = Max(pOut->baseAlign, HwlComputeSurfaceBaseAlign(pIn->swizzleMode));
- }
return ADDR_OK;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeCmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeCmaskInfo(
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
if (m_settings.metaBaseAlignFix)
{
- pOut->baseAlign = Max(pOut->baseAlign, HwlComputeSurfaceBaseAlign(pIn->swizzleMode));
+ pOut->baseAlign = Max(pOut->baseAlign, GetBlockSize(pIn->swizzleMode));
}
pOut->metaBlkWidth = metaBlkDim.w;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::GetMetaMipInfo
*
* @brief
*
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::GetMetaMipInfo(
UINT_32 numMipLevels, ///< [in] number of mip levels
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeDccInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeDccInfo(
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
UINT_32 minMetaBlkSize = dataThick ? 65536 : 4096;
- UINT_32 numFrags = (pIn->numFrags == 0) ? 1 : pIn->numFrags;
- UINT_32 numSlices = (pIn->numSlices == 0) ? 1 : pIn->numSlices;
+ UINT_32 numFrags = Max(pIn->numFrags, 1u);
+ UINT_32 numSlices = Max(pIn->numSlices, 1u);
minMetaBlkSize /= numFrags;
if (m_settings.metaBaseAlignFix)
{
- pOut->dccRamBaseAlign = Max(pOut->dccRamBaseAlign, HwlComputeSurfaceBaseAlign(pIn->swizzleMode));
+ pOut->dccRamBaseAlign = Max(pOut->dccRamBaseAlign, GetBlockSize(pIn->swizzleMode));
}
pOut->pitch = numMetaBlkX * metaBlkDim.w;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeCmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeCmaskAddrFromCoord(
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
- ADDR2_COMPUTE_CMASK_INFO_INPUT input;
- ADDR2_COMPUTE_CMASK_INFO_OUTPUT output;
-
- memset(&input, 0, sizeof(ADDR2_COMPUTE_CMASK_INFO_INPUT));
- input.size = sizeof(ADDR2_COMPUTE_CMASK_INFO_INPUT);
- input.cMaskFlags = pIn->cMaskFlags;
- input.colorFlags = pIn->colorFlags;
- input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
+ ADDR2_COMPUTE_CMASK_INFO_INPUT input = {0};
+ input.size = sizeof(input);
+ input.cMaskFlags = pIn->cMaskFlags;
+ input.colorFlags = pIn->colorFlags;
+ input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
- input.numSlices = Max(pIn->numSlices, 1u);
- input.swizzleMode = pIn->swizzleMode;
- input.resourceType = pIn->resourceType;
+ input.numSlices = Max(pIn->numSlices, 1u);
+ input.swizzleMode = pIn->swizzleMode;
+ input.resourceType = pIn->resourceType;
- memset(&output, 0, sizeof(ADDR2_COMPUTE_CMASK_INFO_OUTPUT));
- output.size = sizeof(ADDR2_COMPUTE_CMASK_INFO_OUTPUT);
+ ADDR2_COMPUTE_CMASK_INFO_OUTPUT output = {0};
+ output.size = sizeof(output);
ADDR_E_RETURNCODE returnCode = ComputeCmaskInfo(&input, &output);
if (returnCode == ADDR_OK)
{
- UINT_32 fmaskBpp = GetFmaskBpp(pIn->numSamples, pIn->numFrags);
-
+ UINT_32 fmaskBpp = GetFmaskBpp(pIn->numSamples, pIn->numFrags);
UINT_32 fmaskElementBytesLog2 = Log2(fmaskBpp >> 3);
-
- UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
- UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
+ UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
+ UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
CoordEq metaEq;
UINT_32 yb = pIn->y / output.metaBlkHeight;
UINT_32 zb = pIn->slice;
- UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
+ UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
- UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
+ UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
UINT_64 address = metaEq.solve(pIn->x, pIn->y, pIn->slice, 0, blockIndex);
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeHtileAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileAddrFromCoord(
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
else
{
- ADDR2_COMPUTE_HTILE_INFO_INPUT input;
- ADDR2_COMPUTE_HTILE_INFO_OUTPUT output;
-
- memset(&input, 0, sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT));
- input.size = sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT);
- input.hTileFlags = pIn->hTileFlags;
- input.depthFlags = pIn->depthflags;
- input.swizzleMode = pIn->swizzleMode;
- input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
+ ADDR2_COMPUTE_HTILE_INFO_INPUT input = {0};
+ input.size = sizeof(input);
+ input.hTileFlags = pIn->hTileFlags;
+ input.depthFlags = pIn->depthflags;
+ input.swizzleMode = pIn->swizzleMode;
+ input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
- input.numSlices = Max(pIn->numSlices, 1u);
- input.numMipLevels = Max(pIn->numMipLevels, 1u);
+ input.numSlices = Max(pIn->numSlices, 1u);
+ input.numMipLevels = Max(pIn->numMipLevels, 1u);
- memset(&output, 0, sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT));
- output.size = sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT);
+ ADDR2_COMPUTE_HTILE_INFO_OUTPUT output = {0};
+ output.size = sizeof(output);
returnCode = ComputeHtileInfo(&input, &output);
if (returnCode == ADDR_OK)
{
- UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
-
- UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
+ UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
+ UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
-
- UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
+ UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
CoordEq metaEq;
UINT_32 yb = pIn->y / output.metaBlkHeight;
UINT_32 zb = pIn->slice;
- UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
+ UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
- UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
+ UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
UINT_64 address = metaEq.solve(pIn->x, pIn->y, pIn->slice, 0, blockIndex);
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeHtileCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileCoordFromAddr(
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
else
{
- ADDR2_COMPUTE_HTILE_INFO_INPUT input;
- ADDR2_COMPUTE_HTILE_INFO_OUTPUT output;
-
- memset(&input, 0, sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT));
- input.size = sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT);
- input.hTileFlags = pIn->hTileFlags;
- input.swizzleMode = pIn->swizzleMode;
- input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
+ ADDR2_COMPUTE_HTILE_INFO_INPUT input = {0};
+ input.size = sizeof(input);
+ input.hTileFlags = pIn->hTileFlags;
+ input.swizzleMode = pIn->swizzleMode;
+ input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
- input.numSlices = Max(pIn->numSlices, 1u);
- input.numMipLevels = Max(pIn->numMipLevels, 1u);
+ input.numSlices = Max(pIn->numSlices, 1u);
+ input.numMipLevels = Max(pIn->numMipLevels, 1u);
- memset(&output, 0, sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT));
- output.size = sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT);
+ ADDR2_COMPUTE_HTILE_INFO_OUTPUT output = {0};
+ output.size = sizeof(output);
returnCode = ComputeHtileInfo(&input, &output);
if (returnCode == ADDR_OK)
{
- UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
-
- UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
+ UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
+ UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
-
- UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
+ UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
CoordEq metaEq;
UINT_64 nibbleAddress = (pIn->addr ^ (pipeXor << m_pipeInterleaveLog2)) << 1;
- UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
+ UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
UINT_32 x, y, z, s, m;
-
metaEq.solveAddr(nibbleAddress, sliceSizeInBlock, x, y, z, s, m);
pOut->slice = m / sliceSizeInBlock;
- pOut->y = ((m % sliceSizeInBlock) / pitchInBlock) * output.metaBlkHeight + y;
- pOut->x = (m % pitchInBlock) * output.metaBlkWidth + x;
+ pOut->y = ((m % sliceSizeInBlock) / pitchInBlock) * output.metaBlkHeight + y;
+ pOut->x = (m % pitchInBlock) * output.metaBlkWidth + x;
+ }
+ }
+
+ return returnCode;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeDccAddrFromCoord
+*
+* @brief
+* Interface function stub of AddrComputeDccAddrFromCoord
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeDccAddrFromCoord(
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) const
+{
+ ADDR_E_RETURNCODE returnCode = ADDR_OK;
+
+ if ((pIn->numMipLevels > 1) || (pIn->mipId > 1) || pIn->dccKeyFlags.linear)
+ {
+ returnCode = ADDR_NOTIMPLEMENTED;
+ }
+ else
+ {
+ ADDR2_COMPUTE_DCCINFO_INPUT input = {0};
+ input.size = sizeof(input);
+ input.dccKeyFlags = pIn->dccKeyFlags;
+ input.colorFlags = pIn->colorFlags;
+ input.swizzleMode = pIn->swizzleMode;
+ input.resourceType = pIn->resourceType;
+ input.bpp = pIn->bpp;
+ input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
+ input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
+ input.numSlices = Max(pIn->numSlices, 1u);
+ input.numFrags = Max(pIn->numFrags, 1u);
+ input.numMipLevels = Max(pIn->numMipLevels, 1u);
+
+ ADDR2_COMPUTE_DCCINFO_OUTPUT output = {0};
+ output.size = sizeof(output);
+
+ returnCode = ComputeDccInfo(&input, &output);
+
+ if (returnCode == ADDR_OK)
+ {
+ UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
+ UINT_32 numSamplesLog2 = Log2(pIn->numFrags);
+ UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
+ UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
+ UINT_32 metaBlkDepthLog2 = Log2(output.metaBlkDepth);
+ UINT_32 compBlkWidthLog2 = Log2(output.compressBlkWidth);
+ UINT_32 compBlkHeightLog2 = Log2(output.compressBlkHeight);
+ UINT_32 compBlkDepthLog2 = Log2(output.compressBlkDepth);
+
+ CoordEq metaEq;
+
+ GetMetaEquation(&metaEq, pIn->mipId, elementBytesLog2, numSamplesLog2, pIn->dccKeyFlags,
+ Gfx9DataColor, pIn->swizzleMode, pIn->resourceType,
+ metaBlkWidthLog2, metaBlkHeightLog2, metaBlkDepthLog2,
+ compBlkWidthLog2, compBlkHeightLog2, compBlkDepthLog2);
+
+ UINT_32 xb = pIn->x / output.metaBlkWidth;
+ UINT_32 yb = pIn->y / output.metaBlkHeight;
+ UINT_32 zb = pIn->slice / output.metaBlkDepth;
+
+ UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
+ UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
+ UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
+
+ UINT_64 address = metaEq.solve(pIn->x, pIn->y, pIn->slice, pIn->sample, blockIndex);
+
+ pOut->addr = address >> 1;
+
+ UINT_32 numPipeBits = GetPipeLog2ForMetaAddressing(pIn->dccKeyFlags.pipeAligned,
+ pIn->swizzleMode);
+
+ UINT_64 pipeXor = static_cast<UINT_64>(pIn->pipeXor & ((1 << numPipeBits) - 1));
+
+ pOut->addr ^= (pipeXor << m_pipeInterleaveLog2);
}
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlInitGlobalParams
*
* @brief
* @return
* TRUE if all settings are valid
*
-****************************************************************************************************
+************************************************************************************************************************
*/
BOOL_32 Gfx9Lib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
m_pipesLog2 = 5;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
m_pipeInterleaveLog2 = 11;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
m_banksLog2 = 4;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
m_seLog2 = 3;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
m_rbPerSeLog2 = 2;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
m_maxCompFragLog2 = 3;
break;
default:
+ ADDR_ASSERT_ALWAYS();
break;
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlConvertChipFamily
*
* @brief
* Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
* @return
* ChipFamily
-****************************************************************************************************
+************************************************************************************************************************
*/
ChipFamily Gfx9Lib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
m_settings.isDce12 = 1;
}
- // Bug ID DEGGIGX90-1056
m_settings.metaBaseAlignFix = 1;
+
+ m_settings.depthPipeXorDisable = 1;
break;
default:
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::InitRbEquation
*
* @brief
* Init RB equation
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::GetRbEquation(
CoordEq* pRbEq, ///< [out] rb equation
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::GetDataEquation
*
* @brief
* Get data equation for fmask and Z
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::GetDataEquation(
CoordEq* pDataEq, ///< [out] data surface equation
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::GetPipeEquation
*
* @brief
* Get pipe equation
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::GetPipeEquation(
CoordEq* pPipeEq, ///< [out] pipe equation
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::GetMetaEquation
*
* @brief
* Get meta equation for cmask/htile/DCC
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::GetMetaEquation(
CoordEq* pMetaEq, ///< [out] meta equation
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::IsEquationSupported
*
* @brief
*
* @return
* TRUE if supported
-****************************************************************************************************
+************************************************************************************************************************
*/
BOOL_32 Gfx9Lib::IsEquationSupported(
AddrResourceType rsrcType,
{
BOOL_32 supported = (elementBytesLog2 < MaxElementBytesLog2) &&
(IsLinear(swMode) == FALSE) &&
- ((IsTex2d(rsrcType) == TRUE) ||
+ (((IsTex2d(rsrcType) == TRUE) &&
+ ((elementBytesLog2 < 4) ||
+ ((IsRotateSwizzle(swMode) == FALSE) &&
+ (IsZOrderSwizzle(swMode) == FALSE)))) ||
((IsTex3d(rsrcType) == TRUE) &&
(IsRotateSwizzle(swMode) == FALSE) &&
(IsBlock256b(swMode) == FALSE)));
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::InitEquationTable
*
* @brief
*
* @return
* N/A
-****************************************************************************************************
+************************************************************************************************************************
*/
VOID Gfx9Lib::InitEquationTable()
{
m_numEquations++;
}
+ else
+ {
+ ADDR_ASSERT_ALWAYS();
+ }
}
// Fill the index into the lookup table, if the combination is not supported
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlGetEquationIndex
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
UINT_32 Gfx9Lib::HwlGetEquationIndex(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut
) const
{
- AddrResourceType rsrcType = pIn->resourceType;
- AddrSwizzleMode swMode = pIn->swizzleMode;
- UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
- UINT_32 numMipLevels = pIn->numMipLevels;
- ADDR2_MIP_INFO* pMipInfo = pOut->pMipInfo;
-
- UINT_32 index = ADDR_INVALID_EQUATION_INDEX;
-
- BOOL_32 eqSupported = (pOut->firstMipInTail == FALSE) &&
- IsEquationSupported(rsrcType, swMode, elementBytesLog2);
+ AddrResourceType rsrcType = pIn->resourceType;
+ AddrSwizzleMode swMode = pIn->swizzleMode;
+ UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
+ UINT_32 index = ADDR_INVALID_EQUATION_INDEX;
- UINT_32 rsrcTypeIdx = static_cast<UINT_32>(rsrcType) - 1;
- UINT_32 swModeIdx = static_cast<UINT_32>(swMode);
-
- if (eqSupported)
+ if (IsEquationSupported(rsrcType, swMode, elementBytesLog2))
{
- index = m_equationLookupTable[rsrcTypeIdx][swModeIdx][elementBytesLog2];
-
- if (pMipInfo != NULL)
- {
- pMipInfo->equationIndex = index;
- pMipInfo->mipOffsetXBytes = 0;
- pMipInfo->mipOffsetYPixel = 0;
- pMipInfo->mipOffsetZPixel = 0;
- pMipInfo->postSwizzleOffset = 0;
-
- /*static const UINT_32 Prt_Xor_Gap =
- static_cast<UINT_32>(ADDR_SW_64KB_Z_T) - static_cast<UINT_32>(ADDR_SW_64KB_Z);*/
-
- for (UINT_32 i = 1; i < numMipLevels; i++)
- {
- Dim3d mipStartPos = {0};
- UINT_32 mipTailOffset = 0;
-
- mipStartPos = GetMipStartPos(rsrcType,
- swMode,
- pOut->pitch,
- pOut->height,
- pOut->numSlices,
- pOut->blockWidth,
- pOut->blockHeight,
- pOut->blockSlices,
- i,
- &mipTailOffset);
+ UINT_32 rsrcTypeIdx = static_cast<UINT_32>(rsrcType) - 1;
+ UINT_32 swModeIdx = static_cast<UINT_32>(swMode);
- UINT_32 mipSwModeIdx = swModeIdx;
-
- pMipInfo[i].equationIndex =
- m_equationLookupTable[rsrcTypeIdx][mipSwModeIdx][elementBytesLog2];
- pMipInfo[i].mipOffsetXBytes = mipStartPos.w * pOut->blockWidth * (pOut->bpp >> 3);
- pMipInfo[i].mipOffsetYPixel = mipStartPos.h * pOut->blockHeight;
- pMipInfo[i].mipOffsetZPixel = mipStartPos.d * pOut->blockSlices;
- pMipInfo[i].postSwizzleOffset = mipTailOffset;
- }
- }
+ index = m_equationLookupTable[rsrcTypeIdx][swModeIdx][elementBytesLog2];
}
- else if (pMipInfo != NULL)
+
+ if (pOut->pMipInfo != NULL)
{
- for (UINT_32 i = 0; i < numMipLevels; i++)
+ for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
{
- pMipInfo[i].equationIndex = ADDR_INVALID_EQUATION_INDEX;
- pMipInfo[i].mipOffsetXBytes = 0;
- pMipInfo[i].mipOffsetYPixel = 0;
- pMipInfo[i].mipOffsetZPixel = 0;
- pMipInfo[i].postSwizzleOffset = 0;
+ pOut->pMipInfo[i].equationIndex = index;
}
}
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeBlock256Equation
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeBlock256Equation(
AddrResourceType rsrcType,
- AddrSwizzleMode swMode,
- UINT_32 elementBytesLog2,
- ADDR_EQUATION* pEquation) const
+ AddrSwizzleMode swMode,
+ UINT_32 elementBytesLog2,
+ ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret = ADDR_OK;
ADDR_CHANNEL_SETTING* pixelBit = &pEquation->addr[elementBytesLog2];
- const UINT_32 MaxBitsUsed = 4;
- ADDR_CHANNEL_SETTING x[MaxBitsUsed] = {};
- ADDR_CHANNEL_SETTING y[MaxBitsUsed] = {};
+ const UINT_32 maxBitsUsed = 4;
+ ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
+ ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
- for (i = 0; i < MaxBitsUsed; i++)
+ for (i = 0; i < maxBitsUsed; i++)
{
InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
InitChannel(1, 1, i, &y[i]);
// Post validation
if (ret == ADDR_OK)
{
- Dim2d microBlockDim = Block256b[elementBytesLog2];
+ Dim2d microBlockDim = Block256_2d[elementBytesLog2];
ADDR_ASSERT((2u << GetMaxValidChannelIndex(pEquation->addr, 8, 0)) ==
(microBlockDim.w * (1 << elementBytesLog2)));
ADDR_ASSERT((2u << GetMaxValidChannelIndex(pEquation->addr, 8, 1)) == microBlockDim.h);
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeThinEquation
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeThinEquation(
AddrResourceType rsrcType,
- AddrSwizzleMode swMode,
- UINT_32 elementBytesLog2,
- ADDR_EQUATION* pEquation) const
+ AddrSwizzleMode swMode,
+ UINT_32 elementBytesLog2,
+ ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret = ADDR_OK;
2 * GetBankXorBits(blockSizeLog2));
}
- const UINT_32 MaxBitsUsed = 14;
- ADDR_ASSERT((2 * MaxBitsUsed) >= maxXorBits);
- ADDR_CHANNEL_SETTING x[MaxBitsUsed] = {};
- ADDR_CHANNEL_SETTING y[MaxBitsUsed] = {};
+ const UINT_32 maxBitsUsed = 14;
+ ADDR_ASSERT((2 * maxBitsUsed) >= maxXorBits);
+ ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
+ ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
- const UINT_32 ExtraXorBits = 16;
- ADDR_ASSERT(ExtraXorBits >= maxXorBits - blockSizeLog2);
- ADDR_CHANNEL_SETTING xorExtra[ExtraXorBits] = {};
+ const UINT_32 extraXorBits = 16;
+ ADDR_ASSERT(extraXorBits >= maxXorBits - blockSizeLog2);
+ ADDR_CHANNEL_SETTING xorExtra[extraXorBits] = {};
- for (UINT_32 i = 0; i < MaxBitsUsed; i++)
+ for (UINT_32 i = 0; i < maxBitsUsed; i++)
{
InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
InitChannel(1, 1, i, &y[i]);
else
{
ret = HwlComputeBlock256Equation(rsrcType, swMode, elementBytesLog2, pEquation);
+
if (ret == ADDR_OK)
{
- Dim2d microBlockDim = Block256b[elementBytesLog2];
+ Dim2d microBlockDim = Block256_2d[elementBytesLog2];
xIdx = Log2(microBlockDim.w);
yIdx = Log2(microBlockDim.h);
lowBits = 8;
{
xorExtra[i - blockSizeLog2] = ((i & 1) == 0) ? y[yIdx++] : x[xIdx++];
}
- }
- if ((ret == ADDR_OK) && IsXor(swMode))
- {
- // Fill XOR bits
- UINT_32 pipeStart = m_pipeInterleaveLog2;
- UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
- for (UINT_32 i = 0; i < pipeXorBits; i++)
+ if (IsXor(swMode))
{
- UINT_32 xor1BitPos = pipeStart + 2 * pipeXorBits - 1 - i;
- ADDR_CHANNEL_SETTING* pXor1Src =
- (xor1BitPos < blockSizeLog2) ?
- &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+ // Fill XOR bits
+ UINT_32 pipeStart = m_pipeInterleaveLog2;
+ UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
- InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
- }
+ UINT_32 bankStart = pipeStart + pipeXorBits;
+ UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
- UINT_32 bankStart = pipeStart + pipeXorBits;
- UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
- for (UINT_32 i = 0; i < bankXorBits; i++)
- {
- UINT_32 xor1BitPos = bankStart + 2 * bankXorBits - 1 - i;
- ADDR_CHANNEL_SETTING* pXor1Src =
- (xor1BitPos < blockSizeLog2) ?
- &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+ for (UINT_32 i = 0; i < pipeXorBits; i++)
+ {
+ UINT_32 xor1BitPos = pipeStart + 2 * pipeXorBits - 1 - i;
+ ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+
+ InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
+ }
+
+ for (UINT_32 i = 0; i < bankXorBits; i++)
+ {
+ UINT_32 xor1BitPos = bankStart + 2 * bankXorBits - 1 - i;
+ ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+
+ InitChannel(&pEquation->xor1[bankStart + i], pXor1Src);
+ }
+
+ if (IsPrt(swMode) == FALSE)
+ {
+ for (UINT_32 i = 0; i < pipeXorBits; i++)
+ {
+ InitChannel(1, 2, pipeXorBits - i - 1, &pEquation->xor2[pipeStart + i]);
+ }
- InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
+ for (UINT_32 i = 0; i < bankXorBits; i++)
+ {
+ InitChannel(1, 2, bankXorBits - i - 1 + pipeXorBits, &pEquation->xor2[bankStart + i]);
+ }
+ }
}
pEquation->numBits = blockSizeLog2;
}
- if ((ret == ADDR_OK) && IsTex3d(rsrcType))
- {
- pEquation->stackedDepthSlices = TRUE;
- }
-
return ret;
}
/**
-****************************************************************************************************
+************************************************************************************************************************
* Gfx9Lib::HwlComputeThickEquation
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-****************************************************************************************************
+************************************************************************************************************************
*/
ADDR_E_RETURNCODE Gfx9Lib::HwlComputeThickEquation(
AddrResourceType rsrcType,
- AddrSwizzleMode swMode,
- UINT_32 elementBytesLog2,
- ADDR_EQUATION* pEquation) const
+ AddrSwizzleMode swMode,
+ UINT_32 elementBytesLog2,
+ ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret = ADDR_OK;
ADDR_CHANNEL_SETTING* pixelBit = &pEquation->addr[elementBytesLog2];
- const UINT_32 MaxBitsUsed = 12;
- ADDR_ASSERT((3 * MaxBitsUsed) >= maxXorBits);
- ADDR_CHANNEL_SETTING x[MaxBitsUsed] = {};
- ADDR_CHANNEL_SETTING y[MaxBitsUsed] = {};
- ADDR_CHANNEL_SETTING z[MaxBitsUsed] = {};
+ const UINT_32 maxBitsUsed = 12;
+ ADDR_ASSERT((3 * maxBitsUsed) >= maxXorBits);
+ ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
+ ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
+ ADDR_CHANNEL_SETTING z[maxBitsUsed] = {};
- const UINT_32 ExtraXorBits = 24;
- ADDR_ASSERT(ExtraXorBits >= maxXorBits - blockSizeLog2);
- ADDR_CHANNEL_SETTING xorExtra[ExtraXorBits] = {};
+ const UINT_32 extraXorBits = 24;
+ ADDR_ASSERT(extraXorBits >= maxXorBits - blockSizeLog2);
+ ADDR_CHANNEL_SETTING xorExtra[extraXorBits] = {};
- for (UINT_32 i = 0; i < MaxBitsUsed; i++)
+ for (UINT_32 i = 0; i < maxBitsUsed; i++)
{
InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
InitChannel(1, 1, i, &y[i]);
if (ret == ADDR_OK)
{
- Dim3d microBlockDim = Block1kb[elementBytesLog2];
+ Dim3d microBlockDim = Block1K_3d[elementBytesLog2];
UINT_32 xIdx = Log2(microBlockDim.w);
UINT_32 yIdx = Log2(microBlockDim.h);
UINT_32 zIdx = Log2(microBlockDim.d);
pixelBit = pEquation->addr;
- static const UINT_32 lowBits = 10;
+ const UINT_32 lowBits = 10;
ADDR_ASSERT(pEquation->addr[lowBits - 1].valid == 1);
ADDR_ASSERT(pEquation->addr[lowBits].valid == 0);
for (UINT_32 i = lowBits; i < blockSizeLog2; i++)
{
- if (((i - lowBits) % 3) == 0)
+ if ((i % 3) == 0)
{
pixelBit[i] = x[xIdx++];
}
- else if (((i - lowBits) % 3) == 1)
+ else if ((i % 3) == 1)
{
pixelBit[i] = z[zIdx++];
}
for (UINT_32 i = blockSizeLog2; i < maxXorBits; i++)
{
- if (((i - lowBits) % 3) == 0)
+ if ((i % 3) == 0)
{
xorExtra[i - blockSizeLog2] = x[xIdx++];
}
- else if (((i - lowBits) % 3) == 1)
+ else if ((i % 3) == 1)
{
xorExtra[i - blockSizeLog2] = z[zIdx++];
}
xorExtra[i - blockSizeLog2] = y[yIdx++];
}
}
- }
- if ((ret == ADDR_OK) && IsXor(swMode))
- {
- // Fill XOR bits
- UINT_32 pipeStart = m_pipeInterleaveLog2;
- UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
- for (UINT_32 i = 0; i < pipeXorBits; i++)
+ if (IsXor(swMode))
{
- UINT_32 xor1BitPos = pipeStart + (3 * pipeXorBits) - 1 - (2 * i);
- ADDR_CHANNEL_SETTING* pXor1Src =
- (xor1BitPos < blockSizeLog2) ?
- &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+ // Fill XOR bits
+ UINT_32 pipeStart = m_pipeInterleaveLog2;
+ UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
+ for (UINT_32 i = 0; i < pipeXorBits; i++)
+ {
+ UINT_32 xor1BitPos = pipeStart + (3 * pipeXorBits) - 1 - (2 * i);
+ ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
- InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
+ InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
- UINT_32 xor2BitPos = pipeStart + (3 * pipeXorBits) - 2 - (2 * i);
- ADDR_CHANNEL_SETTING* pXor2Src =
- (xor2BitPos < blockSizeLog2) ?
- &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
+ UINT_32 xor2BitPos = pipeStart + (3 * pipeXorBits) - 2 - (2 * i);
+ ADDR_CHANNEL_SETTING* pXor2Src = (xor2BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
- InitChannel(&pEquation->xor2[pipeStart + i], pXor2Src);
- }
+ InitChannel(&pEquation->xor2[pipeStart + i], pXor2Src);
+ }
- UINT_32 bankStart = pipeStart + pipeXorBits;
- UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
- for (UINT_32 i = 0; i < bankXorBits; i++)
- {
- UINT_32 xor1BitPos = bankStart + (3 * bankXorBits) - 1 - (2 * i);
- ADDR_CHANNEL_SETTING* pXor1Src =
- (xor1BitPos < blockSizeLog2) ?
- &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
+ UINT_32 bankStart = pipeStart + pipeXorBits;
+ UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
+ for (UINT_32 i = 0; i < bankXorBits; i++)
+ {
+ UINT_32 xor1BitPos = bankStart + (3 * bankXorBits) - 1 - (2 * i);
+ ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
- InitChannel(&pEquation->xor1[bankStart + i], pXor1Src);
+ InitChannel(&pEquation->xor1[bankStart + i], pXor1Src);
- UINT_32 xor2BitPos = bankStart + (3 * bankXorBits) - 2 - (2 * i);
- ADDR_CHANNEL_SETTING* pXor2Src =
- (xor2BitPos < blockSizeLog2) ?
- &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
+ UINT_32 xor2BitPos = bankStart + (3 * bankXorBits) - 2 - (2 * i);
+ ADDR_CHANNEL_SETTING* pXor2Src = (xor2BitPos < blockSizeLog2) ?
+ &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
- InitChannel(&pEquation->xor2[bankStart + i], pXor2Src);
+ InitChannel(&pEquation->xor2[bankStart + i], pXor2Src);
+ }
}
pEquation->numBits = blockSizeLog2;
}
/**
-****************************************************************************************************
-* Gfx9Lib::HwlIsValidDisplaySwizzleMode
+************************************************************************************************************************
+* Gfx9Lib::IsValidDisplaySwizzleMode
*
* @brief
* Check if a swizzle mode is supported by display engine
*
* @return
* TRUE is swizzle mode is supported by display engine
-****************************************************************************************************
+************************************************************************************************************************
*/
-BOOL_32 Gfx9Lib::HwlIsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
+BOOL_32 Gfx9Lib::IsValidDisplaySwizzleMode(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
{
BOOL_32 support = FALSE;
return support;
}
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputePipeBankXor
+*
+* @brief
+* Generate a PipeBankXor value to be ORed into bits above pipeInterleaveBits of address
+*
+* @return
+* PipeBankXor value
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputePipeBankXor(
+ const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const
+{
+ UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
+ UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
+ UINT_32 bankBits = GetBankXorBits(macroBlockBits);
+
+ UINT_32 pipeXor = 0;
+ UINT_32 bankXor = 0;
+
+ const UINT_32 bankMask = (1 << bankBits) - 1;
+ const UINT_32 index = pIn->surfIndex & bankMask;
+
+ const UINT_32 bpp = pIn->flags.fmask ?
+ GetFmaskBpp(pIn->numSamples, pIn->numFrags) : GetElemLib()->GetBitsPerPixel(pIn->format);
+ if (bankBits == 4)
+ {
+ static const UINT_32 BankXorSmallBpp[] = {0, 7, 4, 3, 8, 15, 12, 11, 1, 6, 5, 2, 9, 14, 13, 10};
+ static const UINT_32 BankXorLargeBpp[] = {0, 7, 8, 15, 4, 3, 12, 11, 1, 6, 9, 14, 5, 2, 13, 10};
+
+ bankXor = (bpp <= 32) ? BankXorSmallBpp[index] : BankXorLargeBpp[index];
+ }
+ else if (bankBits > 0)
+ {
+ UINT_32 bankIncrease = (1 << (bankBits - 1)) - 1;
+ bankIncrease = (bankIncrease == 0) ? 1 : bankIncrease;
+ bankXor = (index * bankIncrease) & bankMask;
+ }
+
+ pOut->pipeBankXor = (bankXor << pipeBits) | pipeXor;
+
+ return ADDR_OK;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeSlicePipeBankXor
+*
+* @brief
+* Generate slice PipeBankXor value based on base PipeBankXor value and slice id
+*
+* @return
+* PipeBankXor value
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSlicePipeBankXor(
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const
+{
+ UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
+ UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
+ UINT_32 bankBits = GetBankXorBits(macroBlockBits);
+
+ UINT_32 pipeXor = ReverseBitVector(pIn->slice, pipeBits);
+ UINT_32 bankXor = ReverseBitVector(pIn->slice >> pipeBits, bankBits);
+
+ pOut->pipeBankXor = pIn->basePipeBankXor ^ (pipeXor | (bankXor << pipeBits));
+
+ return ADDR_OK;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeSubResourceOffsetForSwizzlePattern
+*
+* @brief
+* Compute sub resource offset to support swizzle pattern
+*
+* @return
+* Offset
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSubResourceOffsetForSwizzlePattern(
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const
+{
+ ADDR_ASSERT(IsThin(pIn->resourceType, pIn->swizzleMode));
+
+ UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
+ UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
+ UINT_32 bankBits = GetBankXorBits(macroBlockBits);
+ UINT_32 pipeXor = ReverseBitVector(pIn->slice, pipeBits);
+ UINT_32 bankXor = ReverseBitVector(pIn->slice >> pipeBits, bankBits);
+ UINT_32 pipeBankXor = ((pipeXor | (bankXor << pipeBits)) ^ (pIn->pipeBankXor)) << m_pipeInterleaveLog2;
+
+ pOut->offset = pIn->slice * pIn->sliceSize +
+ pIn->macroBlockOffset +
+ (pIn->mipTailOffset ^ pipeBankXor) -
+ static_cast<UINT_64>(pipeBankXor);
+ return ADDR_OK;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeSurfaceInfoSanityCheck
+*
+* @brief
+* Compute surface info sanity check
+*
+* @return
+* Offset
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceInfoSanityCheck(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
+{
+ BOOL_32 invalid = FALSE;
+
+ if ((pIn->bpp > 128) || (pIn->width == 0) || (pIn->numFrags > 8) || (pIn->numSamples > 16))
+ {
+ invalid = TRUE;
+ }
+ else if ((pIn->swizzleMode >= ADDR_SW_MAX_TYPE) ||
+ (pIn->resourceType >= ADDR_RSRC_MAX_TYPE))
+ {
+ invalid = TRUE;
+ }
+
+ BOOL_32 mipmap = (pIn->numMipLevels > 1);
+ BOOL_32 msaa = (pIn->numFrags > 1);
+
+ ADDR2_SURFACE_FLAGS flags = pIn->flags;
+ BOOL_32 zbuffer = (flags.depth || flags.stencil);
+ BOOL_32 color = flags.color;
+ BOOL_32 display = flags.display || flags.rotated;
+
+ AddrResourceType rsrcType = pIn->resourceType;
+ BOOL_32 tex3d = IsTex3d(rsrcType);
+ AddrSwizzleMode swizzle = pIn->swizzleMode;
+ BOOL_32 linear = IsLinear(swizzle);
+ BOOL_32 blk256B = IsBlock256b(swizzle);
+ BOOL_32 blkVar = IsBlockVariable(swizzle);
+ BOOL_32 isNonPrtXor = IsNonPrtXor(swizzle);
+ BOOL_32 prt = flags.prt;
+ BOOL_32 stereo = flags.qbStereo;
+
+ if (invalid == FALSE)
+ {
+ if ((pIn->numFrags > 1) &&
+ (GetBlockSize(swizzle) < (m_pipeInterleaveBytes * pIn->numFrags)))
+ {
+ // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
+ invalid = TRUE;
+ }
+ }
+
+ if (invalid == FALSE)
+ {
+ switch (rsrcType)
+ {
+ case ADDR_RSRC_TEX_1D:
+ invalid = msaa || zbuffer || display || (linear == FALSE) || stereo;
+ break;
+ case ADDR_RSRC_TEX_2D:
+ invalid = (msaa && mipmap) || (stereo && msaa) || (stereo && mipmap);
+ break;
+ case ADDR_RSRC_TEX_3D:
+ invalid = msaa || zbuffer || display || stereo;
+ break;
+ default:
+ invalid = TRUE;
+ break;
+ }
+ }
+
+ if (invalid == FALSE)
+ {
+ if (display)
+ {
+ invalid = (IsValidDisplaySwizzleMode(pIn) == FALSE);
+ }
+ }
+
+ if (invalid == FALSE)
+ {
+ if (linear)
+ {
+ invalid = ((ADDR_RSRC_TEX_1D != rsrcType) && prt) ||
+ zbuffer || msaa || (pIn->bpp == 0) || ((pIn->bpp % 8) != 0);
+ }
+ else
+ {
+ if (blk256B || blkVar || isNonPrtXor)
+ {
+ invalid = prt;
+ if (blk256B)
+ {
+ invalid = invalid || zbuffer || tex3d || mipmap || msaa;
+ }
+ }
+
+ if (invalid == FALSE)
+ {
+ if (IsZOrderSwizzle(swizzle))
+ {
+ invalid = color && msaa;
+ }
+ else if (IsStandardSwizzle(rsrcType, swizzle))
+ {
+ invalid = zbuffer;
+ }
+ else if (IsDisplaySwizzle(rsrcType, swizzle))
+ {
+ invalid = zbuffer;
+ }
+ else if (IsRotateSwizzle(swizzle))
+ {
+ invalid = zbuffer || (pIn->bpp > 64) || tex3d;
+ }
+ else
+ {
+ ADDR_ASSERT(!"invalid swizzle mode");
+ invalid = TRUE;
+ }
+ }
+ }
+ }
+
+ ADDR_ASSERT(invalid == FALSE);
+
+ return invalid ? ADDR_INVALIDPARAMS : ADDR_OK;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlGetPreferredSurfaceSetting
+*
+* @brief
+* Internal function to get suggested surface information for cliet to use
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlGetPreferredSurfaceSetting(
+ const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
+ ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
+{
+ // Macro define resource block type
+ enum AddrBlockType
+ {
+ AddrBlockMicro = 0, // Resource uses 256B block
+ AddrBlock4KB = 1, // Resource uses 4KB block
+ AddrBlock64KB = 2, // Resource uses 64KB block
+ AddrBlockVar = 3, // Resource uses var blcok
+ AddrBlockLinear = 4, // Resource uses linear swizzle mode
+
+ AddrBlockMaxTiledType = AddrBlock64KB + 1,
+ };
+
+ enum AddrBlockSet
+ {
+ AddrBlockSetMicro = 1 << AddrBlockMicro,
+ AddrBlockSetMacro4KB = 1 << AddrBlock4KB,
+ AddrBlockSetMacro64KB = 1 << AddrBlock64KB,
+ AddrBlockSetVar = 1 << AddrBlockVar,
+ AddrBlockSetLinear = 1 << AddrBlockLinear,
+
+ AddrBlockSetMacro = AddrBlockSetMacro4KB | AddrBlockSetMacro64KB,
+ };
+
+ ADDR_E_RETURNCODE returnCode = ADDR_OK;
+ ElemLib* pElemLib = GetElemLib();
+
+ // Set format to INVALID will skip this conversion
+ UINT_32 expandX = 1;
+ UINT_32 expandY = 1;
+ UINT_32 bpp = pIn->bpp;
+ UINT_32 width = pIn->width;
+ UINT_32 height = pIn->height;
+
+ if (pIn->format != ADDR_FMT_INVALID)
+ {
+ // Don't care for this case
+ ElemMode elemMode = ADDR_UNCOMPRESSED;
+
+ // Get compression/expansion factors and element mode which indicates compression/expansion
+ bpp = pElemLib->GetBitsPerPixel(pIn->format,
+ &elemMode,
+ &expandX,
+ &expandY);
+
+ UINT_32 basePitch = 0;
+ GetElemLib()->AdjustSurfaceInfo(elemMode,
+ expandX,
+ expandY,
+ &bpp,
+ &basePitch,
+ &width,
+ &height);
+ }
+
+ UINT_32 numSamples = Max(pIn->numSamples, 1u);
+ UINT_32 numFrags = (pIn->numFrags == 0) ? numSamples : pIn->numFrags;
+ UINT_32 slice = Max(pIn->numSlices, 1u);
+ UINT_32 numMipLevels = Max(pIn->numMipLevels, 1u);
+ UINT_32 minSizeAlign = NextPow2(pIn->minSizeAlign);
+
+ if (pIn->flags.fmask)
+ {
+ bpp = GetFmaskBpp(numSamples, numFrags);
+ numFrags = 1;
+ numSamples = 1;
+ pOut->resourceType = ADDR_RSRC_TEX_2D;
+ }
+ else
+ {
+ // The output may get changed for volume(3D) texture resource in future
+ pOut->resourceType = pIn->resourceType;
+ }
+
+ ADDR_ASSERT(bpp >= 8u);
+ UINT_64 minSizeAlignInElement = Max(minSizeAlign / (bpp >> 3), 1u);
+
+ if (IsTex1d(pOut->resourceType))
+ {
+ pOut->swizzleMode = ADDR_SW_LINEAR;
+ pOut->validBlockSet.value = AddrBlockSetLinear;
+ pOut->canXor = FALSE;
+ }
+ else
+ {
+ ADDR2_BLOCK_SET blockSet;
+ blockSet.value = 0;
+
+ AddrSwType swType = ADDR_SW_S;
+
+ // prt Xor and non-xor will have less height align requirement for stereo surface
+ BOOL_32 prtXor = (pIn->flags.prt || pIn->flags.qbStereo) && (pIn->noXor == FALSE);
+ BOOL_32 displayResource = FALSE;
+
+ pOut->canXor = (pIn->flags.prt == FALSE) && (pIn->noXor == FALSE);
+
+ // Filter out improper swType and blockSet by HW restriction
+ if (pIn->flags.fmask || pIn->flags.depth || pIn->flags.stencil)
+ {
+ ADDR_ASSERT(IsTex2d(pOut->resourceType));
+ blockSet.value = AddrBlockSetMacro;
+ swType = ADDR_SW_Z;
+
+ if (pIn->flags.depth && pIn->flags.texture)
+ {
+ if (((bpp == 16) && (numFrags >= 4)) ||
+ ((bpp == 32) && (numFrags >= 2)))
+ {
+ // When _X/_T swizzle mode was used for MSAA depth texture, TC will get zplane
+ // equation from wrong address within memory range a tile covered and use the
+ // garbage data for compressed Z reading which finally leads to corruption.
+ pOut->canXor = FALSE;
+ prtXor = FALSE;
+ }
+ }
+ }
+ else if (ElemLib::IsBlockCompressed(pIn->format))
+ {
+ // block compressed formats (BCx, ASTC, ETC2) must be either S or D modes. Not sure
+ // under what circumstances "_D" would be appropriate as these formats are not
+ // displayable.
+ blockSet.value = AddrBlockSetMacro;
+
+ // This isn't to be used as texture and caller doesn't allow macro tiled.
+ if ((pIn->flags.texture == FALSE) &&
+ (pIn->forbiddenBlock.macro4KB && pIn->forbiddenBlock.macro64KB))
+ {
+ blockSet.value |= AddrBlockSetLinear;
+ }
+ swType = ADDR_SW_D;
+ }
+ else if (ElemLib::IsMacroPixelPacked(pIn->format))
+ {
+ // macro pixel packed formats (BG_RG, GB_GR) does not support the Z modes. Its not
+ // clear under what circumstances the D or R modes would be appropriate since
+ // these formats are not displayable.
+ blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
+ swType = ADDR_SW_S;
+ }
+ else if (IsTex3d(pOut->resourceType))
+ {
+ blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
+
+ if (pIn->flags.prt)
+ {
+ // PRT cannot use SW_D which gives an unexpected block dimension
+ swType = ADDR_SW_Z;
+ }
+ else if ((numMipLevels > 1) && (slice >= width) && (slice >= height))
+ {
+ // When depth (Z) is the maximum dimension then must use one of the SW_*_S
+ // or SW_*_Z modes if mipmapping is desired on a 3D surface
+ swType = ADDR_SW_Z;
+ }
+ else if (pIn->flags.color)
+ {
+ swType = ADDR_SW_D;
+ }
+ else
+ {
+ swType = ADDR_SW_Z;
+ }
+ }
+ else
+ {
+ swType = ((pIn->flags.display == TRUE) ||
+ (pIn->flags.overlay == TRUE) ||
+ (pIn->bpp == 128)) ? ADDR_SW_D : ADDR_SW_S;
+
+ if (numMipLevels > 1)
+ {
+ ADDR_ASSERT(numFrags == 1);
+ blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
+ }
+ else if ((numFrags > 1) || (numSamples > 1))
+ {
+ ADDR_ASSERT(IsTex2d(pOut->resourceType));
+ blockSet.value = AddrBlockSetMacro;
+ }
+ else
+ {
+ ADDR_ASSERT(IsTex2d(pOut->resourceType));
+ blockSet.value = AddrBlockSetLinear | AddrBlockSetMicro | AddrBlockSetMacro;
+
+ displayResource = pIn->flags.rotated || pIn->flags.display;
+
+ if (displayResource)
+ {
+ swType = pIn->flags.rotated ? ADDR_SW_R : ADDR_SW_D;
+
+ if (pIn->bpp > 64)
+ {
+ blockSet.value = 0;
+ }
+ else if (m_settings.isDce12)
+ {
+ if (pIn->bpp != 32)
+ {
+ blockSet.micro = FALSE;
+ }
+
+ // DCE12 does not support display surface to be _T swizzle mode
+ prtXor = FALSE;
+ }
+ else
+ {
+ ADDR_NOT_IMPLEMENTED();
+ returnCode = ADDR_NOTSUPPORTED;
+ }
+ }
+ }
+ }
+
+ if ((numFrags > 1) &&
+ (GetBlockSize(ADDR_SW_4KB) < (m_pipeInterleaveBytes * numFrags)))
+ {
+ // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
+ blockSet.macro4KB = FALSE;
+ }
+
+ if (pIn->flags.prt)
+ {
+ blockSet.value &= AddrBlockSetMacro64KB;
+ }
+
+ // Apply customized forbidden setting
+ blockSet.value &= ~pIn->forbiddenBlock.value;
+
+ if (pIn->maxAlign > 0)
+ {
+ if (pIn->maxAlign < GetBlockSize(ADDR_SW_64KB))
+ {
+ blockSet.macro64KB = FALSE;
+ }
+
+ if (pIn->maxAlign < GetBlockSize(ADDR_SW_4KB))
+ {
+ blockSet.macro4KB = FALSE;
+ }
+
+ if (pIn->maxAlign < GetBlockSize(ADDR_SW_256B))
+ {
+ blockSet.micro = FALSE;
+ }
+ }
+
+ Dim3d blkAlign[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
+ Dim3d paddedDim[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
+ UINT_64 padSize[AddrBlockMaxTiledType] = {0};
+
+ if (blockSet.micro)
+ {
+ returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlockMicro].w,
+ &blkAlign[AddrBlockMicro].h,
+ &blkAlign[AddrBlockMicro].d,
+ bpp,
+ numFrags,
+ pOut->resourceType,
+ ADDR_SW_256B);
+
+ if (returnCode == ADDR_OK)
+ {
+ if (displayResource)
+ {
+ blkAlign[AddrBlockMicro].w = PowTwoAlign(blkAlign[AddrBlockMicro].w, 32);
+ }
+ else if ((blkAlign[AddrBlockMicro].w >= width) && (blkAlign[AddrBlockMicro].h >= height) &&
+ (minSizeAlign <= GetBlockSize(ADDR_SW_256B)))
+ {
+ // If one 256B block can contain the surface, don't bother bigger block type
+ blockSet.macro4KB = FALSE;
+ blockSet.macro64KB = FALSE;
+ blockSet.var = FALSE;
+ }
+
+ padSize[AddrBlockMicro] = ComputePadSize(&blkAlign[AddrBlockMicro], width, height,
+ slice, &paddedDim[AddrBlockMicro]);
+ }
+ }
+
+ if ((returnCode == ADDR_OK) && blockSet.macro4KB)
+ {
+ returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlock4KB].w,
+ &blkAlign[AddrBlock4KB].h,
+ &blkAlign[AddrBlock4KB].d,
+ bpp,
+ numFrags,
+ pOut->resourceType,
+ ADDR_SW_4KB);
+
+ if (returnCode == ADDR_OK)
+ {
+ if (displayResource)
+ {
+ blkAlign[AddrBlock4KB].w = PowTwoAlign(blkAlign[AddrBlock4KB].w, 32);
+ }
+
+ padSize[AddrBlock4KB] = ComputePadSize(&blkAlign[AddrBlock4KB], width, height,
+ slice, &paddedDim[AddrBlock4KB]);
+
+ ADDR_ASSERT(padSize[AddrBlock4KB] >= padSize[AddrBlockMicro]);
+ }
+ }
+
+ if ((returnCode == ADDR_OK) && blockSet.macro64KB)
+ {
+ returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlock64KB].w,
+ &blkAlign[AddrBlock64KB].h,
+ &blkAlign[AddrBlock64KB].d,
+ bpp,
+ numFrags,
+ pOut->resourceType,
+ ADDR_SW_64KB);
+
+ if (returnCode == ADDR_OK)
+ {
+ if (displayResource)
+ {
+ blkAlign[AddrBlock64KB].w = PowTwoAlign(blkAlign[AddrBlock64KB].w, 32);
+ }
+
+ padSize[AddrBlock64KB] = ComputePadSize(&blkAlign[AddrBlock64KB], width, height,
+ slice, &paddedDim[AddrBlock64KB]);
+
+ ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlock4KB]);
+ ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlockMicro]);
+ }
+ }
+
+ if (returnCode == ADDR_OK)
+ {
+ for (UINT_32 i = AddrBlockMicro; i < AddrBlockMaxTiledType; i++)
+ {
+ padSize[i] = PowTwoAlign(padSize[i], minSizeAlignInElement);
+ }
+
+ // Use minimum block type which meets all conditions above if flag minimizeAlign was set
+ if (pIn->flags.minimizeAlign)
+ {
+ // If padded size of 64KB block is larger than padded size of 256B block or 4KB
+ // block, filter out 64KB block from candidate list
+ if (blockSet.macro64KB &&
+ ((blockSet.micro && (padSize[AddrBlockMicro] < padSize[AddrBlock64KB])) ||
+ (blockSet.macro4KB && (padSize[AddrBlock4KB] < padSize[AddrBlock64KB]))))
+ {
+ blockSet.macro64KB = FALSE;
+ }
+
+ // If padded size of 4KB block is larger than padded size of 256B block,
+ // filter out 4KB block from candidate list
+ if (blockSet.macro4KB &&
+ blockSet.micro &&
+ (padSize[AddrBlockMicro] < padSize[AddrBlock4KB]))
+ {
+ blockSet.macro4KB = FALSE;
+ }
+ }
+ // Filter out 64KB/4KB block if a smaller block type has 2/3 or less memory footprint
+ else if (pIn->flags.opt4space)
+ {
+ UINT_64 threshold = blockSet.micro ? padSize[AddrBlockMicro] :
+ (blockSet.macro4KB ? padSize[AddrBlock4KB] : padSize[AddrBlock64KB]);
+
+ threshold += threshold >> 1;
+
+ if (blockSet.macro64KB && (padSize[AddrBlock64KB] > threshold))
+ {
+ blockSet.macro64KB = FALSE;
+ }
+
+ if (blockSet.macro4KB && (padSize[AddrBlock4KB] > threshold))
+ {
+ blockSet.macro4KB = FALSE;
+ }
+ }
+ else
+ {
+ if (blockSet.macro64KB &&
+ (padSize[AddrBlock64KB] >= static_cast<UINT_64>(width) * height * slice * 2) &&
+ ((blockSet.value & ~AddrBlockSetMacro64KB) != 0))
+ {
+ // If 64KB block waste more than half memory on padding, filter it out from
+ // candidate list when it is not the only choice left
+ blockSet.macro64KB = FALSE;
+ }
+ }
+
+ if (blockSet.value == 0)
+ {
+ // Bad things happen, client will not get any useful information from AddrLib.
+ // Maybe we should fill in some output earlier instead of outputing nothing?
+ ADDR_ASSERT_ALWAYS();
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+ else
+ {
+ pOut->validBlockSet = blockSet;
+ pOut->canXor = pOut->canXor &&
+ (blockSet.macro4KB || blockSet.macro64KB || blockSet.var);
+
+ if (blockSet.macro64KB || blockSet.macro4KB)
+ {
+ if (swType == ADDR_SW_Z)
+ {
+ pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_Z : ADDR_SW_4KB_Z;
+ }
+ else if (swType == ADDR_SW_S)
+ {
+ pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_S : ADDR_SW_4KB_S;
+ }
+ else if (swType == ADDR_SW_D)
+ {
+ pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_D : ADDR_SW_4KB_D;
+ }
+ else
+ {
+ ADDR_ASSERT(swType == ADDR_SW_R);
+ pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_R : ADDR_SW_4KB_R;
+ }
+
+ if (prtXor && blockSet.macro64KB)
+ {
+ // Client wants PRTXOR, give back _T swizzle mode if 64KB is available
+ const UINT_32 prtGap = ADDR_SW_64KB_Z_T - ADDR_SW_64KB_Z;
+ pOut->swizzleMode = static_cast<AddrSwizzleMode>(pOut->swizzleMode + prtGap);
+ }
+ else if (pOut->canXor)
+ {
+ // Client wants XOR and this is allowed, return XOR version swizzle mode
+ const UINT_32 xorGap = ADDR_SW_4KB_Z_X - ADDR_SW_4KB_Z;
+ pOut->swizzleMode = static_cast<AddrSwizzleMode>(pOut->swizzleMode + xorGap);
+ }
+ }
+ else if (blockSet.micro)
+ {
+ if (swType == ADDR_SW_S)
+ {
+ pOut->swizzleMode = ADDR_SW_256B_S;
+ }
+ else if (swType == ADDR_SW_D)
+ {
+ pOut->swizzleMode = ADDR_SW_256B_D;
+ }
+ else
+ {
+ ADDR_ASSERT(swType == ADDR_SW_R);
+ pOut->swizzleMode = ADDR_SW_256B_R;
+ }
+ }
+ else if (blockSet.linear)
+ {
+ // Fall into this branch doesn't mean linear is suitable, only no other choices!
+ pOut->swizzleMode = ADDR_SW_LINEAR;
+ }
+ else
+ {
+ ADDR_ASSERT(blockSet.var);
+
+ // Designer consider VAR swizzle mode is usless for most cases
+ ADDR_UNHANDLED_CASE();
+
+ returnCode = ADDR_NOTSUPPORTED;
+ }
+
+#if DEBUG
+ // Post sanity check, at least AddrLib should accept the output generated by its own
+ if (pOut->swizzleMode != ADDR_SW_LINEAR)
+ {
+ ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
+ localIn.flags = pIn->flags;
+ localIn.swizzleMode = pOut->swizzleMode;
+ localIn.resourceType = pOut->resourceType;
+ localIn.format = pIn->format;
+ localIn.bpp = bpp;
+ localIn.width = width;
+ localIn.height = height;
+ localIn.numSlices = slice;
+ localIn.numMipLevels = numMipLevels;
+ localIn.numSamples = numSamples;
+ localIn.numFrags = numFrags;
+
+ HwlComputeSurfaceInfoSanityCheck(&localIn);
+
+ // TODO : check all valid block type available in validBlockSet?
+ }
+#endif
+ }
+ }
+ }
+
+ return returnCode;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::ComputeStereoInfo
+*
+* @brief
+* Compute height alignment and right eye pipeBankXor for stereo surface
+*
+* @return
+* Error code
+*
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::ComputeStereoInfo(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
+ UINT_32* pHeightAlign
+ ) const
+{
+ ADDR_E_RETURNCODE returnCode = ADDR_OK;
+
+ UINT_32 eqIndex = HwlGetEquationIndex(pIn, pOut);
+
+ if (eqIndex < m_numEquations)
+ {
+ if (IsXor(pIn->swizzleMode))
+ {
+ const UINT_32 blkSizeLog2 = GetBlockSizeLog2(pIn->swizzleMode);
+ const UINT_32 numPipeBits = GetPipeXorBits(blkSizeLog2);
+ const UINT_32 numBankBits = GetBankXorBits(blkSizeLog2);
+ const UINT_32 bppLog2 = Log2(pIn->bpp >> 3);
+ const UINT_32 maxYCoordBlock256 = Log2(Block256_2d[bppLog2].h) - 1;
+ const ADDR_EQUATION *pEqToCheck = &m_equationTable[eqIndex];
+
+ ADDR_ASSERT(maxYCoordBlock256 ==
+ GetMaxValidChannelIndex(&pEqToCheck->addr[0], GetBlockSizeLog2(ADDR_SW_256B), 1));
+
+ const UINT_32 maxYCoordInBaseEquation =
+ (blkSizeLog2 - GetBlockSizeLog2(ADDR_SW_256B)) / 2 + maxYCoordBlock256;
+
+ ADDR_ASSERT(maxYCoordInBaseEquation ==
+ GetMaxValidChannelIndex(&pEqToCheck->addr[0], blkSizeLog2, 1));
+
+ const UINT_32 maxYCoordInPipeXor = (numPipeBits == 0) ? 0 : maxYCoordBlock256 + numPipeBits;
+
+ ADDR_ASSERT(maxYCoordInPipeXor ==
+ GetMaxValidChannelIndex(&pEqToCheck->xor1[m_pipeInterleaveLog2], numPipeBits, 1));
+
+ const UINT_32 maxYCoordInBankXor = (numBankBits == 0) ?
+ 0 : maxYCoordBlock256 + (numPipeBits + 1) / 2 + numBankBits;
+
+ ADDR_ASSERT(maxYCoordInBankXor ==
+ GetMaxValidChannelIndex(&pEqToCheck->xor1[m_pipeInterleaveLog2 + numPipeBits], numBankBits, 1));
+
+ const UINT_32 maxYCoordInPipeBankXor = Max(maxYCoordInPipeXor, maxYCoordInBankXor);
+
+ if (maxYCoordInPipeBankXor > maxYCoordInBaseEquation)
+ {
+ *pHeightAlign = 1u << maxYCoordInPipeBankXor;
+
+ if (pOut->pStereoInfo != NULL)
+ {
+ pOut->pStereoInfo->rightSwizzle = 0;
+
+ if ((PowTwoAlign(pIn->height, *pHeightAlign) % (*pHeightAlign * 2)) != 0)
+ {
+ if (maxYCoordInPipeXor == maxYCoordInPipeBankXor)
+ {
+ pOut->pStereoInfo->rightSwizzle |= (1u << 1);
+ }
+
+ if (maxYCoordInBankXor == maxYCoordInPipeBankXor)
+ {
+ pOut->pStereoInfo->rightSwizzle |=
+ 1u << ((numPipeBits % 2) ? numPipeBits : numPipeBits + 1);
+ }
+
+ ADDR_ASSERT(pOut->pStereoInfo->rightSwizzle ==
+ GetCoordActiveMask(&pEqToCheck->xor1[m_pipeInterleaveLog2],
+ numPipeBits + numBankBits, 1, maxYCoordInPipeBankXor));
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ ADDR_ASSERT_ALWAYS();
+ returnCode = ADDR_ERROR;
+ }
+
+ return returnCode;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeSurfaceInfoTiled
+*
+* @brief
+* Internal function to calculate alignment for tiled surface
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceInfoTiled(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
+ ) const
+{
+ ADDR_E_RETURNCODE returnCode = ComputeBlockDimensionForSurf(&pOut->blockWidth,
+ &pOut->blockHeight,
+ &pOut->blockSlices,
+ pIn->bpp,
+ pIn->numFrags,
+ pIn->resourceType,
+ pIn->swizzleMode);
+
+ if (returnCode == ADDR_OK)
+ {
+ UINT_32 pitchAlignInElement = pOut->blockWidth;
+
+ if ((IsTex2d(pIn->resourceType) == TRUE) &&
+ (pIn->flags.display || pIn->flags.rotated) &&
+ (pIn->numMipLevels <= 1) &&
+ (pIn->numSamples <= 1) &&
+ (pIn->numFrags <= 1))
+ {
+ // Display engine needs pitch align to be at least 32 pixels.
+ pitchAlignInElement = PowTwoAlign(pitchAlignInElement, 32);
+ }
+
+ pOut->pitch = PowTwoAlign(pIn->width, pitchAlignInElement);
+
+ if ((pIn->numMipLevels <= 1) && (pIn->pitchInElement > 0))
+ {
+ if ((pIn->pitchInElement % pitchAlignInElement) != 0)
+ {
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+ else if (pIn->pitchInElement < pOut->pitch)
+ {
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+ else
+ {
+ pOut->pitch = pIn->pitchInElement;
+ }
+ }
+
+ UINT_32 heightAlign = 0;
+
+ if (pIn->flags.qbStereo)
+ {
+ returnCode = ComputeStereoInfo(pIn, pOut, &heightAlign);
+ }
+
+ if (returnCode == ADDR_OK)
+ {
+ pOut->height = PowTwoAlign(pIn->height, pOut->blockHeight);
+
+ if (heightAlign > 1)
+ {
+ pOut->height = PowTwoAlign(pOut->height, heightAlign);
+ }
+
+ pOut->numSlices = PowTwoAlign(pIn->numSlices, pOut->blockSlices);
+
+ pOut->epitchIsHeight = FALSE;
+ pOut->mipChainInTail = FALSE;
+
+ pOut->mipChainPitch = pOut->pitch;
+ pOut->mipChainHeight = pOut->height;
+ pOut->mipChainSlice = pOut->numSlices;
+
+ if (pIn->numMipLevels > 1)
+ {
+ UINT_32 numMipLevel;
+ ADDR2_MIP_INFO *pMipInfo;
+ ADDR2_MIP_INFO mipInfo[4];
+
+ if (pOut->pMipInfo != NULL)
+ {
+ pMipInfo = pOut->pMipInfo;
+ numMipLevel = pIn->numMipLevels;
+ }
+ else
+ {
+ pMipInfo = mipInfo;
+ numMipLevel = Min(pIn->numMipLevels, 4u);
+ }
+
+ UINT_32 endingMip = GetMipChainInfo(pIn->resourceType,
+ pIn->swizzleMode,
+ pIn->bpp,
+ pIn->width,
+ pIn->height,
+ pIn->numSlices,
+ pOut->blockWidth,
+ pOut->blockHeight,
+ pOut->blockSlices,
+ numMipLevel,
+ pMipInfo);
+
+ if (endingMip == 0)
+ {
+ pOut->epitchIsHeight = TRUE;
+ pOut->pitch = pMipInfo[0].pitch;
+ pOut->height = pMipInfo[0].height;
+ pOut->numSlices = pMipInfo[0].depth;
+ pOut->mipChainInTail = TRUE;
+ }
+ else
+ {
+ UINT_32 mip0WidthInBlk = pOut->pitch / pOut->blockWidth;
+ UINT_32 mip0HeightInBlk = pOut->height / pOut->blockHeight;
+
+ AddrMajorMode majorMode = GetMajorMode(pIn->resourceType,
+ pIn->swizzleMode,
+ mip0WidthInBlk,
+ mip0HeightInBlk,
+ pOut->numSlices / pOut->blockSlices);
+ if (majorMode == ADDR_MAJOR_Y)
+ {
+ UINT_32 mip1WidthInBlk = RoundHalf(mip0WidthInBlk);
+
+ if ((mip1WidthInBlk == 1) && (endingMip > 2))
+ {
+ mip1WidthInBlk++;
+ }
+
+ pOut->mipChainPitch += (mip1WidthInBlk * pOut->blockWidth);
+
+ pOut->epitchIsHeight = FALSE;
+ }
+ else
+ {
+ UINT_32 mip1HeightInBlk = RoundHalf(mip0HeightInBlk);
+
+ if ((mip1HeightInBlk == 1) && (endingMip > 2))
+ {
+ mip1HeightInBlk++;
+ }
+
+ pOut->mipChainHeight += (mip1HeightInBlk * pOut->blockHeight);
+
+ pOut->epitchIsHeight = TRUE;
+ }
+ }
+
+ if (pOut->pMipInfo != NULL)
+ {
+ UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
+
+ for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
+ {
+ Dim3d mipStartPos = {0};
+ UINT_32 mipTailOffsetInBytes = 0;
+
+ mipStartPos = GetMipStartPos(pIn->resourceType,
+ pIn->swizzleMode,
+ pOut->pitch,
+ pOut->height,
+ pOut->numSlices,
+ pOut->blockWidth,
+ pOut->blockHeight,
+ pOut->blockSlices,
+ i,
+ elementBytesLog2,
+ &mipTailOffsetInBytes);
+
+ UINT_32 pitchInBlock =
+ pOut->mipChainPitch / pOut->blockWidth;
+ UINT_32 sliceInBlock =
+ (pOut->mipChainHeight / pOut->blockHeight) * pitchInBlock;
+ UINT_64 blockIndex =
+ mipStartPos.d * sliceInBlock + mipStartPos.h * pitchInBlock + mipStartPos.w;
+ UINT_64 macroBlockOffset =
+ blockIndex << GetBlockSizeLog2(pIn->swizzleMode);
+
+ pMipInfo[i].macroBlockOffset = macroBlockOffset;
+ pMipInfo[i].mipTailOffset = mipTailOffsetInBytes;
+ }
+ }
+ }
+ else if (pOut->pMipInfo != NULL)
+ {
+ pOut->pMipInfo[0].pitch = pOut->pitch;
+ pOut->pMipInfo[0].height = pOut->height;
+ pOut->pMipInfo[0].depth = IsTex3d(pIn->resourceType)? pOut->numSlices : 1;
+ pOut->pMipInfo[0].offset = 0;
+ }
+
+ pOut->sliceSize = static_cast<UINT_64>(pOut->mipChainPitch) * pOut->mipChainHeight *
+ (pIn->bpp >> 3) * pIn->numFrags;
+ pOut->surfSize = pOut->sliceSize * pOut->mipChainSlice;
+ pOut->baseAlign = HwlComputeSurfaceBaseAlign(pIn->swizzleMode);
+
+ if (pIn->flags.prt)
+ {
+ pOut->baseAlign = Max(pOut->baseAlign, PrtAlignment);
+ }
+ }
+ }
+
+ return returnCode;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::GetMipChainInfo
+*
+* @brief
+* Internal function to get out information about mip chain
+*
+* @return
+* Smaller value between Id of first mip fitted in mip tail and max Id of mip being created
+************************************************************************************************************************
+*/
+UINT_32 Gfx9Lib::GetMipChainInfo(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 bpp,
+ UINT_32 mip0Width,
+ UINT_32 mip0Height,
+ UINT_32 mip0Depth,
+ UINT_32 blockWidth,
+ UINT_32 blockHeight,
+ UINT_32 blockDepth,
+ UINT_32 numMipLevel,
+ ADDR2_MIP_INFO* pMipInfo) const
+{
+ const Dim3d tailMaxDim =
+ GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
+
+ UINT_32 mipPitch = mip0Width;
+ UINT_32 mipHeight = mip0Height;
+ UINT_32 mipDepth = IsTex3d(resourceType) ? mip0Depth : 1;
+ UINT_32 offset = 0;
+ UINT_32 endingMip = numMipLevel - 1;
+ BOOL_32 inTail = FALSE;
+ BOOL_32 finalDim = FALSE;
+
+ BOOL_32 is3dThick = IsThick(resourceType, swizzleMode);
+ BOOL_32 is3dThin = IsTex3d(resourceType) && (is3dThick == FALSE);
+
+ for (UINT_32 mipId = 0; mipId < numMipLevel; mipId++)
+ {
+ if (inTail)
+ {
+ if (finalDim == FALSE)
+ {
+ UINT_32 mipSize;
+
+ if (is3dThick)
+ {
+ mipSize = mipPitch * mipHeight * mipDepth * (bpp >> 3);
+ }
+ else
+ {
+ mipSize = mipPitch * mipHeight * (bpp >> 3);
+ }
+
+ if (mipSize <= 256)
+ {
+ UINT_32 index = Log2(bpp >> 3);
+
+ if (is3dThick)
+ {
+ mipPitch = Block256_3dZ[index].w;
+ mipHeight = Block256_3dZ[index].h;
+ mipDepth = Block256_3dZ[index].d;
+ }
+ else
+ {
+ mipPitch = Block256_2d[index].w;
+ mipHeight = Block256_2d[index].h;
+ }
+
+ finalDim = TRUE;
+ }
+ }
+ }
+ else
+ {
+ inTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim,
+ mipPitch, mipHeight, mipDepth);
+
+ if (inTail)
+ {
+ endingMip = mipId;
+
+ mipPitch = tailMaxDim.w;
+ mipHeight = tailMaxDim.h;
+
+ if (is3dThick)
+ {
+ mipDepth = tailMaxDim.d;
+ }
+ }
+ else
+ {
+ mipPitch = PowTwoAlign(mipPitch, blockWidth);
+ mipHeight = PowTwoAlign(mipHeight, blockHeight);
+
+ if (is3dThick)
+ {
+ mipDepth = PowTwoAlign(mipDepth, blockDepth);
+ }
+ }
+ }
+
+ pMipInfo[mipId].pitch = mipPitch;
+ pMipInfo[mipId].height = mipHeight;
+ pMipInfo[mipId].depth = mipDepth;
+ pMipInfo[mipId].offset = offset;
+ offset += (mipPitch * mipHeight * mipDepth * (bpp >> 3));
+
+ if (finalDim)
+ {
+ if (is3dThin)
+ {
+ mipDepth = Max(mipDepth >> 1, 1u);
+ }
+ }
+ else
+ {
+ mipPitch = Max(mipPitch >> 1, 1u);
+ mipHeight = Max(mipHeight >> 1, 1u);
+
+ if (is3dThick || is3dThin)
+ {
+ mipDepth = Max(mipDepth >> 1, 1u);
+ }
+ }
+ }
+
+ return endingMip;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::GetMetaMiptailInfo
+*
+* @brief
+* Get mip tail coordinate information.
+*
+* @return
+* N/A
+************************************************************************************************************************
+*/
+VOID Gfx9Lib::GetMetaMiptailInfo(
+ ADDR2_META_MIP_INFO* pInfo, ///< [out] output structure to store per mip coord
+ Dim3d mipCoord, ///< [in] mip tail base coord
+ UINT_32 numMipInTail, ///< [in] number of mips in tail
+ Dim3d* pMetaBlkDim ///< [in] meta block width/height/depth
+ ) const
+{
+ BOOL_32 isThick = (pMetaBlkDim->d > 1);
+ UINT_32 mipWidth = pMetaBlkDim->w;
+ UINT_32 mipHeight = pMetaBlkDim->h >> 1;
+ UINT_32 mipDepth = pMetaBlkDim->d;
+ UINT_32 minInc;
+
+ if (isThick)
+ {
+ minInc = (pMetaBlkDim->h >= 512) ? 128 : ((pMetaBlkDim->h == 256) ? 64 : 32);
+ }
+ else if (pMetaBlkDim->h >= 1024)
+ {
+ minInc = 256;
+ }
+ else if (pMetaBlkDim->h == 512)
+ {
+ minInc = 128;
+ }
+ else
+ {
+ minInc = 64;
+ }
+
+ UINT_32 blk32MipId = 0xFFFFFFFF;
+
+ for (UINT_32 mip = 0; mip < numMipInTail; mip++)
+ {
+ pInfo[mip].inMiptail = TRUE;
+ pInfo[mip].startX = mipCoord.w;
+ pInfo[mip].startY = mipCoord.h;
+ pInfo[mip].startZ = mipCoord.d;
+ pInfo[mip].width = mipWidth;
+ pInfo[mip].height = mipHeight;
+ pInfo[mip].depth = mipDepth;
+
+ if (mipWidth <= 32)
+ {
+ if (blk32MipId == 0xFFFFFFFF)
+ {
+ blk32MipId = mip;
+ }
+
+ mipCoord.w = pInfo[blk32MipId].startX;
+ mipCoord.h = pInfo[blk32MipId].startY;
+ mipCoord.d = pInfo[blk32MipId].startZ;
+
+ switch (mip - blk32MipId)
+ {
+ case 0:
+ mipCoord.w += 32; // 16x16
+ break;
+ case 1:
+ mipCoord.h += 32; // 8x8
+ break;
+ case 2:
+ mipCoord.h += 32; // 4x4
+ mipCoord.w += 16;
+ break;
+ case 3:
+ mipCoord.h += 32; // 2x2
+ mipCoord.w += 32;
+ break;
+ case 4:
+ mipCoord.h += 32; // 1x1
+ mipCoord.w += 48;
+ break;
+ // The following are for BC/ASTC formats
+ case 5:
+ mipCoord.h += 48; // 1/2 x 1/2
+ break;
+ case 6:
+ mipCoord.h += 48; // 1/4 x 1/4
+ mipCoord.w += 16;
+ break;
+ case 7:
+ mipCoord.h += 48; // 1/8 x 1/8
+ mipCoord.w += 32;
+ break;
+ case 8:
+ mipCoord.h += 48; // 1/16 x 1/16
+ mipCoord.w += 48;
+ break;
+ default:
+ ADDR_ASSERT_ALWAYS();
+ break;
+ }
+
+ mipWidth = ((mip - blk32MipId) == 0) ? 16 : 8;
+ mipHeight = mipWidth;
+
+ if (isThick)
+ {
+ mipDepth = mipWidth;
+ }
+ }
+ else
+ {
+ if (mipWidth <= minInc)
+ {
+ // if we're below the minimal increment...
+ if (isThick)
+ {
+ // For 3d, just go in z direction
+ mipCoord.d += mipDepth;
+ }
+ else
+ {
+ // For 2d, first go across, then down
+ if ((mipWidth * 2) == minInc)
+ {
+ // if we're 2 mips below, that's when we go back in x, and down in y
+ mipCoord.w -= minInc;
+ mipCoord.h += minInc;
+ }
+ else
+ {
+ // otherwise, just go across in x
+ mipCoord.w += minInc;
+ }
+ }
+ }
+ else
+ {
+ // On even mip, go down, otherwise, go across
+ if (mip & 1)
+ {
+ mipCoord.w += mipWidth;
+ }
+ else
+ {
+ mipCoord.h += mipHeight;
+ }
+ }
+ // Divide the width by 2
+ mipWidth >>= 1;
+ // After the first mip in tail, the mip is always a square
+ mipHeight = mipWidth;
+ // ...or for 3d, a cube
+ if (isThick)
+ {
+ mipDepth = mipWidth;
+ }
+ }
+ }
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::GetMipStartPos
+*
+* @brief
+* Internal function to get out information about mip logical start position
+*
+* @return
+* logical start position in macro block width/heith/depth of one mip level within one slice
+************************************************************************************************************************
+*/
+Dim3d Gfx9Lib::GetMipStartPos(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 width,
+ UINT_32 height,
+ UINT_32 depth,
+ UINT_32 blockWidth,
+ UINT_32 blockHeight,
+ UINT_32 blockDepth,
+ UINT_32 mipId,
+ UINT_32 log2ElementBytes,
+ UINT_32* pMipTailBytesOffset) const
+{
+ Dim3d mipStartPos = {0};
+ const Dim3d tailMaxDim = GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
+
+ // Report mip in tail if Mip0 is already in mip tail
+ BOOL_32 inMipTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim, width, height, depth);
+ UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
+ UINT_32 mipIndexInTail = mipId;
+
+ if (inMipTail == FALSE)
+ {
+ // Mip 0 dimension, unit in block
+ UINT_32 mipWidthInBlk = width / blockWidth;
+ UINT_32 mipHeightInBlk = height / blockHeight;
+ UINT_32 mipDepthInBlk = depth / blockDepth;
+ AddrMajorMode majorMode = GetMajorMode(resourceType,
+ swizzleMode,
+ mipWidthInBlk,
+ mipHeightInBlk,
+ mipDepthInBlk);
+
+ UINT_32 endingMip = mipId + 1;
+
+ for (UINT_32 i = 1; i <= mipId; i++)
+ {
+ if ((i == 1) || (i == 3))
+ {
+ if (majorMode == ADDR_MAJOR_Y)
+ {
+ mipStartPos.w += mipWidthInBlk;
+ }
+ else
+ {
+ mipStartPos.h += mipHeightInBlk;
+ }
+ }
+ else
+ {
+ if (majorMode == ADDR_MAJOR_X)
+ {
+ mipStartPos.w += mipWidthInBlk;
+ }
+ else if (majorMode == ADDR_MAJOR_Y)
+ {
+ mipStartPos.h += mipHeightInBlk;
+ }
+ else
+ {
+ mipStartPos.d += mipDepthInBlk;
+ }
+ }
+
+ BOOL_32 inTail = FALSE;
+
+ if (IsThick(resourceType, swizzleMode))
+ {
+ UINT_32 dim = log2blkSize % 3;
+
+ if (dim == 0)
+ {
+ inTail =
+ (mipWidthInBlk <= 2) && (mipHeightInBlk == 1) && (mipDepthInBlk <= 2);
+ }
+ else if (dim == 1)
+ {
+ inTail =
+ (mipWidthInBlk == 1) && (mipHeightInBlk <= 2) && (mipDepthInBlk <= 2);
+ }
+ else
+ {
+ inTail =
+ (mipWidthInBlk <= 2) && (mipHeightInBlk <= 2) && (mipDepthInBlk == 1);
+ }
+ }
+ else
+ {
+ if (log2blkSize & 1)
+ {
+ inTail = (mipWidthInBlk <= 2) && (mipHeightInBlk == 1);
+ }
+ else
+ {
+ inTail = (mipWidthInBlk == 1) && (mipHeightInBlk <= 2);
+ }
+ }
+
+ if (inTail)
+ {
+ endingMip = i;
+ break;
+ }
+
+ mipWidthInBlk = RoundHalf(mipWidthInBlk);
+ mipHeightInBlk = RoundHalf(mipHeightInBlk);
+ mipDepthInBlk = RoundHalf(mipDepthInBlk);
+ }
+
+ if (mipId >= endingMip)
+ {
+ inMipTail = TRUE;
+ mipIndexInTail = mipId - endingMip;
+ }
+ }
+
+ if (inMipTail)
+ {
+ UINT_32 index = mipIndexInTail + MaxMacroBits - log2blkSize;
+ ADDR_ASSERT(index < sizeof(MipTailOffset256B) / sizeof(UINT_32));
+ *pMipTailBytesOffset = MipTailOffset256B[index] << 8;
+ }
+
+ return mipStartPos;
+}
+
+/**
+************************************************************************************************************************
+* Gfx9Lib::HwlComputeSurfaceAddrFromCoordTiled
+*
+* @brief
+* Internal function to calculate address from coord for tiled swizzle surface
+*
+* @return
+* ADDR_E_RETURNCODE
+************************************************************************************************************************
+*/
+ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceAddrFromCoordTiled(
+ const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
+ ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
+ ) const
+{
+ ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
+ localIn.swizzleMode = pIn->swizzleMode;
+ localIn.flags = pIn->flags;
+ localIn.resourceType = pIn->resourceType;
+ localIn.bpp = pIn->bpp;
+ localIn.width = Max(pIn->unalignedWidth, 1u);
+ localIn.height = Max(pIn->unalignedHeight, 1u);
+ localIn.numSlices = Max(pIn->numSlices, 1u);
+ localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
+ localIn.numSamples = Max(pIn->numSamples, 1u);
+ localIn.numFrags = Max(pIn->numFrags, 1u);
+ if (localIn.numMipLevels <= 1)
+ {
+ localIn.pitchInElement = pIn->pitchInElement;
+ }
+
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
+ ADDR_E_RETURNCODE returnCode = ComputeSurfaceInfoTiled(&localIn, &localOut);
+
+ BOOL_32 valid = (returnCode == ADDR_OK) &&
+ (IsThin(pIn->resourceType, pIn->swizzleMode) ||
+ IsThick(pIn->resourceType, pIn->swizzleMode)) &&
+ ((pIn->pipeBankXor == 0) || (IsXor(pIn->swizzleMode)));
+
+ if (valid)
+ {
+ UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
+ Dim3d mipStartPos = {0};
+ UINT_32 mipTailBytesOffset = 0;
+
+ if (pIn->numMipLevels > 1)
+ {
+ // Mip-map chain cannot be MSAA surface
+ ADDR_ASSERT((pIn->numSamples <= 1) && (pIn->numFrags<= 1));
+
+ mipStartPos = GetMipStartPos(pIn->resourceType,
+ pIn->swizzleMode,
+ localOut.pitch,
+ localOut.height,
+ localOut.numSlices,
+ localOut.blockWidth,
+ localOut.blockHeight,
+ localOut.blockSlices,
+ pIn->mipId,
+ log2ElementBytes,
+ &mipTailBytesOffset);
+ }
+
+ UINT_32 interleaveOffset = 0;
+ UINT_32 pipeBits = 0;
+ UINT_32 pipeXor = 0;
+ UINT_32 bankBits = 0;
+ UINT_32 bankXor = 0;
+
+ if (IsThin(pIn->resourceType, pIn->swizzleMode))
+ {
+ UINT_32 blockOffset = 0;
+ UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
+
+ if (IsZOrderSwizzle(pIn->swizzleMode))
+ {
+ // Morton generation
+ if ((log2ElementBytes == 0) || (log2ElementBytes == 2))
+ {
+ UINT_32 totalLowBits = 6 - log2ElementBytes;
+ UINT_32 mortBits = totalLowBits / 2;
+ UINT_32 lowBitsValue = MortonGen2d(pIn->y, pIn->x, mortBits);
+ // Are 9 bits enough?
+ UINT_32 highBitsValue =
+ MortonGen2d(pIn->x >> mortBits, pIn->y >> mortBits, 9) << totalLowBits;
+ blockOffset = lowBitsValue | highBitsValue;
+ ADDR_ASSERT(blockOffset == lowBitsValue + highBitsValue);
+ }
+ else
+ {
+ blockOffset = MortonGen2d(pIn->y, pIn->x, 13);
+ }
+
+ // Fill LSBs with sample bits
+ if (pIn->numSamples > 1)
+ {
+ blockOffset *= pIn->numSamples;
+ blockOffset |= pIn->sample;
+ }
+
+ // Shift according to BytesPP
+ blockOffset <<= log2ElementBytes;
+ }
+ else
+ {
+ // Micro block offset
+ UINT_32 microBlockOffset = ComputeSurface2DMicroBlockOffset(pIn);
+ blockOffset = microBlockOffset;
+
+ // Micro block dimension
+ ADDR_ASSERT(log2ElementBytes < MaxNumOfBpp);
+ Dim2d microBlockDim = Block256_2d[log2ElementBytes];
+ // Morton generation, does 12 bit enough?
+ blockOffset |=
+ MortonGen2d((pIn->x / microBlockDim.w), (pIn->y / microBlockDim.h), 12) << 8;
+
+ // Sample bits start location
+ UINT_32 sampleStart = log2blkSize - Log2(pIn->numSamples);
+ // Join sample bits information to the highest Macro block bits
+ if (IsNonPrtXor(pIn->swizzleMode))
+ {
+ // Non-prt-Xor : xor highest Macro block bits with sample bits
+ blockOffset = blockOffset ^ (pIn->sample << sampleStart);
+ }
+ else
+ {
+ // Non-Xor or prt-Xor: replace highest Macro block bits with sample bits
+ // after this op, the blockOffset only contains log2 Macro block size bits
+ blockOffset %= (1 << sampleStart);
+ blockOffset |= (pIn->sample << sampleStart);
+ ADDR_ASSERT((blockOffset >> log2blkSize) == 0);
+ }
+ }
+
+ if (IsXor(pIn->swizzleMode))
+ {
+ // Mask off bits above Macro block bits to keep page synonyms working for prt
+ if (IsPrt(pIn->swizzleMode))
+ {
+ blockOffset &= ((1 << log2blkSize) - 1);
+ }
+
+ // Preserve offset inside pipe interleave
+ interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
+ blockOffset >>= m_pipeInterleaveLog2;
+
+ // Pipe/Se xor bits
+ pipeBits = GetPipeXorBits(log2blkSize);
+ // Pipe xor
+ pipeXor = FoldXor2d(blockOffset, pipeBits);
+ blockOffset >>= pipeBits;
+
+ // Bank xor bits
+ bankBits = GetBankXorBits(log2blkSize);
+ // Bank Xor
+ bankXor = FoldXor2d(blockOffset, bankBits);
+ blockOffset >>= bankBits;
+
+ // Put all the part back together
+ blockOffset <<= bankBits;
+ blockOffset |= bankXor;
+ blockOffset <<= pipeBits;
+ blockOffset |= pipeXor;
+ blockOffset <<= m_pipeInterleaveLog2;
+ blockOffset |= interleaveOffset;
+ }
+
+ ADDR_ASSERT((blockOffset | mipTailBytesOffset) == (blockOffset + mipTailBytesOffset));
+ ADDR_ASSERT((mipTailBytesOffset == 0u) || (blockOffset < (1u << log2blkSize)));
+
+ blockOffset |= mipTailBytesOffset;
+
+ if (IsNonPrtXor(pIn->swizzleMode) && (pIn->numSamples <= 1))
+ {
+ // Apply slice xor if not MSAA/PRT
+ blockOffset ^= (ReverseBitVector(pIn->slice, pipeBits) << m_pipeInterleaveLog2);
+ blockOffset ^= (ReverseBitVector(pIn->slice >> pipeBits, bankBits) <<
+ (m_pipeInterleaveLog2 + pipeBits));
+ }
+
+ returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
+ bankBits, pipeBits, &blockOffset);
+
+ blockOffset %= (1 << log2blkSize);
+
+ UINT_32 pitchInMacroBlock = localOut.mipChainPitch / localOut.blockWidth;
+ UINT_32 paddedHeightInMacroBlock = localOut.mipChainHeight / localOut.blockHeight;
+ UINT_32 sliceSizeInMacroBlock = pitchInMacroBlock * paddedHeightInMacroBlock;
+ UINT_32 macroBlockIndex =
+ (pIn->slice + mipStartPos.d) * sliceSizeInMacroBlock +
+ ((pIn->y / localOut.blockHeight) + mipStartPos.h) * pitchInMacroBlock +
+ ((pIn->x / localOut.blockWidth) + mipStartPos.w);
+
+ UINT_64 macroBlockOffset = (static_cast<UINT_64>(macroBlockIndex) <<
+ GetBlockSizeLog2(pIn->swizzleMode));
+
+ pOut->addr = blockOffset | macroBlockOffset;
+ }
+ else
+ {
+ UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
+
+ Dim3d microBlockDim = Block1K_3d[log2ElementBytes];
+
+ UINT_32 blockOffset = MortonGen3d((pIn->x / microBlockDim.w),
+ (pIn->y / microBlockDim.h),
+ (pIn->slice / microBlockDim.d),
+ 8);
+
+ blockOffset <<= 10;
+ blockOffset |= ComputeSurface3DMicroBlockOffset(pIn);
+
+ if (IsXor(pIn->swizzleMode))
+ {
+ // Mask off bits above Macro block bits to keep page synonyms working for prt
+ if (IsPrt(pIn->swizzleMode))
+ {
+ blockOffset &= ((1 << log2blkSize) - 1);
+ }
+
+ // Preserve offset inside pipe interleave
+ interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
+ blockOffset >>= m_pipeInterleaveLog2;
+
+ // Pipe/Se xor bits
+ pipeBits = GetPipeXorBits(log2blkSize);
+ // Pipe xor
+ pipeXor = FoldXor3d(blockOffset, pipeBits);
+ blockOffset >>= pipeBits;
+
+ // Bank xor bits
+ bankBits = GetBankXorBits(log2blkSize);
+ // Bank Xor
+ bankXor = FoldXor3d(blockOffset, bankBits);
+ blockOffset >>= bankBits;
+
+ // Put all the part back together
+ blockOffset <<= bankBits;
+ blockOffset |= bankXor;
+ blockOffset <<= pipeBits;
+ blockOffset |= pipeXor;
+ blockOffset <<= m_pipeInterleaveLog2;
+ blockOffset |= interleaveOffset;
+ }
+
+ ADDR_ASSERT((blockOffset | mipTailBytesOffset) == (blockOffset + mipTailBytesOffset));
+ ADDR_ASSERT((mipTailBytesOffset == 0u) || (blockOffset < (1u << log2blkSize)));
+ blockOffset |= mipTailBytesOffset;
+
+ returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
+ bankBits, pipeBits, &blockOffset);
+
+ blockOffset %= (1 << log2blkSize);
+
+ UINT_32 xb = pIn->x / localOut.blockWidth + mipStartPos.w;
+ UINT_32 yb = pIn->y / localOut.blockHeight + mipStartPos.h;
+ UINT_32 zb = pIn->slice / localOut.blockSlices + + mipStartPos.d;
+
+ UINT_32 pitchInBlock = localOut.mipChainPitch / localOut.blockWidth;
+ UINT_32 sliceSizeInBlock =
+ (localOut.mipChainHeight / localOut.blockHeight) * pitchInBlock;
+ UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
+
+ pOut->addr = blockOffset | (blockIndex << log2blkSize);
+ }
+ }
+ else
+ {
+ returnCode = ADDR_INVALIDPARAMS;
+ }
+
+ return returnCode;
+}
+
} // V2
} // Addr
*/
/**
-****************************************************************************************************
+************************************************************************************************************************
* @file gfx9addrlib.h
* @brief Contgfx9ns the Gfx9Lib class definition.
-****************************************************************************************************
+************************************************************************************************************************
*/
#ifndef __GFX9_ADDR_LIB_H__
{
/**
-****************************************************************************************************
+************************************************************************************************************************
* @brief GFX9 specific settings structure.
-****************************************************************************************************
+************************************************************************************************************************
*/
struct Gfx9ChipSettings
{
// Misc configuration bits
UINT_32 metaBaseAlignFix : 1;
- UINT_32 reserved2 : 31;
+ UINT_32 depthPipeXorDisable : 1;
+ UINT_32 reserved2 : 30;
};
};
/**
-****************************************************************************************************
+************************************************************************************************************************
* @brief GFX9 data surface type.
-****************************************************************************************************
+************************************************************************************************************************
*/
enum Gfx9DataType
{
};
/**
-****************************************************************************************************
+************************************************************************************************************************
* @brief This class is the GFX9 specific address library
* function set.
-****************************************************************************************************
+************************************************************************************************************************
*/
class Gfx9Lib : public Lib
{
Gfx9Lib(const Client* pClient);
virtual ~Gfx9Lib();
+ virtual BOOL_32 HwlIsStandardSwizzle(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ return m_swizzleModeTable[swizzleMode].isStd ||
+ (IsTex3d(resourceType) && m_swizzleModeTable[swizzleMode].isDisp);
+ }
+
+ virtual BOOL_32 HwlIsDisplaySwizzle(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ return IsTex2d(resourceType) && m_swizzleModeTable[swizzleMode].isDisp;
+ }
+
+ virtual BOOL_32 HwlIsThin(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ return ((IsTex2d(resourceType) == TRUE) ||
+ ((IsTex3d(resourceType) == TRUE) &&
+ (m_swizzleModeTable[swizzleMode].isZ == FALSE) &&
+ (m_swizzleModeTable[swizzleMode].isStd == FALSE)));
+ }
+
+ virtual BOOL_32 HwlIsThick(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode) const
+ {
+ return (IsTex3d(resourceType) &&
+ (m_swizzleModeTable[swizzleMode].isZ || m_swizzleModeTable[swizzleMode].isStd));
+ }
+
virtual ADDR_E_RETURNCODE HwlComputeHtileInfo(
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) const;
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) const;
+ virtual ADDR_E_RETURNCODE HwlComputeDccAddrFromCoord(
+ const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) const;
+
virtual UINT_32 HwlGetEquationIndex(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
return baseAlign;
}
- virtual BOOL_32 HwlIsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
+ virtual ADDR_E_RETURNCODE HwlComputePipeBankXor(
+ const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const;
- virtual BOOL_32 HwlIsDce12() const { return m_settings.isDce12; }
+ virtual ADDR_E_RETURNCODE HwlComputeSlicePipeBankXor(
+ const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
+ ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const;
+
+ virtual ADDR_E_RETURNCODE HwlComputeSubResourceOffsetForSwizzlePattern(
+ const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
+ ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const;
+
+ virtual ADDR_E_RETURNCODE HwlGetPreferredSurfaceSetting(
+ const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
+ ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const;
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfoSanityCheck(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfoTiled(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
+
+ virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoordTiled(
+ const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;
// Initialize equation table
VOID InitEquationTable();
+ ADDR_E_RETURNCODE ComputeStereoInfo(
+ const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
+ ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
+ UINT_32* pHeightAlign) const;
+
+ UINT_32 GetMipChainInfo(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 bpp,
+ UINT_32 mip0Width,
+ UINT_32 mip0Height,
+ UINT_32 mip0Depth,
+ UINT_32 blockWidth,
+ UINT_32 blockHeight,
+ UINT_32 blockDepth,
+ UINT_32 numMipLevel,
+ ADDR2_MIP_INFO* pMipInfo) const;
+
+ VOID GetMetaMiptailInfo(
+ ADDR2_META_MIP_INFO* pInfo,
+ Dim3d mipCoord,
+ UINT_32 numMipInTail,
+ Dim3d* pMetaBlkDim) const;
+
+ Dim3d GetMipStartPos(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 width,
+ UINT_32 height,
+ UINT_32 depth,
+ UINT_32 blockWidth,
+ UINT_32 blockHeight,
+ UINT_32 blockDepth,
+ UINT_32 mipId,
+ UINT_32 log2ElementBytes,
+ UINT_32* pMipTailBytesOffset) const;
+
+ AddrMajorMode GetMajorMode(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 mip0WidthInBlk,
+ UINT_32 mip0HeightInBlk,
+ UINT_32 mip0DepthInBlk) const
+ {
+ BOOL_32 yMajor = (mip0WidthInBlk < mip0HeightInBlk);
+ BOOL_32 xMajor = (yMajor == FALSE);
+
+ if (IsThick(resourceType, swizzleMode))
+ {
+ yMajor = yMajor && (mip0HeightInBlk >= mip0DepthInBlk);
+ xMajor = xMajor && (mip0WidthInBlk >= mip0DepthInBlk);
+ }
+
+ AddrMajorMode majorMode;
+ if (xMajor)
+ {
+ majorMode = ADDR_MAJOR_X;
+ }
+ else if (yMajor)
+ {
+ majorMode = ADDR_MAJOR_Y;
+ }
+ else
+ {
+ majorMode = ADDR_MAJOR_Z;
+ }
+
+ return majorMode;
+ }
+
+ Dim3d GetDccCompressBlk(
+ AddrResourceType resourceType,
+ AddrSwizzleMode swizzleMode,
+ UINT_32 bpp) const
+ {
+ UINT_32 index = Log2(bpp >> 3);
+ Dim3d compressBlkDim;
+
+ if (IsThin(resourceType, swizzleMode))
+ {
+ compressBlkDim.w = Block256_2d[index].w;
+ compressBlkDim.h = Block256_2d[index].h;
+ compressBlkDim.d = 1;
+ }
+ else if (IsStandardSwizzle(resourceType, swizzleMode))
+ {
+ compressBlkDim = Block256_3dS[index];
+ }
+ else
+ {
+ compressBlkDim = Block256_3dZ[index];
+ }
+
+ return compressBlkDim;
+ }
+
+ static const Dim3d Block256_3dS[MaxNumOfBpp];
+ static const Dim3d Block256_3dZ[MaxNumOfBpp];
+
+ static const UINT_32 MipTailOffset256B[];
+
+ static const SwizzleModeFlags SwizzleModeTable[ADDR_SW_MAX_TYPE];
+
// Max number of swizzle mode supported for equation
static const UINT_32 MaxSwMode = 32;
// Max number of resource type (2D/3D) supported for equation
UINT_32 mip0Width, UINT_32 mip0Height, UINT_32 mip0Depth,
UINT_32* pNumMetaBlkX, UINT_32* pNumMetaBlkY, UINT_32* pNumMetaBlkZ) const;
+ BOOL_32 IsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
+
Gfx9ChipSettings m_settings;
};
ADDR_E_RETURNCODE retCode = SiLib::HwlComputeSurfaceInfo(pIn, pOut);
+
+ if ((pIn->mipLevel > 0) &&
+ (pOut->tcCompatible == TRUE) &&
+ (pOut->tileMode != pIn->tileMode) &&
+ (m_settings.isVolcanicIslands == TRUE))
+ {
+ CheckTcCompatibility(pOut->pTileInfo, pIn->bpp, pOut->tileMode, pOut->tileType, pOut);
+ }
+
if (pOut->macroModeIndex == TileIndexNoMacroIndex)
{
pOut->macroModeIndex = TileIndexInvalid;
switch (tileMode)
{
case ADDR_TM_1D_TILED_THICK:
- tileMode = ADDR_TM_1D_TILED_THIN1;
+ tileMode = ADDR_TM_1D_TILED_THIN1;
break;
case ADDR_TM_2D_TILED_XTHICK:
case ADDR_TM_2D_TILED_THICK:
- tileMode = ADDR_TM_2D_TILED_THIN1;
+ tileMode = ADDR_TM_2D_TILED_THIN1;
break;
case ADDR_TM_3D_TILED_XTHICK:
case ADDR_TM_3D_TILED_THICK:
- tileMode = ADDR_TM_3D_TILED_THIN1;
+ tileMode = ADDR_TM_3D_TILED_THIN1;
break;
case ADDR_TM_PRT_TILED_THICK:
- tileMode = ADDR_TM_PRT_TILED_THIN1;
+ tileMode = ADDR_TM_PRT_TILED_THIN1;
break;
case ADDR_TM_PRT_2D_TILED_THICK:
- tileMode = ADDR_TM_PRT_2D_TILED_THIN1;
+ tileMode = ADDR_TM_PRT_2D_TILED_THIN1;
break;
case ADDR_TM_PRT_3D_TILED_THICK:
- tileMode = ADDR_TM_PRT_3D_TILED_THIN1;
+ tileMode = ADDR_TM_PRT_3D_TILED_THIN1;
break;
default:
if (flags.tcCompatible)
{
- if (IsMacroTiled(tileMode))
- {
- if (inTileType != ADDR_DEPTH_SAMPLE_ORDER)
- {
- // Turn off tcCompatible for color surface if tileSplit happens. Depth/stencil
- // tileSplit case was handled at tileIndex selecting time.
- INT_32 tileIndex = pOut->tileIndex;
-
- if ((tileIndex == TileIndexInvalid) && (IsTileInfoAllZero(pTileInfo) == FALSE))
- {
- tileIndex = HwlPostCheckTileIndex(pTileInfo, tileMode, inTileType, tileIndex);
- }
-
- if (tileIndex != TileIndexInvalid)
- {
- ADDR_ASSERT(static_cast<UINT_32>(tileIndex) < TileTableSize);
- // Non-depth entries store a split factor
- UINT_32 sampleSplit = m_tileTable[tileIndex].info.tileSplitBytes;
- UINT_32 tileBytes1x = BITS_TO_BYTES(bpp * MicroTilePixels * thickness);
- UINT_32 colorTileSplit = Max(256u, sampleSplit * tileBytes1x);
-
- if (m_rowSize < colorTileSplit)
- {
- flags.tcCompatible = FALSE;
- }
- }
- }
- }
- else
- {
- // Client should not enable tc compatible for linear and 1D tile modes.
- flags.tcCompatible = FALSE;
- }
+ CheckTcCompatibility(pTileInfo, bpp, tileMode, inTileType, pOut);
}
pOut->tcCompatible = flags.tcCompatible;
return depthStencil2DTileConfigMatch;
}
+/**
+****************************************************************************************************
+* CiLib::DepthStencilTileCfgMatch
+*
+* @brief
+* Turn off TcCompatible if requirement is not met
+* @return
+* N/A
+****************************************************************************************************
+*/
+VOID CiLib::CheckTcCompatibility(
+ const ADDR_TILEINFO* pTileInfo, ///< [in] input tile info
+ UINT_32 bpp, ///< [in] Bits per pixel
+ AddrTileMode tileMode, ///< [in] input tile mode
+ AddrTileType tileType, ///< [in] input tile type
+ ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] out structure
+ ) const
+{
+ if (IsMacroTiled(tileMode))
+ {
+ if (tileType != ADDR_DEPTH_SAMPLE_ORDER)
+ {
+ // Turn off tcCompatible for color surface if tileSplit happens. Depth/stencil
+ // tileSplit case was handled at tileIndex selecting time.
+ INT_32 tileIndex = pOut->tileIndex;
+
+ if ((tileIndex == TileIndexInvalid) && (IsTileInfoAllZero(pTileInfo) == FALSE))
+ {
+ tileIndex = HwlPostCheckTileIndex(pTileInfo, tileMode, tileType, tileIndex);
+ }
+
+ if (tileIndex != TileIndexInvalid)
+ {
+ UINT_32 thickness = Thickness(tileMode);
+
+ ADDR_ASSERT(static_cast<UINT_32>(tileIndex) < TileTableSize);
+ // Non-depth entries store a split factor
+ UINT_32 sampleSplit = m_tileTable[tileIndex].info.tileSplitBytes;
+ UINT_32 tileBytes1x = BITS_TO_BYTES(bpp * MicroTilePixels * thickness);
+ UINT_32 colorTileSplit = Max(256u, sampleSplit * tileBytes1x);
+
+ if (m_rowSize < colorTileSplit)
+ {
+ pOut->tcCompatible = FALSE;
+ }
+ }
+ }
+ }
+ else
+ {
+ // Client should not enable tc compatible for linear and 1D tile modes.
+ pOut->tcCompatible = FALSE;
+ }
+}
+
} // V1
} // Addr
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
+ VOID CheckTcCompatibility(
+ const ADDR_TILEINFO* pTileInfo, UINT_32 bpp, AddrTileMode tileMode,
+ AddrTileType tileType, ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
+
static const UINT_32 MacroTileTableSize = 16;
static const UINT_32 PrtMacroModeOffset = MacroTileTableSize / 2;
static const INT_32 MinDepth2DThinIndex = 0;
****************************************************************************************************
*/
BOOL_32 EgBasedLib::IsTileInfoAllZero(
- ADDR_TILEINFO* pTileInfo)
+ const ADDR_TILEINFO* pTileInfo)
{
BOOL_32 allZero = TRUE;
ADDR_TILEINFO* pTileInfo, ADDR_EQUATION* pEquation) const;
// Static functions
- static BOOL_32 IsTileInfoAllZero(ADDR_TILEINFO* pTileInfo);
+ static BOOL_32 IsTileInfoAllZero(const ADDR_TILEINFO* pTileInfo);
static UINT_32 ComputeFmaskNumPlanesFromNumSamples(UINT_32 numSamples);
static UINT_32 ComputeFmaskResolvedBppFromNumSamples(UINT_32 numSamples);
{
static const UINT_32 SiUncompressDepthTileIndex = 3;
- if ((pIn->flags.prt == FALSE) &&
- (m_uncompressDepthEqIndex != 0) &&
- (tileIndex == SiUncompressDepthTileIndex))
+ if ((pIn->numSlices > 1) &&
+ (IsMacroTiled(pOut->tileMode) == TRUE) &&
+ (m_chipFamily == ADDR_CHIP_FAMILY_SI))
+ {
+ pOut->equationIndex = ADDR_INVALID_EQUATION_INDEX;
+ }
+ else if ((pIn->flags.prt == FALSE) &&
+ (m_uncompressDepthEqIndex != 0) &&
+ (tileIndex == SiUncompressDepthTileIndex))
{
pOut->equationIndex = m_uncompressDepthEqIndex + Log2(pIn->bpp >> 3);
}
switch (tileMode)
{
case ADDR_TM_PRT_TILED_THIN1:
- tileMode = ADDR_TM_2D_TILED_THIN1;
+ tileMode = ADDR_TM_2D_TILED_THIN1;
break;
case ADDR_TM_PRT_TILED_THICK:
- tileMode = ADDR_TM_2D_TILED_THICK;
+ tileMode = ADDR_TM_2D_TILED_THICK;
break;
case ADDR_TM_PRT_2D_TILED_THICK:
- tileMode = ADDR_TM_2D_TILED_THICK;
+ tileMode = ADDR_TM_2D_TILED_THICK;
break;
case ADDR_TM_PRT_3D_TILED_THICK:
- tileMode = ADDR_TM_3D_TILED_THICK;
+ tileMode = ADDR_TM_3D_TILED_THICK;
break;
default:
if (tileMode != pInOut->tileMode)
{
- pInOut->tileMode = tileMode;
-
- ADDR_ASSERT(pInOut->flags.prt == TRUE);
+ pInOut->tileMode = tileMode;
+ // Only PRT tile modes are overridden for now. Revisit this once new modes are added above.
+ pInOut->flags.prt = TRUE;
}
}
projects / mesa.git / commitdiff