amd/addrlib: import gfx9 support
This commit is contained in:
Nicolai Hähnle
Marek Olšák
parent
047d6daf10
commit
7f160efcde
|
|
@ -26,7 +26,9 @@ addrlib_libamdgpu_addrlib_la_CPPFLAGS = \
|
|||
-I$(srcdir)/common \
|
||||
-I$(srcdir)/addrlib \
|
||||
-I$(srcdir)/addrlib/core \
|
||||
-I$(srcdir)/addrlib/inc/chip/gfx9 \
|
||||
-I$(srcdir)/addrlib/inc/chip/r800 \
|
||||
-I$(srcdir)/addrlib/gfx9/chip \
|
||||
-I$(srcdir)/addrlib/r800/chip \
|
||||
-DBRAHMA_BUILD=1
|
||||
|
||||
|
|
|
|||
|
|
@ -16,8 +16,16 @@ ADDRLIB_FILES = \
|
|||
addrlib/core/addrlib.h \
|
||||
addrlib/core/addrlib1.cpp \
|
||||
addrlib/core/addrlib1.h \
|
||||
addrlib/core/addrlib2.cpp \
|
||||
addrlib/core/addrlib2.h \
|
||||
addrlib/core/addrobject.cpp \
|
||||
addrlib/core/addrobject.h \
|
||||
addrlib/gfx9/coord.cpp \
|
||||
addrlib/gfx9/coord.h \
|
||||
addrlib/gfx9/gfx9addrlib.cpp \
|
||||
addrlib/gfx9/gfx9addrlib.h \
|
||||
addrlib/gfx9/rbmap.cpp \
|
||||
addrlib/gfx9/rbmap.h \
|
||||
addrlib/inc/chip/r800/si_gb_reg.h \
|
||||
addrlib/inc/lnx_common_defs.h \
|
||||
addrlib/r800/chip/si_ci_vi_merged_enum.h \
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
*/
|
||||
#include "addrinterface.h"
|
||||
#include "addrlib1.h"
|
||||
#include "addrlib2.h"
|
||||
|
||||
#include "addrcommon.h"
|
||||
|
||||
|
|
@ -1070,3 +1071,517 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
|
|||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Surface functions for Addr2
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeSurfaceInfo
|
||||
*
|
||||
* @brief
|
||||
* Calculate surface width/height/depth/alignments and suitable tiling mode
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeSurfaceAddrFromCoord
|
||||
*
|
||||
* @brief
|
||||
* Compute surface address according to coordinates
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
|
||||
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeSurfaceCoordFromAddr
|
||||
*
|
||||
* @brief
|
||||
* Compute coordinates according to surface address
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
|
||||
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// HTile functions for Addr2
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeHtileInfo
|
||||
*
|
||||
* @brief
|
||||
* Compute Htile pitch, height, base alignment and size in bytes
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
|
||||
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeHtileInfo(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeHtileAddrFromCoord
|
||||
*
|
||||
* @brief
|
||||
* Compute Htile address according to coordinates (of depth buffer)
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
|
||||
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeHtileCoordFromAddr
|
||||
*
|
||||
* @brief
|
||||
* Compute coordinates within depth buffer (1st pixel of a micro tile) according to
|
||||
* Htile address
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
|
||||
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// C-mask functions for Addr2
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeCmaskInfo
|
||||
*
|
||||
* @brief
|
||||
* Compute Cmask pitch, height, base alignment and size in bytes from color buffer
|
||||
* info
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
|
||||
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeCmaskAddrFromCoord
|
||||
*
|
||||
* @brief
|
||||
* Compute Cmask address according to coordinates (of MSAA color buffer)
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
|
||||
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeCmaskCoordFromAddr
|
||||
*
|
||||
* @brief
|
||||
* Compute coordinates within color buffer (1st pixel of a micro tile) according to
|
||||
* Cmask address
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
|
||||
ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// F-mask functions for Addr2
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeFmaskInfo
|
||||
*
|
||||
* @brief
|
||||
* Compute Fmask pitch/height/depth/alignments and size in bytes
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
|
||||
ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeFmaskAddrFromCoord
|
||||
*
|
||||
* @brief
|
||||
* Compute Fmask address according to coordinates (x,y,slice,sample,plane)
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
|
||||
ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeFmaskCoordFromAddr
|
||||
*
|
||||
* @brief
|
||||
* Compute coordinates (x,y,slice,sample,plane) according to Fmask address
|
||||
*
|
||||
* @return
|
||||
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
|
||||
ADDR_HANDLE hLib, ///< address lib handle
|
||||
const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
|
||||
ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
|
||||
{
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// DCC key functions for Addr2
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputeDccInfo
|
||||
*
|
||||
* @brief
|
||||
* Compute DCC key size, base alignment based on color surface size, tile info or tile index
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
|
||||
ADDR_HANDLE hLib, ///< handle of addrlib
|
||||
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
|
||||
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
|
||||
{
|
||||
ADDR_E_RETURNCODE returnCode;
|
||||
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputeDccInfo(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2ComputePipeBankXor
|
||||
*
|
||||
* @brief
|
||||
* Calculate a valid bank pipe xor value for client to use.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
|
||||
ADDR_HANDLE hLib, ///< handle of addrlib
|
||||
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
|
||||
ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
|
||||
{
|
||||
ADDR_E_RETURNCODE returnCode;
|
||||
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->ComputePipeBankXor(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* Addr2GetPreferredSurfaceSetting
|
||||
*
|
||||
* @brief
|
||||
* Suggest a preferred setting for client driver to program HW register
|
||||
****************************************************************************************************
|
||||
*/
|
||||
ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
|
||||
ADDR_HANDLE hLib, ///< handle of addrlib
|
||||
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
|
||||
ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
|
||||
{
|
||||
ADDR_E_RETURNCODE returnCode;
|
||||
|
||||
V2::Lib* pLib = V2::Lib::GetLib(hLib);
|
||||
|
||||
if (pLib != NULL)
|
||||
{
|
||||
returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
returnCode = ADDR_ERROR;
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -199,6 +199,142 @@ typedef enum _AddrTileMode
|
|||
ADDR_TM_COUNT = 26, ///< Must be the value of the last tile mode
|
||||
} AddrTileMode;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief
|
||||
* Neutral enums that define swizzle modes for Gfx9 ASIC
|
||||
* @note
|
||||
*
|
||||
* ADDR_SW_LINEAR linear aligned addressing mode, for 1D/2D/3D resouce
|
||||
* ADDR_SW_256B_* addressing block aligned size is 256B, for 2D/3D resouce
|
||||
* ADDR_SW_4KB_* addressing block aligned size is 4KB, for 2D/3D resouce
|
||||
* ADDR_SW_64KB_* addressing block aligned size is 64KB, for 2D/3D resouce
|
||||
* ADDR_SW_VAR_* addressing block aligned size is ASIC specific, for 2D/3D resouce
|
||||
*
|
||||
* ADDR_SW_*_Z For 2D resouce, represents Z-order swizzle mode for depth/stencil/FMask
|
||||
For 3D resouce, represents a swizzle mode similar to legacy thick tile mode
|
||||
* ADDR_SW_*_S represents standard swizzle mode defined by MS
|
||||
* ADDR_SW_*_D For 2D resouce, represents a swizzle mode for displayable resource
|
||||
* For 3D resouce, represents a swizzle mode which places each slice in order & pixel
|
||||
within slice is placed as 2D ADDR_SW_*_S. Don't use this combination if possible!
|
||||
* ADDR_SW_*_R For 2D resouce only, represents a swizzle mode for rotated displayable resource
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
typedef enum _AddrSwizzleMode
|
||||
{
|
||||
ADDR_SW_LINEAR = 0,
|
||||
ADDR_SW_256B_S = 1,
|
||||
ADDR_SW_256B_D = 2,
|
||||
ADDR_SW_256B_R = 3,
|
||||
ADDR_SW_4KB_Z = 4,
|
||||
ADDR_SW_4KB_S = 5,
|
||||
ADDR_SW_4KB_D = 6,
|
||||
ADDR_SW_4KB_R = 7,
|
||||
ADDR_SW_64KB_Z = 8,
|
||||
ADDR_SW_64KB_S = 9,
|
||||
ADDR_SW_64KB_D = 10,
|
||||
ADDR_SW_64KB_R = 11,
|
||||
ADDR_SW_VAR_Z = 12,
|
||||
ADDR_SW_VAR_S = 13,
|
||||
ADDR_SW_VAR_D = 14,
|
||||
ADDR_SW_VAR_R = 15,
|
||||
ADDR_SW_64KB_Z_T = 16,
|
||||
ADDR_SW_64KB_S_T = 17,
|
||||
ADDR_SW_64KB_D_T = 18,
|
||||
ADDR_SW_64KB_R_T = 19,
|
||||
ADDR_SW_4KB_Z_X = 20,
|
||||
ADDR_SW_4KB_S_X = 21,
|
||||
ADDR_SW_4KB_D_X = 22,
|
||||
ADDR_SW_4KB_R_X = 23,
|
||||
ADDR_SW_64KB_Z_X = 24,
|
||||
ADDR_SW_64KB_S_X = 25,
|
||||
ADDR_SW_64KB_D_X = 26,
|
||||
ADDR_SW_64KB_R_X = 27,
|
||||
ADDR_SW_VAR_Z_X = 28,
|
||||
ADDR_SW_VAR_S_X = 29,
|
||||
ADDR_SW_VAR_D_X = 30,
|
||||
ADDR_SW_VAR_R_X = 31,
|
||||
ADDR_SW_LINEAR_GENERAL = 32,
|
||||
ADDR_SW_MAX_TYPE = 33,
|
||||
|
||||
// Used for represent block with identical size
|
||||
ADDR_SW_256B = ADDR_SW_256B_S,
|
||||
ADDR_SW_4KB = ADDR_SW_4KB_S_X,
|
||||
ADDR_SW_64KB = ADDR_SW_64KB_S_X,
|
||||
ADDR_SW_VAR = ADDR_SW_VAR_S_X,
|
||||
} AddrSwizzleMode;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief
|
||||
* Neutral enums that define image type
|
||||
* @note
|
||||
* this is new for address library interface version 2
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
typedef enum _AddrResourceType
|
||||
{
|
||||
ADDR_RSRC_TEX_1D = 0,
|
||||
ADDR_RSRC_TEX_2D = 1,
|
||||
ADDR_RSRC_TEX_3D = 2,
|
||||
ADDR_RSRC_MAX_TYPE = 3,
|
||||
} AddrResourceType;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief
|
||||
* Neutral enums that define resource heap location
|
||||
* @note
|
||||
* this is new for address library interface version 2
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
typedef enum _AddrResrouceLocation
|
||||
{
|
||||
ADDR_RSRC_LOC_UNDEF = 0, // Resource heap is undefined/unknown
|
||||
ADDR_RSRC_LOC_LOCAL = 1, // CPU visable and CPU invisable local heap
|
||||
ADDR_RSRC_LOC_USWC = 2, // CPU write-combined non-cached nonlocal heap
|
||||
ADDR_RSRC_LOC_CACHED = 3, // CPU cached nonlocal heap
|
||||
ADDR_RSRC_LOC_INVIS = 4, // CPU invisable local heap only
|
||||
ADDR_RSRC_LOC_MAX_TYPE = 5,
|
||||
} AddrResrouceLocation;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief
|
||||
* Neutral enums that define resource basic swizzle mode
|
||||
* @note
|
||||
* this is new for address library interface version 2
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
typedef enum _AddrSwType
|
||||
{
|
||||
ADDR_SW_Z = 0, // Resource basic swizzle mode is ZOrder
|
||||
ADDR_SW_S = 1, // Resource basic swizzle mode is Standard
|
||||
ADDR_SW_D = 2, // Resource basic swizzle mode is Display
|
||||
ADDR_SW_R = 3, // Resource basic swizzle mode is Rotated
|
||||
} AddrSwType;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief
|
||||
* Neutral enums that define mipmap major mode
|
||||
* @note
|
||||
* this is new for address library interface version 2
|
||||
*
|
||||
****************************************************************************************************
|
||||
*/
|
||||
typedef enum _AddrMajorMode
|
||||
{
|
||||
ADDR_MAJOR_X = 0,
|
||||
ADDR_MAJOR_Y = 1,
|
||||
ADDR_MAJOR_Z = 2,
|
||||
ADDR_MAJOR_MAX_TYPE = 3,
|
||||
} AddrMajorMode;
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* AddrFormat
|
||||
|
|
|
|||
|
|
@ -210,6 +210,7 @@ enum LibClass
|
|||
R800_ADDRLIB = 0x8,
|
||||
SI_ADDRLIB = 0xa,
|
||||
CI_ADDRLIB = 0xb,
|
||||
AI_ADDRLIB = 0xd,
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -231,6 +232,7 @@ enum ChipFamily
|
|||
ADDR_CHIP_FAMILY_SI,
|
||||
ADDR_CHIP_FAMILY_CI,
|
||||
ADDR_CHIP_FAMILY_VI,
|
||||
ADDR_CHIP_FAMILY_AI,
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -582,12 +584,233 @@ static inline VOID SafeAssign(
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* RoundHalf
|
||||
*
|
||||
* @brief
|
||||
* return (x + 1) / 2
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 RoundHalf(
|
||||
UINT_32 x) ///< [in] input value
|
||||
{
|
||||
ADDR_ASSERT(x != 0);
|
||||
|
||||
#if 1
|
||||
return (x >> 1) + (x & 1);
|
||||
#else
|
||||
return (x + 1) >> 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* SumGeo
|
||||
*
|
||||
* @brief
|
||||
* Calculate sum of a geometric progression whose ratio is 1/2
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 SumGeo(
|
||||
UINT_32 base, ///< [in] First term in the geometric progression
|
||||
UINT_32 num) ///< [in] Number of terms to be added into sum
|
||||
{
|
||||
ADDR_ASSERT(base > 0);
|
||||
|
||||
UINT_32 sum = 0;
|
||||
UINT_32 i = 0;
|
||||
for (; (i < num) && (base > 1); i++)
|
||||
{
|
||||
sum += base;
|
||||
base = RoundHalf(base);
|
||||
}
|
||||
sum += num - i;
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* GetBit
|
||||
*
|
||||
* @brief
|
||||
* Extract bit N value (0 or 1) of a UINT32 value.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 GetBit(
|
||||
UINT_32 u32, ///< [in] UINT32 value
|
||||
UINT_32 pos) ///< [in] bit position from LSB, valid range is [0..31]
|
||||
{
|
||||
ADDR_ASSERT(pos <= 31);
|
||||
|
||||
return (u32 >> pos) & 0x1;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* GetBits
|
||||
*
|
||||
* @brief
|
||||
* Copy 'bitsNum' bits from src start from srcStartPos into destination from dstStartPos
|
||||
* srcStartPos: 0~31 for UINT_32
|
||||
* bitsNum : 1~32 for UINT_32
|
||||
* srcStartPos: 0~31 for UINT_32
|
||||
* src start position
|
||||
* |
|
||||
* src : b[31] b[30] b[29] ... ... ... ... ... ... ... ... b[end]..b[beg] ... b[1] b[0]
|
||||
* || Bits num || copy length || Bits num ||
|
||||
* dst : b[31] b[30] b[29] ... b[end]..b[beg] ... ... ... ... ... ... ... ... b[1] b[0]
|
||||
* |
|
||||
* dst start position
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 GetBits(
|
||||
UINT_32 src,
|
||||
UINT_32 srcStartPos,
|
||||
UINT_32 bitsNum,
|
||||
UINT_32 dstStartPos)
|
||||
{
|
||||
ADDR_ASSERT((srcStartPos < 32) && (dstStartPos < 32) && (bitsNum > 0));
|
||||
ADDR_ASSERT((bitsNum + dstStartPos <= 32) && (bitsNum + srcStartPos <= 32));
|
||||
|
||||
return ((src >> srcStartPos) << (32 - bitsNum)) >> (32 - bitsNum - dstStartPos);
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* MortonGen2d
|
||||
*
|
||||
* @brief
|
||||
* Generate 2D Morton interleave code with num lowest bits in each channel
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 MortonGen2d(
|
||||
UINT_32 x, ///< [in] First channel
|
||||
UINT_32 y, ///< [in] Second channel
|
||||
UINT_32 num) ///< [in] Number of bits extracted from each channel
|
||||
{
|
||||
UINT_32 mort = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < num; i++)
|
||||
{
|
||||
mort |= (GetBit(y, i) << (2 * i));
|
||||
mort |= (GetBit(x, i) << (2 * i + 1));
|
||||
}
|
||||
|
||||
return mort;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* MortonGen3d
|
||||
*
|
||||
* @brief
|
||||
* Generate 3D Morton interleave code with num lowest bits in each channel
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 MortonGen3d(
|
||||
UINT_32 x, ///< [in] First channel
|
||||
UINT_32 y, ///< [in] Second channel
|
||||
UINT_32 z, ///< [in] Third channel
|
||||
UINT_32 num) ///< [in] Number of bits extracted from each channel
|
||||
{
|
||||
UINT_32 mort = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < num; i++)
|
||||
{
|
||||
mort |= (GetBit(z, i) << (3 * i));
|
||||
mort |= (GetBit(y, i) << (3 * i + 1));
|
||||
mort |= (GetBit(x, i) << (3 * i + 2));
|
||||
}
|
||||
|
||||
return mort;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* ReverseBitVector
|
||||
*
|
||||
* @brief
|
||||
* Return reversed lowest num bits of v
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 ReverseBitVector(
|
||||
UINT_32 v, ///< [in] Reverse operation base value
|
||||
UINT_32 num) ///< [in] Number of bits used in reverse operation
|
||||
{
|
||||
UINT_32 reverse = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < num; i++)
|
||||
{
|
||||
reverse |= (GetBit(v, num - 1 - i) << i);
|
||||
}
|
||||
|
||||
return reverse;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* FoldXor2d
|
||||
*
|
||||
* @brief
|
||||
* Xor bit vector v[num-1]v[num-2]...v[1]v[0] with v[num]v[num+1]...v[2*num-2]v[2*num-1]
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 FoldXor2d(
|
||||
UINT_32 v, ///< [in] Xor operation base value
|
||||
UINT_32 num) ///< [in] Number of bits used in fold xor operation
|
||||
{
|
||||
return (v & ((1 << num) - 1)) ^ ReverseBitVector(v >> num, num);
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* DeMort
|
||||
*
|
||||
* @brief
|
||||
* Return v[0] | v[2] | v[4] | v[6]... | v[2*num - 2]
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 DeMort(
|
||||
UINT_32 v, ///< [in] DeMort operation base value
|
||||
UINT_32 num) ///< [in] Number of bits used in fold DeMort operation
|
||||
{
|
||||
UINT_32 d = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < num; i++)
|
||||
{
|
||||
d |= ((v & (1 << (i << 1))) >> i);
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* FoldXor3d
|
||||
*
|
||||
* @brief
|
||||
* v[0]...v[num-1] ^ v[3*num-1]v[3*num-3]...v[num+2]v[num] ^ v[3*num-2]...v[num+1]v[num-1]
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline UINT_32 FoldXor3d(
|
||||
UINT_32 v, ///< [in] Xor operation base value
|
||||
UINT_32 num) ///< [in] Number of bits used in fold xor operation
|
||||
{
|
||||
UINT_32 t = v & ((1 << num) - 1);
|
||||
t ^= ReverseBitVector(DeMort(v >> num, num), num);
|
||||
t ^= ReverseBitVector(DeMort(v >> (num + 1), num), num);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* InitChannel
|
||||
*
|
||||
* @brief
|
||||
* Get channel initialization value
|
||||
* Set channel initialization value via a return value
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline ADDR_CHANNEL_SETTING InitChannel(
|
||||
|
|
@ -603,6 +826,69 @@ static inline ADDR_CHANNEL_SETTING InitChannel(
|
|||
return t;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* InitChannel
|
||||
*
|
||||
* @brief
|
||||
* Set channel initialization value via channel pointer
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline VOID InitChannel(
|
||||
UINT_32 valid, ///< [in] valid setting
|
||||
UINT_32 channel, ///< [in] channel setting
|
||||
UINT_32 index, ///< [in] index setting
|
||||
ADDR_CHANNEL_SETTING *pChanSet) ///< [out] channel setting to be initialized
|
||||
{
|
||||
pChanSet->valid = valid;
|
||||
pChanSet->channel = channel;
|
||||
pChanSet->index = index;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* InitChannel
|
||||
*
|
||||
* @brief
|
||||
* Set channel initialization value via another channel
|
||||
****************************************************************************************************
|
||||
*/
|
||||
static inline VOID InitChannel(
|
||||
ADDR_CHANNEL_SETTING *pChanDst, ///< [in] channel setting to be copied from
|
||||
ADDR_CHANNEL_SETTING *pChanSrc) ///< [out] channel setting to be initialized
|
||||
{
|
||||
pChanDst->valid = pChanSrc->valid;
|
||||
pChanDst->channel = pChanSrc->channel;
|
||||
pChanDst->index = pChanSrc->channel;
|
||||
}
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* GetMaxValidChannelIndex
|
||||
*
|
||||
* @brief
|
||||
* Get max valid index for a specific channel
|
||||
****************************************************************************************************
|
||||
*/
|
||||
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
|
||||
{
|
||||
UINT_32 index = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < searchCount; i++)
|
||||
{
|
||||
if (pChanSet[i].valid && (pChanSet[i].channel == channel))
|
||||
{
|
||||
index = Max(index, static_cast<UINT_32>(pChanSet[i].index));
|
||||
}
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
} // Addr
|
||||
|
||||
#endif // __ADDR_COMMON_H__
|
||||
|
|
|
|||
|
|
@ -217,6 +217,9 @@ ADDR_E_RETURNCODE Lib::Create(
|
|||
break;
|
||||
}
|
||||
break;
|
||||
case CIASICIDGFXENGINE_ARCTICISLAND:
|
||||
pLib = Gfx9HwlInit(&client);
|
||||
break;
|
||||
default:
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -56,6 +56,10 @@
|
|||
#define CIASICIDGFXENGINE_SOUTHERNISLAND 0x0000000A
|
||||
#endif
|
||||
|
||||
#ifndef CIASICIDGFXENGINE_ARCTICISLAND
|
||||
#define CIASICIDGFXENGINE_ARCTICISLAND 0x0000000D
|
||||
#endif
|
||||
|
||||
namespace Addr
|
||||
{
|
||||
|
||||
|
|
@ -68,6 +72,8 @@ enum PipeInterleave
|
|||
{
|
||||
ADDR_PIPEINTERLEAVE_256B = 256,
|
||||
ADDR_PIPEINTERLEAVE_512B = 512,
|
||||
ADDR_PIPEINTERLEAVE_1KB = 1024,
|
||||
ADDR_PIPEINTERLEAVE_2KB = 2048,
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -257,6 +263,7 @@ private:
|
|||
|
||||
Lib* SiHwlInit (const Client* pClient);
|
||||
Lib* CiHwlInit (const Client* pClient);
|
||||
Lib* Gfx9HwlInit(const Client* pClient);
|
||||
|
||||
} // Addr
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,797 @@
|
|||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @file addrlib2.h
|
||||
* @brief Contains the Addr::V2::Lib class definition.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __ADDR2_LIB2_H__
|
||||
#define __ADDR2_LIB2_H__
|
||||
|
||||
#include "addrlib.h"
|
||||
|
||||
namespace Addr
|
||||
{
|
||||
namespace V2
|
||||
{
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief Flags for SwizzleModeTable
|
||||
****************************************************************************************************
|
||||
*/
|
||||
struct SwizzleModeFlags
|
||||
{
|
||||
// Swizzle mode
|
||||
UINT_32 isLinear : 1; // Linear
|
||||
|
||||
// Block size
|
||||
UINT_32 is256b : 1; // Block size is 256B
|
||||
UINT_32 is4kb : 1; // Block size is 4KB
|
||||
UINT_32 is64kb : 1; // Block size is 64KB
|
||||
UINT_32 isVar : 1; // Block size is variable
|
||||
|
||||
UINT_32 isZ : 1; // Z order swizzle mode
|
||||
UINT_32 isStd : 1; // Standard swizzle mode
|
||||
UINT_32 isDisp : 1; // Display swizzle mode
|
||||
UINT_32 isRot : 1; // Rotate swizzle mode
|
||||
|
||||
// XOR mode
|
||||
UINT_32 isXor : 1; // XOR after swizzle if set
|
||||
|
||||
UINT_32 isT : 1; // T mode
|
||||
};
|
||||
|
||||
struct Dim2d
|
||||
{
|
||||
UINT_32 w;
|
||||
UINT_32 h;
|
||||
};
|
||||
|
||||
struct Dim3d
|
||||
{
|
||||
UINT_32 w;
|
||||
UINT_32 h;
|
||||
UINT_32 d;
|
||||
};
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief This class contains asic independent address lib functionalities
|
||||
****************************************************************************************************
|
||||
*/
|
||||
class Lib : public Addr::Lib
|
||||
{
|
||||
public:
|
||||
virtual ~Lib();
|
||||
|
||||
static Lib* GetLib(
|
||||
ADDR_HANDLE hLib);
|
||||
|
||||
//
|
||||
// Interface stubs
|
||||
//
|
||||
|
||||
// For data surface
|
||||
ADDR_E_RETURNCODE ComputeSurfaceInfo(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoord(
|
||||
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceCoordFromAddr(
|
||||
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
// For HTile
|
||||
ADDR_E_RETURNCODE ComputeHtileInfo(
|
||||
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeHtileAddrFromCoord(
|
||||
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeHtileCoordFromAddr(
|
||||
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
// For CMask
|
||||
ADDR_E_RETURNCODE ComputeCmaskInfo(
|
||||
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeCmaskAddrFromCoord(
|
||||
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeCmaskCoordFromAddr(
|
||||
const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
// For FMask
|
||||
ADDR_E_RETURNCODE ComputeFmaskInfo(
|
||||
const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut);
|
||||
|
||||
ADDR_E_RETURNCODE ComputeFmaskAddrFromCoord(
|
||||
const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeFmaskCoordFromAddr(
|
||||
const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
// For DCC key
|
||||
ADDR_E_RETURNCODE ComputeDccInfo(
|
||||
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) const;
|
||||
|
||||
// Misc
|
||||
ADDR_E_RETURNCODE ComputePipeBankXor(
|
||||
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut);
|
||||
|
||||
ADDR_E_RETURNCODE Addr2GetPreferredSurfaceSetting(
|
||||
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
|
||||
ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const;
|
||||
|
||||
protected:
|
||||
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 Dim2d CompressBlock2d[];
|
||||
static const Dim3d CompressBlock3dS[];
|
||||
static const Dim3d CompressBlock3dZ[];
|
||||
|
||||
static const UINT_32 MaxMacroBits;
|
||||
static const UINT_32 MipTailOffset[];
|
||||
|
||||
// Checking block size
|
||||
static BOOL_32 IsBlock256b(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].is256b;
|
||||
}
|
||||
|
||||
static BOOL_32 IsBlock4kb(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].is4kb;
|
||||
}
|
||||
|
||||
static BOOL_32 IsBlock64kb(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].is64kb;
|
||||
}
|
||||
|
||||
static BOOL_32 IsBlockVariable(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isVar;
|
||||
}
|
||||
|
||||
// Checking swizzle mode
|
||||
static BOOL_32 IsLinear(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isLinear;
|
||||
}
|
||||
|
||||
static BOOL_32 IsZOrderSwizzle(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isZ;
|
||||
}
|
||||
|
||||
static BOOL_32 IsStandardSwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isStd ||
|
||||
(IsTex3d(resourceType) && SwizzleModeTable[swizzleMode].isDisp);
|
||||
}
|
||||
|
||||
static BOOL_32 IsDisplaySwizzle(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return IsTex2d(resourceType) && SwizzleModeTable[swizzleMode].isDisp;
|
||||
}
|
||||
|
||||
static BOOL_32 IsRotateSwizzle(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isRot;
|
||||
}
|
||||
|
||||
static BOOL_32 IsXor(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isXor;
|
||||
}
|
||||
|
||||
static BOOL_32 IsPrt(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return SwizzleModeTable[swizzleMode].isT;
|
||||
}
|
||||
|
||||
static BOOL_32 IsNonPrtXor(AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return (IsXor(swizzleMode) && (IsPrt(swizzleMode) == FALSE));
|
||||
}
|
||||
|
||||
// Checking resource type
|
||||
static BOOL_32 IsTex1d(AddrResourceType resourceType)
|
||||
{
|
||||
return (resourceType == ADDR_RSRC_TEX_1D);
|
||||
}
|
||||
|
||||
static BOOL_32 IsTex2d(AddrResourceType resourceType)
|
||||
{
|
||||
return (resourceType == ADDR_RSRC_TEX_2D);
|
||||
}
|
||||
|
||||
static BOOL_32 IsTex3d(AddrResourceType resourceType)
|
||||
{
|
||||
return (resourceType == ADDR_RSRC_TEX_3D);
|
||||
}
|
||||
|
||||
static BOOL_32 IsThick(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return (IsTex3d(resourceType) &&
|
||||
(SwizzleModeTable[swizzleMode].isZ || SwizzleModeTable[swizzleMode].isStd));
|
||||
}
|
||||
|
||||
static BOOL_32 IsThin(AddrResourceType resourceType, AddrSwizzleMode swizzleMode)
|
||||
{
|
||||
return (IsTex2d(resourceType) ||
|
||||
(IsTex3d(resourceType) && SwizzleModeTable[swizzleMode].isDisp));
|
||||
}
|
||||
|
||||
UINT_32 GetBlockSizeLog2(AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
UINT_32 blockSizeLog2 = 0;
|
||||
|
||||
if (IsBlock256b(swizzleMode))
|
||||
{
|
||||
blockSizeLog2 = 8;
|
||||
}
|
||||
else if (IsBlock4kb(swizzleMode))
|
||||
{
|
||||
blockSizeLog2 = 12;
|
||||
}
|
||||
else if (IsBlock64kb(swizzleMode))
|
||||
{
|
||||
blockSizeLog2 = 16;
|
||||
}
|
||||
else if (IsBlockVariable(swizzleMode))
|
||||
{
|
||||
blockSizeLog2 = m_blockVarSizeLog2;
|
||||
}
|
||||
else
|
||||
{
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
}
|
||||
|
||||
return blockSizeLog2;
|
||||
}
|
||||
|
||||
UINT_32 GetBlockSize(AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
return (1 << GetBlockSizeLog2(swizzleMode));
|
||||
}
|
||||
|
||||
static UINT_32 GetFmaskBpp(UINT_32 sample, UINT_32 frag)
|
||||
{
|
||||
sample = (sample == 0) ? 1 : sample;
|
||||
frag = (frag == 0) ? sample : frag;
|
||||
|
||||
UINT_32 fmaskBpp = QLog2(frag);
|
||||
|
||||
if (sample > frag)
|
||||
{
|
||||
fmaskBpp++;
|
||||
}
|
||||
|
||||
if (fmaskBpp == 3)
|
||||
{
|
||||
fmaskBpp = 4;
|
||||
}
|
||||
|
||||
fmaskBpp = Max(8u, fmaskBpp * sample);
|
||||
|
||||
return fmaskBpp;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileInfo(
|
||||
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeCmaskInfo(
|
||||
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeDccInfo(
|
||||
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_DCCINFO_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
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileAddrFromCoord(
|
||||
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileCoordFromAddr(
|
||||
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeBlock256Equation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeThinEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeThickEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_NOTSUPPORTED;
|
||||
}
|
||||
|
||||
virtual UINT_32 HwlGetEquationIndex(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return ADDR_INVALID_EQUATION_INDEX;
|
||||
}
|
||||
|
||||
UINT_32 GetEquationIndex(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const
|
||||
{
|
||||
return HwlGetEquationIndex(pIn, pOut);
|
||||
}
|
||||
|
||||
virtual UINT_32 HwlComputeSurfaceBaseAlign(AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
ADDR_NOT_IMPLEMENTED();
|
||||
return 0;
|
||||
}
|
||||
|
||||
UINT_32 ComputeSurfaceBaseAlign(AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
return HwlComputeSurfaceBaseAlign(swizzleMode);
|
||||
}
|
||||
|
||||
ADDR_E_RETURNCODE ComputeBlock256Equation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeThinEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeThickEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceInfoSanityCheck(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceInfoLinear(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceLinearPadding(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
UINT_32* pMipmap0PaddedWidth,
|
||||
UINT_32* pSlice0PaddedHeight,
|
||||
ADDR2_MIP_INFO* pMipInfo = NULL) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceInfoTiled(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoordLinear(
|
||||
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceAddrFromCoordTiled(
|
||||
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceCoordFromAddrLinear(
|
||||
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeSurfaceCoordFromAddrTiled(
|
||||
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
UINT_32 ComputeSurface2DMicroBlockOffset(
|
||||
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const;
|
||||
|
||||
UINT_32 ComputeSurface3DMicroBlockOffset(
|
||||
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,
|
||||
UINT_32* pDepth,
|
||||
UINT_32 bpp,
|
||||
UINT_32 numSamples,
|
||||
AddrResourceType resourceType,
|
||||
AddrSwizzleMode swizzleMode) const;
|
||||
|
||||
ADDR_E_RETURNCODE ComputeBlockDimension(
|
||||
UINT_32* pWidth,
|
||||
UINT_32* pHeight,
|
||||
UINT_32* pDepth,
|
||||
UINT_32 bpp,
|
||||
AddrResourceType resourceType,
|
||||
AddrSwizzleMode swizzleMode) const;
|
||||
|
||||
static UINT_64 ComputePadSize(
|
||||
const Dim3d* pBlkDim,
|
||||
UINT_32 width,
|
||||
UINT_32 height,
|
||||
UINT_32 numSlices,
|
||||
Dim3d* pPadDim)
|
||||
{
|
||||
pPadDim->w = PowTwoAlign(width ,pBlkDim->w);
|
||||
pPadDim->h = PowTwoAlign(height ,pBlkDim->h);
|
||||
pPadDim->d = PowTwoAlign(numSlices, pBlkDim->d);
|
||||
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,
|
||||
UINT_32 pipeBits,
|
||||
UINT_32* pBankX,
|
||||
UINT_32* pPipeX);
|
||||
|
||||
static BOOL_32 Valid3DMipSliceIdConstraint(
|
||||
UINT_32 numSlices,
|
||||
UINT_32 mipId,
|
||||
UINT_32 slice)
|
||||
{
|
||||
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 blockWidth,
|
||||
UINT_32 blockHeight,
|
||||
UINT_32 blockDepth) const;
|
||||
|
||||
static BOOL_32 IsInMipTail(
|
||||
AddrResourceType resourceType,
|
||||
AddrSwizzleMode swizzleMode,
|
||||
Dim3d mipTailDim,
|
||||
UINT_32 width,
|
||||
UINT_32 height,
|
||||
UINT_32 depth)
|
||||
{
|
||||
BOOL_32 inTail = ((width <= mipTailDim.w) &&
|
||||
(height <= mipTailDim.h) &&
|
||||
(IsThin(resourceType, swizzleMode) || (depth <= mipTailDim.d)));
|
||||
|
||||
return inTail;
|
||||
}
|
||||
|
||||
static BOOL_32 IsLocalHeap(AddrResrouceLocation resourceType)
|
||||
{
|
||||
return ((resourceType == ADDR_RSRC_LOC_LOCAL) ||
|
||||
(resourceType == ADDR_RSRC_LOC_INVIS));
|
||||
}
|
||||
|
||||
static BOOL_32 IsInvisibleHeap(AddrResrouceLocation resourceType)
|
||||
{
|
||||
return (resourceType == ADDR_RSRC_LOC_INVIS);
|
||||
}
|
||||
|
||||
static BOOL_32 IsNonlocalHeap(AddrResrouceLocation resourceType)
|
||||
{
|
||||
return ((resourceType == ADDR_RSRC_LOC_USWC) ||
|
||||
(resourceType == ADDR_RSRC_LOC_CACHED));
|
||||
}
|
||||
|
||||
UINT_32 GetPipeLog2ForMetaAddressing(BOOL_32 pipeAligned, AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
UINT_32 numPipeLog2 = pipeAligned ? Min(m_pipesLog2 + m_seLog2, 5u) : 0;
|
||||
|
||||
if (IsXor(swizzleMode))
|
||||
{
|
||||
UINT_32 maxPipeLog2 = GetBlockSizeLog2(swizzleMode) - m_pipeInterleaveLog2;
|
||||
|
||||
numPipeLog2 = Min(numPipeLog2, maxPipeLog2);
|
||||
}
|
||||
|
||||
return numPipeLog2;
|
||||
}
|
||||
|
||||
UINT_32 GetPipeNumForMetaAddressing(BOOL_32 pipeAligned, AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
return (1 << GetPipeLog2ForMetaAddressing(pipeAligned, swizzleMode));
|
||||
}
|
||||
|
||||
VOID VerifyMipLevelInfo(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
|
||||
{
|
||||
#if DEBUG
|
||||
if (pIn->numMipLevels > 1)
|
||||
{
|
||||
UINT_32 actualMipLevels = 1;
|
||||
switch (pIn->resourceType)
|
||||
{
|
||||
case ADDR_RSRC_TEX_3D:
|
||||
// Fall through to share 2D case
|
||||
actualMipLevels = Max(actualMipLevels, Log2NonPow2(pIn->numSlices) + 1);
|
||||
case ADDR_RSRC_TEX_2D:
|
||||
// Fall through to share 1D case
|
||||
actualMipLevels = Max(actualMipLevels, Log2NonPow2(pIn->height) + 1);
|
||||
case ADDR_RSRC_TEX_1D:
|
||||
// Base 1D case
|
||||
actualMipLevels = Max(actualMipLevels, Log2NonPow2(pIn->width) + 1);
|
||||
break;
|
||||
default:
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
}
|
||||
// Client pass wrong number of MipLevels to addrlib and result will be bad.
|
||||
// Not sure if we should fail this calling instead of putting an assertion here.
|
||||
ADDR_ASSERT(actualMipLevels >= pIn->numMipLevels);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
ADDR_E_RETURNCODE ApplyCustomerPipeBankXor(
|
||||
AddrSwizzleMode swizzleMode,
|
||||
UINT_32 pipeBankXor,
|
||||
UINT_32 bankBits,
|
||||
UINT_32 pipeBits,
|
||||
UINT_32* pBlockOffset) const
|
||||
{
|
||||
ADDR_E_RETURNCODE returnCode = ADDR_OK;
|
||||
|
||||
if (IsXor(swizzleMode))
|
||||
{
|
||||
// Apply driver set bankPipeXor
|
||||
UINT_32 bankX = 0;
|
||||
UINT_32 pipeX = 0;
|
||||
returnCode = ExtractPipeBankXor(pipeBankXor, bankBits, pipeBits, &bankX, &pipeX);
|
||||
*pBlockOffset ^= (pipeX << m_pipeInterleaveLog2);
|
||||
*pBlockOffset ^= (bankX << (m_pipeInterleaveLog2 + pipeBits));
|
||||
}
|
||||
|
||||
return returnCode;
|
||||
}
|
||||
|
||||
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* pPitch,
|
||||
UINT_32* pHeight) 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_banksLog2; ///< Number of bank Log2
|
||||
UINT_32 m_pipesLog2; ///< Number of pipe per shader engine Log2
|
||||
UINT_32 m_seLog2; ///< Number of shader engine Log2
|
||||
UINT_32 m_rbPerSeLog2; ///< Number of render backend per shader engine Log2
|
||||
UINT_32 m_maxCompFragLog2; ///< Number of max compressed fragment Log2
|
||||
|
||||
UINT_32 m_pipeInterleaveLog2; ///< Log2 of pipe interleave bytes
|
||||
|
||||
UINT_32 m_blockVarSizeLog2; ///< Log2 of block var size
|
||||
|
||||
private:
|
||||
// Disallow the copy constructor
|
||||
Lib(const Lib& a);
|
||||
|
||||
// Disallow the assignment operator
|
||||
Lib& operator=(const Lib& a);
|
||||
};
|
||||
|
||||
} // V2
|
||||
} // Addr
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,707 @@
|
|||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
// Coordinate class implementation
|
||||
#include "addrcommon.h"
|
||||
#include "coord.h"
|
||||
|
||||
Coordinate::Coordinate()
|
||||
{
|
||||
dim = 'x';
|
||||
ord = 0;
|
||||
}
|
||||
|
||||
Coordinate::Coordinate(INT_8 c, UINT_32 n)
|
||||
{
|
||||
set(c,n);
|
||||
}
|
||||
|
||||
VOID Coordinate::set(INT_8 c, UINT_32 n)
|
||||
{
|
||||
dim = c;
|
||||
ord = static_cast<INT_8>(n);
|
||||
}
|
||||
|
||||
UINT_32 Coordinate::ison(UINT_32 x, UINT_32 y, UINT_32 z, UINT_32 s, UINT_32 m)
|
||||
{
|
||||
UINT_32 bit = 1 << (UINT_32)ord;
|
||||
UINT_32 out = 0;
|
||||
|
||||
switch (dim)
|
||||
{
|
||||
case 'm': out = m & bit; break;
|
||||
case 's': out = s & bit; break;
|
||||
case 'x': out = x & bit; break;
|
||||
case 'y': out = y & bit; break;
|
||||
case 'z': out = z & bit; break;
|
||||
}
|
||||
return (out != 0) ? 1 : 0;
|
||||
}
|
||||
|
||||
INT_8 Coordinate::getdim()
|
||||
{
|
||||
return dim;
|
||||
}
|
||||
|
||||
INT_8 Coordinate::getord()
|
||||
{
|
||||
return ord;
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator==(const Coordinate& b)
|
||||
{
|
||||
return (dim == b.dim) && (ord == b.ord);
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator<(const Coordinate& b)
|
||||
{
|
||||
BOOL_32 ret;
|
||||
|
||||
if (dim == b.dim)
|
||||
{
|
||||
ret = ord < b.ord;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dim == 's' || b.dim == 'm')
|
||||
{
|
||||
ret = TRUE;
|
||||
}
|
||||
else if (b.dim == 's' || dim == 'm')
|
||||
{
|
||||
ret = FALSE;
|
||||
}
|
||||
else if (ord == b.ord)
|
||||
{
|
||||
ret = dim < b.dim;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = ord < b.ord;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator>(const Coordinate& b)
|
||||
{
|
||||
BOOL_32 lt = *this < b;
|
||||
BOOL_32 eq = *this == b;
|
||||
return !lt && !eq;
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator<=(const Coordinate& b)
|
||||
{
|
||||
return (*this < b) || (*this == b);
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator>=(const Coordinate& b)
|
||||
{
|
||||
return !(*this < b);
|
||||
}
|
||||
|
||||
BOOL_32 Coordinate::operator!=(const Coordinate& b)
|
||||
{
|
||||
return !(*this == b);
|
||||
}
|
||||
|
||||
Coordinate& Coordinate::operator++(INT_32)
|
||||
{
|
||||
ord++;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// CoordTerm
|
||||
|
||||
CoordTerm::CoordTerm()
|
||||
{
|
||||
num_coords = 0;
|
||||
}
|
||||
|
||||
VOID CoordTerm::Clear()
|
||||
{
|
||||
num_coords = 0;
|
||||
}
|
||||
|
||||
VOID CoordTerm::add(Coordinate& co)
|
||||
{
|
||||
// This function adds a coordinate INT_32o the list
|
||||
// It will prevent the same coordinate from appearing,
|
||||
// and will keep the list ordered from smallest to largest
|
||||
UINT_32 i;
|
||||
|
||||
for (i = 0; i < num_coords; i++)
|
||||
{
|
||||
if (m_coord[i] == co)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (m_coord[i] > co)
|
||||
{
|
||||
for (UINT_32 j = num_coords; j > i; j--)
|
||||
{
|
||||
m_coord[j] = m_coord[j - 1];
|
||||
}
|
||||
m_coord[i] = co;
|
||||
num_coords++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i == num_coords)
|
||||
{
|
||||
m_coord[num_coords] = co;
|
||||
num_coords++;
|
||||
}
|
||||
}
|
||||
|
||||
VOID CoordTerm::add(CoordTerm& cl)
|
||||
{
|
||||
for (UINT_32 i = 0; i < cl.num_coords; i++)
|
||||
{
|
||||
add(cl.m_coord[i]);
|
||||
}
|
||||
}
|
||||
|
||||
BOOL_32 CoordTerm::remove(Coordinate& co)
|
||||
{
|
||||
BOOL_32 remove = FALSE;
|
||||
for (UINT_32 i = 0; i < num_coords; i++)
|
||||
{
|
||||
if (m_coord[i] == co)
|
||||
{
|
||||
remove = TRUE;
|
||||
num_coords--;
|
||||
}
|
||||
|
||||
if (remove)
|
||||
{
|
||||
m_coord[i] = m_coord[i + 1];
|
||||
}
|
||||
}
|
||||
return remove;
|
||||
}
|
||||
|
||||
BOOL_32 CoordTerm::Exists(Coordinate& co)
|
||||
{
|
||||
BOOL_32 exists = FALSE;
|
||||
for (UINT_32 i = 0; i < num_coords; i++)
|
||||
{
|
||||
if (m_coord[i] == co)
|
||||
{
|
||||
exists = TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return exists;
|
||||
}
|
||||
|
||||
VOID CoordTerm::copyto(CoordTerm& cl)
|
||||
{
|
||||
cl.num_coords = num_coords;
|
||||
for (UINT_32 i = 0; i < num_coords; i++)
|
||||
{
|
||||
cl.m_coord[i] = m_coord[i];
|
||||
}
|
||||
}
|
||||
|
||||
UINT_32 CoordTerm::getsize()
|
||||
{
|
||||
return num_coords;
|
||||
}
|
||||
|
||||
UINT_32 CoordTerm::getxor(UINT_32 x, UINT_32 y, UINT_32 z, UINT_32 s, UINT_32 m)
|
||||
{
|
||||
UINT_32 out = 0;
|
||||
for (UINT_32 i = 0; i < num_coords; i++)
|
||||
{
|
||||
out = out ^ m_coord[i].ison(x, y, z, s, m);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
VOID CoordTerm::getsmallest(Coordinate& co)
|
||||
{
|
||||
co = m_coord[0];
|
||||
}
|
||||
|
||||
UINT_32 CoordTerm::Filter(INT_8 f, Coordinate& co, UINT_32 start, INT_8 axis)
|
||||
{
|
||||
for (UINT_32 i = start; i < num_coords;)
|
||||
{
|
||||
if (((f == '<' && m_coord[i] < co) ||
|
||||
(f == '>' && m_coord[i] > co) ||
|
||||
(f == '=' && m_coord[i] == co)) &&
|
||||
(axis == '\0' || axis == m_coord[i].getdim()))
|
||||
{
|
||||
for (UINT_32 j = i; j < num_coords - 1; j++)
|
||||
{
|
||||
m_coord[j] = m_coord[j + 1];
|
||||
}
|
||||
num_coords--;
|
||||
}
|
||||
else
|
||||
{
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return num_coords;
|
||||
}
|
||||
|
||||
Coordinate& CoordTerm::operator[](UINT_32 i)
|
||||
{
|
||||
return m_coord[i];
|
||||
}
|
||||
|
||||
BOOL_32 CoordTerm::operator==(const CoordTerm& b)
|
||||
{
|
||||
BOOL_32 ret = TRUE;
|
||||
|
||||
if (num_coords != b.num_coords)
|
||||
{
|
||||
ret = FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (UINT_32 i = 0; i < num_coords; i++)
|
||||
{
|
||||
// Note: the lists will always be in order, so we can compare the two lists at time
|
||||
if (m_coord[i] != b.m_coord[i])
|
||||
{
|
||||
ret = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
BOOL_32 CoordTerm::operator!=(const CoordTerm& b)
|
||||
{
|
||||
return !(*this == b);
|
||||
}
|
||||
|
||||
BOOL_32 CoordTerm::exceedRange(UINT_32 xRange, UINT_32 yRange, UINT_32 zRange, UINT_32 sRange)
|
||||
{
|
||||
BOOL_32 exceed = FALSE;
|
||||
for (UINT_32 i = 0; (i < num_coords) && (exceed == FALSE); i++)
|
||||
{
|
||||
UINT_32 subject;
|
||||
switch (m_coord[i].getdim())
|
||||
{
|
||||
case 'x':
|
||||
subject = xRange;
|
||||
break;
|
||||
case 'y':
|
||||
subject = yRange;
|
||||
break;
|
||||
case 'z':
|
||||
subject = zRange;
|
||||
break;
|
||||
case 's':
|
||||
subject = sRange;
|
||||
break;
|
||||
case 'm':
|
||||
subject = 0;
|
||||
break;
|
||||
default:
|
||||
// Invalid input!
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
subject = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
exceed = ((1u << m_coord[i].getord()) <= subject);
|
||||
}
|
||||
|
||||
return exceed;
|
||||
}
|
||||
|
||||
// coordeq
|
||||
CoordEq::CoordEq()
|
||||
{
|
||||
m_numBits = 0;
|
||||
}
|
||||
|
||||
VOID CoordEq::remove(Coordinate& co)
|
||||
{
|
||||
for (UINT_32 i = 0; i < m_numBits; i++)
|
||||
{
|
||||
m_eq[i].remove(co);
|
||||
}
|
||||
}
|
||||
|
||||
BOOL_32 CoordEq::Exists(Coordinate& co)
|
||||
{
|
||||
BOOL_32 exists = FALSE;
|
||||
|
||||
for (UINT_32 i = 0; i < m_numBits; i++)
|
||||
{
|
||||
if (m_eq[i].Exists(co))
|
||||
{
|
||||
exists = TRUE;
|
||||
}
|
||||
}
|
||||
return exists;
|
||||
}
|
||||
|
||||
VOID CoordEq::resize(UINT_32 n)
|
||||
{
|
||||
if (n > m_numBits)
|
||||
{
|
||||
for (UINT_32 i = m_numBits; i < n; i++)
|
||||
{
|
||||
m_eq[i].Clear();
|
||||
}
|
||||
}
|
||||
m_numBits = n;
|
||||
}
|
||||
|
||||
UINT_32 CoordEq::getsize()
|
||||
{
|
||||
return m_numBits;
|
||||
}
|
||||
|
||||
UINT_64 CoordEq::solve(UINT_32 x, UINT_32 y, UINT_32 z, UINT_32 s, UINT_32 m)
|
||||
{
|
||||
UINT_64 out = 0;
|
||||
for (UINT_32 i = 0; i < m_numBits; i++)
|
||||
{
|
||||
if (m_eq[i].getxor(x, y, z, s, m) != 0)
|
||||
{
|
||||
out |= (1ULL << i);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
VOID CoordEq::solveAddr(
|
||||
UINT_64 addr, UINT_32 sliceInM,
|
||||
UINT_32& x, UINT_32& y, UINT_32& z, UINT_32& s, UINT_32& m)
|
||||
{
|
||||
UINT_32 xBitsValid = 0;
|
||||
UINT_32 yBitsValid = 0;
|
||||
UINT_32 zBitsValid = 0;
|
||||
UINT_32 sBitsValid = 0;
|
||||
UINT_32 mBitsValid = 0;
|
||||
|
||||
CoordEq temp = *this;
|
||||
|
||||
x = y = z = s = m = 0;
|
||||
|
||||
UINT_32 bitsLeft = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < temp.m_numBits; i++)
|
||||
{
|
||||
UINT_32 termSize = temp.m_eq[i].getsize();
|
||||
|
||||
if (termSize == 1)
|
||||
{
|
||||
INT_8 bit = (addr >> i) & 1;
|
||||
INT_8 dim = temp.m_eq[i][0].getdim();
|
||||
INT_8 ord = temp.m_eq[i][0].getord();
|
||||
|
||||
ADDR_ASSERT((ord < 32) || (bit == 0));
|
||||
|
||||
switch (dim)
|
||||
{
|
||||
case 'x':
|
||||
xBitsValid |= (1 << ord);
|
||||
x |= (bit << ord);
|
||||
break;
|
||||
case 'y':
|
||||
yBitsValid |= (1 << ord);
|
||||
y |= (bit << ord);
|
||||
break;
|
||||
case 'z':
|
||||
zBitsValid |= (1 << ord);
|
||||
z |= (bit << ord);
|
||||
break;
|
||||
case 's':
|
||||
sBitsValid |= (1 << ord);
|
||||
s |= (bit << ord);
|
||||
break;
|
||||
case 'm':
|
||||
mBitsValid |= (1 << ord);
|
||||
m |= (bit << ord);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
temp.m_eq[i].Clear();
|
||||
}
|
||||
else if (termSize > 1)
|
||||
{
|
||||
bitsLeft++;
|
||||
}
|
||||
}
|
||||
|
||||
if (bitsLeft > 0)
|
||||
{
|
||||
if (sliceInM != 0)
|
||||
{
|
||||
z = m / sliceInM;
|
||||
zBitsValid = 0xffffffff;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
bitsLeft = 0;
|
||||
|
||||
for (UINT_32 i = 0; i < temp.m_numBits; i++)
|
||||
{
|
||||
UINT_32 termSize = temp.m_eq[i].getsize();
|
||||
|
||||
if (termSize == 1)
|
||||
{
|
||||
INT_8 bit = (addr >> i) & 1;
|
||||
INT_8 dim = temp.m_eq[i][0].getdim();
|
||||
INT_8 ord = temp.m_eq[i][0].getord();
|
||||
|
||||
ADDR_ASSERT((ord < 32) || (bit == 0));
|
||||
|
||||
switch (dim)
|
||||
{
|
||||
case 'x':
|
||||
xBitsValid |= (1 << ord);
|
||||
x |= (bit << ord);
|
||||
break;
|
||||
case 'y':
|
||||
yBitsValid |= (1 << ord);
|
||||
y |= (bit << ord);
|
||||
break;
|
||||
case 'z':
|
||||
zBitsValid |= (1 << ord);
|
||||
z |= (bit << ord);
|
||||
break;
|
||||
case 's':
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
case 'm':
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
temp.m_eq[i].Clear();
|
||||
}
|
||||
else if (termSize > 1)
|
||||
{
|
||||
CoordTerm tmpTerm = temp.m_eq[i];
|
||||
|
||||
for (UINT_32 j = 0; j < termSize; j++)
|
||||
{
|
||||
INT_8 dim = temp.m_eq[i][j].getdim();
|
||||
INT_8 ord = temp.m_eq[i][j].getord();
|
||||
|
||||
switch (dim)
|
||||
{
|
||||
case 'x':
|
||||
if (xBitsValid & (1 << ord))
|
||||
{
|
||||
UINT_32 v = (((x >> ord) & 1) << i);
|
||||
addr ^= static_cast<UINT_64>(v);
|
||||
tmpTerm.remove(temp.m_eq[i][j]);
|
||||
}
|
||||
break;
|
||||
case 'y':
|
||||
if (yBitsValid & (1 << ord))
|
||||
{
|
||||
UINT_32 v = (((y >> ord) & 1) << i);
|
||||
addr ^= static_cast<UINT_64>(v);
|
||||
tmpTerm.remove(temp.m_eq[i][j]);
|
||||
}
|
||||
break;
|
||||
case 'z':
|
||||
if (zBitsValid & (1 << ord))
|
||||
{
|
||||
UINT_32 v = (((z >> ord) & 1) << i);
|
||||
addr ^= static_cast<UINT_64>(v);
|
||||
tmpTerm.remove(temp.m_eq[i][j]);
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
case 'm':
|
||||
ADDR_ASSERT_ALWAYS();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
temp.m_eq[i] = tmpTerm;
|
||||
|
||||
bitsLeft++;
|
||||
}
|
||||
}
|
||||
} while (bitsLeft > 0);
|
||||
}
|
||||
}
|
||||
|
||||
VOID CoordEq::copy(CoordEq& o, UINT_32 start, UINT_32 num)
|
||||
{
|
||||
o.m_numBits = (num == 0xFFFFFFFF) ? m_numBits : num;
|
||||
for (UINT_32 i = 0; i < o.m_numBits; i++)
|
||||
{
|
||||
m_eq[start + i].copyto(o.m_eq[i]);
|
||||
}
|
||||
}
|
||||
|
||||
VOID CoordEq::reverse(UINT_32 start, UINT_32 num)
|
||||
{
|
||||
UINT_32 n = (num == 0xFFFFFFFF) ? m_numBits : num;
|
||||
|
||||
for (UINT_32 i = 0; i < n / 2; i++)
|
||||
{
|
||||
CoordTerm temp;
|
||||
m_eq[start + i].copyto(temp);
|
||||
m_eq[start + n - 1 - i].copyto(m_eq[start + i]);
|
||||
temp.copyto(m_eq[start + n - 1 - i]);
|
||||
}
|
||||
}
|
||||
|
||||
VOID CoordEq::xorin(CoordEq& x, UINT_32 start)
|
||||
{
|
||||
UINT_32 n = ((m_numBits - start) < x.m_numBits) ? (m_numBits - start) : x.m_numBits;
|
||||
for (UINT_32 i = 0; i < n; i++)
|
||||
{
|
||||
m_eq[start + i].add(x.m_eq[i]);
|
||||
}
|
||||
}
|
||||
|
||||
UINT_32 CoordEq::Filter(INT_8 f, Coordinate& co, UINT_32 start, INT_8 axis)
|
||||
{
|
||||
for (UINT_32 i = start; i < m_numBits;)
|
||||
{
|
||||
UINT_32 m = m_eq[i].Filter(f, co, 0, axis);
|
||||
if (m == 0)
|
||||
{
|
||||
for (UINT_32 j = i; j < m_numBits - 1; j++)
|
||||
{
|
||||
m_eq[j] = m_eq[j + 1];
|
||||
}
|
||||
m_numBits--;
|
||||
}
|
||||
else
|
||||
{
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return m_numBits;
|
||||
}
|
||||
|
||||
VOID CoordEq::shift(INT_32 amount, INT_32 start)
|
||||
{
|
||||
if (amount != 0)
|
||||
{
|
||||
INT_32 numBits = static_cast<INT_32>(m_numBits);
|
||||
amount = -amount;
|
||||
INT_32 inc = (amount < 0) ? -1 : 1;
|
||||
INT_32 i = (amount < 0) ? numBits - 1 : start;
|
||||
INT_32 end = (amount < 0) ? start - 1 : numBits;
|
||||
for (; (inc > 0) ? i < end : i > end; i += inc)
|
||||
{
|
||||
if ((i + amount < start) || (i + amount >= numBits))
|
||||
{
|
||||
m_eq[i].Clear();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_eq[i + amount].copyto(m_eq[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CoordTerm& CoordEq::operator[](UINT_32 i)
|
||||
{
|
||||
return m_eq[i];
|
||||
}
|
||||
|
||||
VOID CoordEq::mort2d(Coordinate& c0, Coordinate& c1, UINT_32 start, UINT_32 end)
|
||||
{
|
||||
if (end == 0)
|
||||
{
|
||||
ADDR_ASSERT(m_numBits > 0);
|
||||
end = m_numBits - 1;
|
||||
}
|
||||
for (UINT_32 i = start; i <= end; i++)
|
||||
{
|
||||
UINT_32 select = (i - start) % 2;
|
||||
Coordinate& c = (select == 0) ? c0 : c1;
|
||||
m_eq[i].add(c);
|
||||
c++;
|
||||
}
|
||||
}
|
||||
|
||||
VOID CoordEq::mort3d(Coordinate& c0, Coordinate& c1, Coordinate& c2, UINT_32 start, UINT_32 end)
|
||||
{
|
||||
if (end == 0)
|
||||
{
|
||||
ADDR_ASSERT(m_numBits > 0);
|
||||
end = m_numBits - 1;
|
||||
}
|
||||
for (UINT_32 i = start; i <= end; i++)
|
||||
{
|
||||
UINT_32 select = (i - start) % 3;
|
||||
Coordinate& c = (select == 0) ? c0 : ((select == 1) ? c1 : c2);
|
||||
m_eq[i].add(c);
|
||||
c++;
|
||||
}
|
||||
}
|
||||
|
||||
BOOL_32 CoordEq::operator==(const CoordEq& b)
|
||||
{
|
||||
BOOL_32 ret = TRUE;
|
||||
|
||||
if (m_numBits != b.m_numBits)
|
||||
{
|
||||
ret = FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (UINT_32 i = 0; i < m_numBits; i++)
|
||||
{
|
||||
if (m_eq[i] != b.m_eq[i])
|
||||
{
|
||||
ret = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
BOOL_32 CoordEq::operator!=(const CoordEq& b)
|
||||
{
|
||||
return !(*this == b);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
// Class used to define a coordinate bit
|
||||
|
||||
#ifndef __COORD_H
|
||||
#define __COORD_H
|
||||
|
||||
class Coordinate
|
||||
{
|
||||
public:
|
||||
Coordinate();
|
||||
Coordinate(INT_8 c, UINT_32 n);
|
||||
|
||||
VOID set(INT_8 c, UINT_32 n);
|
||||
UINT_32 ison(UINT_32 x, UINT_32 y, UINT_32 z = 0, UINT_32 s = 0, UINT_32 m = 0);
|
||||
INT_8 getdim();
|
||||
INT_8 getord();
|
||||
|
||||
BOOL_32 operator==(const Coordinate& b);
|
||||
BOOL_32 operator<(const Coordinate& b);
|
||||
BOOL_32 operator>(const Coordinate& b);
|
||||
BOOL_32 operator<=(const Coordinate& b);
|
||||
BOOL_32 operator>=(const Coordinate& b);
|
||||
BOOL_32 operator!=(const Coordinate& b);
|
||||
Coordinate& operator++(INT_32);
|
||||
|
||||
private:
|
||||
INT_8 dim;
|
||||
INT_8 ord;
|
||||
};
|
||||
|
||||
class CoordTerm
|
||||
{
|
||||
public:
|
||||
CoordTerm();
|
||||
VOID Clear();
|
||||
VOID add(Coordinate& co);
|
||||
VOID add(CoordTerm& cl);
|
||||
BOOL_32 remove(Coordinate& co);
|
||||
BOOL_32 Exists(Coordinate& co);
|
||||
VOID copyto(CoordTerm& cl);
|
||||
UINT_32 getsize();
|
||||
UINT_32 getxor(UINT_32 x, UINT_32 y, UINT_32 z = 0, UINT_32 s = 0, UINT_32 m = 0);
|
||||
|
||||
VOID getsmallest(Coordinate& co);
|
||||
UINT_32 Filter(INT_8 f, Coordinate& co, UINT_32 start = 0, INT_8 axis = '\0');
|
||||
Coordinate& operator[](UINT_32 i);
|
||||
BOOL_32 operator==(const CoordTerm& b);
|
||||
BOOL_32 operator!=(const CoordTerm& b);
|
||||
BOOL_32 exceedRange(UINT_32 xRange, UINT_32 yRange = 0, UINT_32 zRange = 0, UINT_32 sRange = 0);
|
||||
|
||||
private:
|
||||
static const UINT_32 MaxCoords = 8;
|
||||
UINT_32 num_coords;
|
||||
Coordinate m_coord[MaxCoords];
|
||||
};
|
||||
|
||||
class CoordEq
|
||||
{
|
||||
public:
|
||||
CoordEq();
|
||||
VOID remove(Coordinate& co);
|
||||
BOOL_32 Exists(Coordinate& co);
|
||||
VOID resize(UINT_32 n);
|
||||
UINT_32 getsize();
|
||||
virtual UINT_64 solve(UINT_32 x, UINT_32 y, UINT_32 z = 0, UINT_32 s = 0, UINT_32 m = 0);
|
||||
virtual VOID solveAddr(UINT_64 addr, UINT_32 sliceInM,
|
||||
UINT_32& x, UINT_32& y, UINT_32& z, UINT_32& s, UINT_32& m);
|
||||
|
||||
VOID copy(CoordEq& o, UINT_32 start = 0, UINT_32 num = 0xFFFFFFFF);
|
||||
VOID reverse(UINT_32 start = 0, UINT_32 num = 0xFFFFFFFF);
|
||||
VOID xorin(CoordEq& x, UINT_32 start = 0);
|
||||
UINT_32 Filter(INT_8 f, Coordinate& co, UINT_32 start = 0, INT_8 axis = '\0');
|
||||
VOID shift(INT_32 amount, INT_32 start = 0);
|
||||
virtual CoordTerm& operator[](UINT_32 i);
|
||||
VOID mort2d(Coordinate& c0, Coordinate& c1, UINT_32 start = 0, UINT_32 end = 0);
|
||||
VOID mort3d(Coordinate& c0, Coordinate& c1, Coordinate& c2, UINT_32 start = 0, UINT_32 end = 0);
|
||||
|
||||
BOOL_32 operator==(const CoordEq& b);
|
||||
BOOL_32 operator!=(const CoordEq& b);
|
||||
|
||||
private:
|
||||
static const UINT_32 MaxEqBits = 64;
|
||||
UINT_32 m_numBits;
|
||||
|
||||
CoordTerm m_eq[MaxEqBits];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,249 @@
|
|||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @file gfx9addrlib.h
|
||||
* @brief Contgfx9ns the Gfx9Lib class definition.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __GFX9_ADDR_LIB_H__
|
||||
#define __GFX9_ADDR_LIB_H__
|
||||
|
||||
#include "addrlib2.h"
|
||||
#include "coord.h"
|
||||
|
||||
namespace Addr
|
||||
{
|
||||
namespace V2
|
||||
{
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief GFX9 specific settings structure.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
struct Gfx9ChipSettings
|
||||
{
|
||||
struct
|
||||
{
|
||||
// Asic/Generation name
|
||||
UINT_32 isArcticIsland : 1;
|
||||
UINT_32 isVega10 : 1;
|
||||
UINT_32 reserved0 : 30;
|
||||
|
||||
// Display engine IP version name
|
||||
UINT_32 isDce12 : 1;
|
||||
UINT_32 reserved1 : 31;
|
||||
|
||||
// Misc configuration bits
|
||||
UINT_32 metaBaseAlignFix : 1;
|
||||
UINT_32 reserved2 : 31;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief GFX9 data surface type.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
enum Gfx9DataType
|
||||
{
|
||||
Gfx9DataColor,
|
||||
Gfx9DataDepthStencil,
|
||||
Gfx9DataFmask
|
||||
};
|
||||
|
||||
/**
|
||||
****************************************************************************************************
|
||||
* @brief This class is the GFX9 specific address library
|
||||
* function set.
|
||||
****************************************************************************************************
|
||||
*/
|
||||
class Gfx9Lib : public Lib
|
||||
{
|
||||
public:
|
||||
/// Creates Gfx9Lib object
|
||||
static Addr::Lib* CreateObj(const Client* pClient)
|
||||
{
|
||||
VOID* pMem = Object::ClientAlloc(sizeof(Gfx9Lib), pClient);
|
||||
return (pMem != NULL) ? new (pMem) Gfx9Lib(pClient) : NULL;
|
||||
}
|
||||
|
||||
protected:
|
||||
Gfx9Lib(const Client* pClient);
|
||||
virtual ~Gfx9Lib();
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileInfo(
|
||||
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeCmaskInfo(
|
||||
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeDccInfo(
|
||||
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeCmaskAddrFromCoord(
|
||||
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileAddrFromCoord(
|
||||
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeHtileCoordFromAddr(
|
||||
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
|
||||
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) const;
|
||||
|
||||
virtual UINT_32 HwlGetEquationIndex(
|
||||
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
|
||||
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeBlock256Equation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeThinEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
virtual ADDR_E_RETURNCODE HwlComputeThickEquation(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2,
|
||||
ADDR_EQUATION* pEquation) const;
|
||||
|
||||
// Get equation table pointer and number of equations
|
||||
virtual UINT_32 HwlGetEquationTableInfo(const ADDR_EQUATION** ppEquationTable) const
|
||||
{
|
||||
*ppEquationTable = m_equationTable;
|
||||
|
||||
return m_numEquations;
|
||||
}
|
||||
|
||||
virtual BOOL_32 IsEquationSupported(
|
||||
AddrResourceType rsrcType,
|
||||
AddrSwizzleMode swMode,
|
||||
UINT_32 elementBytesLog2) const;
|
||||
|
||||
virtual UINT_32 HwlComputeSurfaceBaseAlign(AddrSwizzleMode swizzleMode) const
|
||||
{
|
||||
UINT_32 baseAlign;
|
||||
|
||||
if (IsXor(swizzleMode))
|
||||
{
|
||||
if (m_settings.isVega10)
|
||||
{
|
||||
baseAlign = GetBlockSize(swizzleMode);
|
||||
}
|
||||
else
|
||||
{
|
||||
UINT_32 blockSizeLog2 = GetBlockSizeLog2(swizzleMode);
|
||||
UINT_32 pipeBits = GetPipeXorBits(blockSizeLog2);
|
||||
UINT_32 bankBits = GetBankXorBits(blockSizeLog2);
|
||||
baseAlign = 1 << (Min(blockSizeLog2, m_pipeInterleaveLog2 + pipeBits+ bankBits));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
baseAlign = 256;
|
||||
}
|
||||
|
||||
return baseAlign;
|
||||
}
|
||||
|
||||
virtual BOOL_32 HwlIsValidDisplaySwizzleMode(const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
|
||||
|
||||
virtual BOOL_32 HwlIsDce12() const { return m_settings.isDce12; }
|
||||
|
||||
// Initialize equation table
|
||||
VOID InitEquationTable();
|
||||
|
||||
// Max number of swizzle mode supported for equation
|
||||
static const UINT_32 MaxSwMode = 32;
|
||||
// Max number of resource type (2D/3D) supported for equation
|
||||
static const UINT_32 MaxRsrcType = 2;
|
||||
// Max number of bpp (8bpp/16bpp/32bpp/64bpp/128bpp)
|
||||
static const UINT_32 MaxElementBytesLog2 = 5;
|
||||
// Almost all swizzle mode + resource type support equation
|
||||
static const UINT_32 EquationTableSize = MaxElementBytesLog2 * MaxSwMode * MaxRsrcType;
|
||||
// Equation table
|
||||
ADDR_EQUATION m_equationTable[EquationTableSize];
|
||||
|
||||
// Number of equation entries in the table
|
||||
UINT_32 m_numEquations;
|
||||
// Equation lookup table according to bpp and tile index
|
||||
UINT_32 m_equationLookupTable[MaxRsrcType][MaxSwMode][MaxElementBytesLog2];
|
||||
|
||||
private:
|
||||
virtual ADDR_E_RETURNCODE HwlGetMaxAlignments(
|
||||
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) const;
|
||||
|
||||
virtual BOOL_32 HwlInitGlobalParams(
|
||||
const ADDR_CREATE_INPUT* pCreateIn);
|
||||
|
||||
static VOID GetRbEquation(CoordEq* pRbEq, UINT_32 rbPerSeLog2, UINT_32 seLog2);
|
||||
|
||||
VOID GetDataEquation(CoordEq* pDataEq, Gfx9DataType dataSurfaceType,
|
||||
AddrSwizzleMode swizzleMode, AddrResourceType resourceType,
|
||||
UINT_32 elementBytesLog2, UINT_32 numSamplesLog2) const;
|
||||
|
||||
VOID GetPipeEquation(CoordEq* pPipeEq, CoordEq* pDataEq,
|
||||
UINT_32 pipeInterleaveLog2, UINT_32 numPipesLog2,
|
||||
UINT_32 numSamplesLog2, Gfx9DataType dataSurfaceType,
|
||||
AddrSwizzleMode swizzleMode, AddrResourceType resourceType) const;
|
||||
|
||||
VOID GetMetaEquation(CoordEq* pMetaEq, UINT_32 maxMip,
|
||||
UINT_32 elementBytesLog2, UINT_32 numSamplesLog2,
|
||||
ADDR2_META_FLAGS metaFlag, Gfx9DataType dataSurfaceType,
|
||||
AddrSwizzleMode swizzleMode, AddrResourceType resourceType,
|
||||
UINT_32 metaBlkWidthLog2, UINT_32 metaBlkHeightLog2,
|
||||
UINT_32 metaBlkDepthLog2, UINT_32 compBlkWidthLog2,
|
||||
UINT_32 compBlkHeightLog2, UINT_32 compBlkDepthLog2) const;
|
||||
|
||||
virtual ChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision);
|
||||
|
||||
VOID GetMetaMipInfo(UINT_32 numMipLevels, Dim3d* pMetaBlkDim,
|
||||
BOOL_32 dataThick, ADDR2_META_MIP_INFO* pInfo,
|
||||
UINT_32 mip0Width, UINT_32 mip0Height, UINT_32 mip0Depth,
|
||||
UINT_32* pNumMetaBlkX, UINT_32* pNumMetaBlkY, UINT_32* pNumMetaBlkZ) const;
|
||||
|
||||
Gfx9ChipSettings m_settings;
|
||||
};
|
||||
|
||||
} // V2
|
||||
} // Addr
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,142 @@
|
|||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
// This class RB_MAP contains the top-level calculation functions which are used to generate rb id map based rb id equations
|
||||
|
||||
#ifndef __RB_MAP_H
|
||||
#define __RB_MAP_H
|
||||
|
||||
#include "coord.h"
|
||||
|
||||
class RB_MAP
|
||||
{
|
||||
public:
|
||||
|
||||
enum MAX_VALUES {
|
||||
MAX_SES_LOG2 = 3,
|
||||
MAX_RBS_LOG2 = 2
|
||||
};
|
||||
|
||||
enum COMPRESSED_DATABLOCKS_IN_METABLOCK_PER_RB_LOG2 {
|
||||
COMPRESSED_DATABLOCKS_IN_METABLOCK_PER_RB_LOG2_2D = 10,
|
||||
COMPRESSED_DATABLOCKS_IN_METABLOCK_PER_RB_LOG2_3D = 18
|
||||
};
|
||||
|
||||
RB_MAP(void);
|
||||
|
||||
void Get_Comp_Block_Screen_Space( CoordEq& addr, int bytes_log2, int* w, int* h, int* d = NULL);
|
||||
|
||||
void Get_Meta_Block_Screen_Space( int num_comp_blocks_log2, bool is_thick, bool x_biased,
|
||||
int comp_block_width_log2, int comp_block_height_log2, int comp_block_depth_log2,
|
||||
int& meta_block_width_log2, int& meta_block_height_log2, int& meta_block_depth_log2 );
|
||||
void cap_pipe( int xmode, bool is_thick, int& num_ses_log2, int bpp_log2, int num_samples_log2, int pipe_interleave_log2,
|
||||
int& block_size_log2, int& num_pipes_log2 );
|
||||
|
||||
void Get_Data_Offset_Equation( CoordEq& data_eq, int data_type, int bpp_log2, int num_samples_log2, int block_size_log2 );
|
||||
|
||||
void Get_RB_Equation( CoordEq& rb_equation, int num_ses_log2, int num_rbs_log2 );
|
||||
|
||||
void Get_Pipe_Equation( CoordEq& pipe_equation, CoordEq& addr,
|
||||
int pipe_interleave_log2,
|
||||
int num_pipes_log2,
|
||||
int block_size_log2,
|
||||
int num_samples_log2,
|
||||
int xmode, int data_type
|
||||
);
|
||||
|
||||
void get_meta_miptail_coord( int& x, int& y, int& z, int mip_in_tail, int blk_width_log2, int blk_height_log2, int blk_depth_log2 );
|
||||
|
||||
void get_mip_coord( int& x, int& y, int& z, int mip,
|
||||
int meta_blk_width_log2, int meta_blk_height_log2, int meta_blk_depth_log2,
|
||||
int data_blk_width_log2, int data_blk_height_log2,
|
||||
int& surf_width, int& surf_height, int& surf_depth, int epitch, int max_mip,
|
||||
int data_type, int bpp_log2, bool meta_linear );
|
||||
|
||||
void get_mip_coord_linear( int& x, int& y, int& z, int mip, int data_blk_width_log2, int data_blk_height_log2,
|
||||
int& surf_width, int& surf_height, int& surf_depth, int epitch, int max_mip, int data_type, int bpp_log2 );
|
||||
|
||||
void get_mip_coord_nonlinear( int& x, int& y, int& z, int mip, int meta_blk_width_log2, int meta_blk_height_log2, int meta_blk_depth_log2,
|
||||
int& surf_width, int& surf_height, int& surf_depth, int epitch, int max_mip, int data_type );
|
||||
|
||||
void get_meta_eq( CoordEq& metaaddr, int max_mip, int num_ses_log2, int num_rbs_log2, int &num_pipes_log2,
|
||||
int block_size_log2, int bpp_log2, int num_samples_log2, int max_comp_frag_log2,
|
||||
int pipe_interleave_log2, int xmode, int data_type, int meta_alignment, bool meta_linear);
|
||||
|
||||
#if 0
|
||||
long get_meta_addr( int x, int y, int z, int s, int mip,
|
||||
int surf_width, int surf_height, int surf_depth, int epitch,
|
||||
long surf_base, int pipe_xor, int max_mip,
|
||||
int num_ses_log2, int num_rbs_log2, int num_pipes_log2,
|
||||
int block_size_log2, int bpp_log2, int num_samples_log2, int max_comp_frag_log2,
|
||||
int pipe_interleave_log2, int xmode, int data_type, int meta_alignment, bool meta_linear);
|
||||
#endif
|
||||
|
||||
long get_meta_addr_calc( int x, int y, int z, int s,
|
||||
long surf_base, int element_bytes_log2, int num_samples_log2, int max_comp_frag_log2,
|
||||
long pitch, long slice,
|
||||
int max_mip,
|
||||
//int swizzle_mode,
|
||||
int xmode, int pipe_xor, int block_size_log2,
|
||||
/*int num_banks_log2,*/ int num_pipes_log2,
|
||||
int pipe_interleave_log2, int meta_alignment, int dim_type, int x_mip_org, int y_mip_org,
|
||||
int z_mip_org, int num_ses_log2, int num_rbs_log2, /*bool se_affinity_enable,*/ int data_type,
|
||||
int l2_metablk_w, int l2_metablk_h, int l2_metablk_d, bool meta_linear);
|
||||
|
||||
void Initialize(void);
|
||||
|
||||
public:
|
||||
enum XOR_RANGE {
|
||||
NONE = 0,
|
||||
XOR = 1,
|
||||
PRT = 2
|
||||
};
|
||||
|
||||
|
||||
enum DATA_TYPE_ENUM {
|
||||
DATA_COLOR1D,
|
||||
DATA_COLOR2D,
|
||||
DATA_COLOR3D_S,
|
||||
DATA_COLOR3D_Z,
|
||||
DATA_Z_STENCIL,
|
||||
DATA_FMASK,
|
||||
DATA_COLOR2D_LINEAR,
|
||||
DATA_COLOR3D_D_NOT_USED // should not be used; use COLOR2D instead
|
||||
};
|
||||
|
||||
enum META_ALIGNMENT {
|
||||
META_ALIGN_NONE,
|
||||
META_ALIGN_PIPE,
|
||||
META_ALIGN_RB,
|
||||
META_ALIGN_PIPE_RB
|
||||
};
|
||||
|
||||
CoordEq rb_equation[MAX_SES_LOG2+1][MAX_RBS_LOG2+1];
|
||||
CoordEq zaddr [4][4];
|
||||
CoordEq caddr [5][4];
|
||||
CoordEq c3addr[5][2];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#if !defined (__GFX9_GB_REG_H__)
|
||||
#define __GFX9_GB_REG_H__
|
||||
|
||||
/*
|
||||
* Copyright © 2017 Advanced Micro Devices, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sub license, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
|
||||
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the
|
||||
* next paragraph) shall be included in all copies or substantial portions
|
||||
* of the Software.
|
||||
*/
|
||||
|
||||
//
|
||||
// Make sure the necessary endian defines are there.
|
||||
//
|
||||
#if defined(LITTLEENDIAN_CPU)
|
||||
#elif defined(BIGENDIAN_CPU)
|
||||
#else
|
||||
#error "BIGENDIAN_CPU or LITTLEENDIAN_CPU must be defined"
|
||||
#endif
|
||||
|
||||
union GB_ADDR_CONFIG {
|
||||
struct {
|
||||
#if defined(LITTLEENDIAN_CPU)
|
||||
unsigned int NUM_PIPES : 3;
|
||||
unsigned int PIPE_INTERLEAVE_SIZE : 3;
|
||||
unsigned int MAX_COMPRESSED_FRAGS : 2;
|
||||
unsigned int BANK_INTERLEAVE_SIZE : 3;
|
||||
unsigned int : 1;
|
||||
unsigned int NUM_BANKS : 3;
|
||||
unsigned int : 1;
|
||||
unsigned int SHADER_ENGINE_TILE_SIZE : 3;
|
||||
unsigned int NUM_SHADER_ENGINES : 2;
|
||||
unsigned int NUM_GPUS : 3;
|
||||
unsigned int MULTI_GPU_TILE_SIZE : 2;
|
||||
unsigned int NUM_RB_PER_SE : 2;
|
||||
unsigned int ROW_SIZE : 2;
|
||||
unsigned int NUM_LOWER_PIPES : 1;
|
||||
unsigned int SE_ENABLE : 1;
|
||||
#elif defined(BIGENDIAN_CPU)
|
||||
unsigned int SE_ENABLE : 1;
|
||||
unsigned int NUM_LOWER_PIPES : 1;
|
||||
unsigned int ROW_SIZE : 2;
|
||||
unsigned int NUM_RB_PER_SE : 2;
|
||||
unsigned int MULTI_GPU_TILE_SIZE : 2;
|
||||
unsigned int NUM_GPUS : 3;
|
||||
unsigned int NUM_SHADER_ENGINES : 2;
|
||||
unsigned int SHADER_ENGINE_TILE_SIZE : 3;
|
||||
unsigned int : 1;
|
||||
unsigned int NUM_BANKS : 3;
|
||||
unsigned int : 1;
|
||||
unsigned int BANK_INTERLEAVE_SIZE : 3;
|
||||
unsigned int MAX_COMPRESSED_FRAGS : 2;
|
||||
unsigned int PIPE_INTERLEAVE_SIZE : 3;
|
||||
unsigned int NUM_PIPES : 3;
|
||||
#endif
|
||||
} bitfields, bits;
|
||||
unsigned int u32All;
|
||||
signed int i32All;
|
||||
float f32All;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -48,6 +48,7 @@ enum {
|
|||
FAMILY_VI,
|
||||
FAMILY_CZ,
|
||||
FAMILY_PI,
|
||||
FAMILY_AI,
|
||||
FAMILY_LAST,
|
||||
};
|
||||
|
||||
|
|
@ -174,4 +175,14 @@ enum {
|
|||
#define ASICREV_IS_STONEY(eChipRev) \
|
||||
((eChipRev >= STONEY_A0) && (eChipRev < CZ_UNKNOWN))
|
||||
|
||||
/* AI specific rev IDs */
|
||||
enum {
|
||||
AI_VEGA10_P_A0 = 0x01,
|
||||
|
||||
AI_UNKNOWN = 0xFF
|
||||
};
|
||||
|
||||
#define ASICREV_IS_VEGA10_P(eChipRev) \
|
||||
((eChipRev) >= AI_VEGA10_P_A0 && (eChipRev) < AI_UNKNOWN)
|
||||
|
||||
#endif /* AMDGPU_ID_H */
|
||||
|
|
|
|||
Loading…
Reference in New Issue